PointCloud.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <optional>
 
#include "open3d/core/Tensor.h"
 
namespace open3d {
namespace t {
namespace geometry {
namespace kernel {
namespace pointcloud {
 
void Unproject(
        const core::Tensor& depth,
        std::optional<std::reference_wrapper<const core::Tensor>> image_colors,
        core::Tensor& points,
        std::optional<std::reference_wrapper<core::Tensor>> colors,
        const core::Tensor& intrinsics,
        const core::Tensor& extrinsics,
        float depth_scale,
        float depth_max,
        int64_t stride);
 
void Project(core::Tensor& depth,
             std::optional<std::reference_wrapper<core::Tensor>> image_colors,
             const core::Tensor& points,
             std::optional<std::reference_wrapper<const core::Tensor>> colors,
             const core::Tensor& intrinsics,
             const core::Tensor& extrinsics,
             float depth_scale,
             float depth_max);
 
#ifdef BUILD_SYCL_MODULE
void ProjectSYCL(
        core::Tensor& depth,
        std::optional<std::reference_wrapper<core::Tensor>> image_colors,
        const core::Tensor& points,
        std::optional<std::reference_wrapper<const core::Tensor>> colors,
        const core::Tensor& intrinsics,
        const core::Tensor& extrinsics,
        float depth_scale,
        float depth_max);
#endif
 
void GetPointMaskWithinAABB(const core::Tensor& points,
                            const core::Tensor& min_bound,
                            const core::Tensor& max_bound,
                            core::Tensor& mask);
 
void GetPointMaskWithinOBB(const core::Tensor& points,
                           const core::Tensor& center,
                           const core::Tensor& rotation,
                           const core::Tensor& extent,
                           core::Tensor& mask);
 
void UnprojectCPU(
        const core::Tensor& depth,
        std::optional<std::reference_wrapper<const core::Tensor>> image_colors,
        core::Tensor& points,
        std::optional<std::reference_wrapper<core::Tensor>> colors,
        const core::Tensor& intrinsics,
        const core::Tensor& extrinsics,
        float depth_scale,
        float depth_max,
        int64_t stride);
 
void ProjectCPU(
        core::Tensor& depth,
        std::optional<std::reference_wrapper<core::Tensor>> image_colors,
        const core::Tensor& points,
        std::optional<std::reference_wrapper<const core::Tensor>> colors,
        const core::Tensor& intrinsics,
        const core::Tensor& extrinsics,
        float depth_scale,
        float depth_max);
 
void GetPointMaskWithinAABBCPU(const core::Tensor& points,
                               const core::Tensor& min_bound,
                               const core::Tensor& max_bound,
                               core::Tensor& mask);
 
void GetPointMaskWithinOBBCPU(const core::Tensor& points,
                              const core::Tensor& center,
                              const core::Tensor& rotation,
                              const core::Tensor& extent,
                              core::Tensor& mask);
 
void NormalizeNormalsCPU(core::Tensor& normals);
 
void OrientNormalsToAlignWithDirectionCPU(core::Tensor& normals,
                                          const core::Tensor& direction);
 
void OrientNormalsTowardsCameraLocationCPU(const core::Tensor& points,
                                           core::Tensor& normals,
                                           const core::Tensor& camera);
 
void ComputeBoundaryPointsCPU(const core::Tensor& points,
                              const core::Tensor& normals,
                              const core::Tensor& indices,
                              const core::Tensor& counts,
                              core::Tensor& mask,
                              double angle_threshold);
 
#ifdef BUILD_SYCL_MODULE
void UnprojectSYCL(
        const core::Tensor& depth,
        std::optional<std::reference_wrapper<const core::Tensor>> image_colors,
        core::Tensor& points,
        std::optional<std::reference_wrapper<core::Tensor>> colors,
        const core::Tensor& intrinsics,
        const core::Tensor& extrinsics,
        float depth_scale,
        float depth_max,
        int64_t stride);
 
void GetPointMaskWithinAABBSYCL(const core::Tensor& points,
                                const core::Tensor& min_bound,
                                const core::Tensor& max_bound,
                                core::Tensor& mask);
 
void GetPointMaskWithinOBBSYCL(const core::Tensor& points,
                               const core::Tensor& center,
                               const core::Tensor& rotation,
                               const core::Tensor& extent,
                               core::Tensor& mask);
 
void NormalizeNormalsSYCL(core::Tensor& normals);
 
void OrientNormalsToAlignWithDirectionSYCL(core::Tensor& normals,
                                           const core::Tensor& direction);
 
void OrientNormalsTowardsCameraLocationSYCL(const core::Tensor& points,
                                            core::Tensor& normals,
                                            const core::Tensor& camera);
 
void ComputeBoundaryPointsSYCL(const core::Tensor& points,
                               const core::Tensor& normals,
                               const core::Tensor& indices,
                               const core::Tensor& counts,
                               core::Tensor& mask,
                               double angle_threshold);
#endif
 
#ifdef BUILD_CUDA_MODULE
void UnprojectCUDA(
        const core::Tensor& depth,
        std::optional<std::reference_wrapper<const core::Tensor>> image_colors,
        core::Tensor& points,
        std::optional<std::reference_wrapper<core::Tensor>> colors,
        const core::Tensor& intrinsics,
        const core::Tensor& extrinsics,
        float depth_scale,
        float depth_max,
        int64_t stride);
 
void ProjectCUDA(
        core::Tensor& depth,
        std::optional<std::reference_wrapper<core::Tensor>> image_colors,
        const core::Tensor& points,
        std::optional<std::reference_wrapper<const core::Tensor>> colors,
        const core::Tensor& intrinsics,
        const core::Tensor& extrinsics,
        float depth_scale,
        float depth_max);
 
void GetPointMaskWithinAABBCUDA(const core::Tensor& points,
                                const core::Tensor& min_bound,
                                const core::Tensor& max_bound,
                                core::Tensor& mask);
 
void GetPointMaskWithinOBBCUDA(const core::Tensor& points,
                               const core::Tensor& center,
                               const core::Tensor& rotation,
                               const core::Tensor& extent,
                               core::Tensor& mask);
 
void NormalizeNormalsCUDA(core::Tensor& normals);
 
void OrientNormalsToAlignWithDirectionCUDA(core::Tensor& normals,
                                           const core::Tensor& direction);
 
void OrientNormalsTowardsCameraLocationCUDA(const core::Tensor& points,
                                            core::Tensor& normals,
                                            const core::Tensor& camera);
 
void ComputeBoundaryPointsCUDA(const core::Tensor& points,
                               const core::Tensor& normals,
                               const core::Tensor& indices,
                               const core::Tensor& counts,
                               core::Tensor& mask,
                               double angle_threshold);
#endif
 
void EstimateCovariancesUsingHybridSearchCPU(const core::Tensor& points,
                                             core::Tensor& covariances,
                                             const double& radius,
                                             const int64_t& max_nn);
 
void EstimateCovariancesUsingKNNSearchCPU(const core::Tensor& points,
                                          core::Tensor& covariances,
                                          const int64_t& max_nn);
 
void EstimateCovariancesUsingRadiusSearchCPU(const core::Tensor& points,
                                             core::Tensor& covariances,
                                             const double& radius);
 
void EstimateNormalsFromCovariancesCPU(const core::Tensor& covariances,
                                       core::Tensor& normals,
                                       const bool has_normals);
 
void EstimateColorGradientsUsingHybridSearchCPU(const core::Tensor& points,
                                                const core::Tensor& normals,
                                                const core::Tensor& colors,
                                                core::Tensor& color_gradient,
                                                const double& radius,
                                                const int64_t& max_nn);
 
void EstimateColorGradientsUsingKNNSearchCPU(const core::Tensor& points,
                                             const core::Tensor& normals,
                                             const core::Tensor& colors,
                                             core::Tensor& color_gradient,
                                             const int64_t& max_nn);
 
void EstimateColorGradientsUsingRadiusSearchCPU(const core::Tensor& points,
                                                const core::Tensor& normals,
                                                const core::Tensor& colors,
                                                core::Tensor& color_gradient,
                                                const double& radius);
 
#ifdef BUILD_SYCL_MODULE
void EstimateColorGradientsUsingHybridSearchSYCL(const core::Tensor& points,
                                                 const core::Tensor& normals,
                                                 const core::Tensor& colors,
                                                 core::Tensor& color_gradient,
                                                 const double& radius,
                                                 const int64_t& max_nn);
 
void EstimateColorGradientsUsingKNNSearchSYCL(const core::Tensor& points,
                                              const core::Tensor& normals,
                                              const core::Tensor& colors,
                                              core::Tensor& color_gradient,
                                              const int64_t& max_nn);
 
void EstimateColorGradientsUsingRadiusSearchSYCL(const core::Tensor& points,
                                                 const core::Tensor& normals,
                                                 const core::Tensor& colors,
                                                 core::Tensor& color_gradient,
                                                 const double& radius);
#endif
 
#ifdef BUILD_CUDA_MODULE
void EstimateCovariancesUsingHybridSearchCUDA(const core::Tensor& points,
                                              core::Tensor& covariances,
                                              const double& radius,
                                              const int64_t& max_nn);
 
void EstimateCovariancesUsingKNNSearchCUDA(const core::Tensor& points,
                                           core::Tensor& covariances,
                                           const int64_t& max_nn);
 
void EstimateCovariancesUsingRadiusSearchCUDA(const core::Tensor& points,
                                              core::Tensor& covariances,
                                              const double& radius);
 
void EstimateNormalsFromCovariancesCUDA(const core::Tensor& covariances,
                                        core::Tensor& normals,
                                        const bool has_normals);
 
void EstimateColorGradientsUsingHybridSearchCUDA(const core::Tensor& points,
                                                 const core::Tensor& normals,
                                                 const core::Tensor& colors,
                                                 core::Tensor& color_gradient,
                                                 const double& radius,
                                                 const int64_t& max_nn);
 
void EstimateColorGradientsUsingKNNSearchCUDA(const core::Tensor& points,
                                              const core::Tensor& normals,
                                              const core::Tensor& colors,
                                              core::Tensor& color_gradient,
                                              const int64_t& max_nn);
 
void EstimateColorGradientsUsingRadiusSearchCUDA(const core::Tensor& points,
                                                 const core::Tensor& normals,
                                                 const core::Tensor& colors,
                                                 core::Tensor& color_gradient,
                                                 const double& radius);
#endif
 
#ifdef BUILD_SYCL_MODULE
void EstimateCovariancesUsingHybridSearchSYCL(const core::Tensor& points,
                                              core::Tensor& covariances,
                                              const double& radius,
                                              const int64_t& max_nn);
 
void EstimateCovariancesUsingKNNSearchSYCL(const core::Tensor& points,
                                           core::Tensor& covariances,
                                           const int64_t& max_nn);
 
void EstimateCovariancesUsingRadiusSearchSYCL(const core::Tensor& points,
                                              core::Tensor& covariances,
                                              const double& radius);
 
void EstimateNormalsFromCovariancesSYCL(const core::Tensor& covariances,
                                        core::Tensor& normals,
                                        const bool has_normals);
#endif
 
}  // namespace pointcloud
}  // namespace kernel
}  // namespace geometry
}  // namespace t
}  // namespace open3d