PointCloud.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2026 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);
 
void SmoothLaplacianCPU(const core::Tensor& points,
                        core::Tensor& smoothed_points,
                        size_t iterations,
                        double lambda,
                        int max_nn,
                        bool use_fixed_neighborhoods);
 
void SmoothTaubinCPU(const core::Tensor& points,
                     core::Tensor& smoothed_points,
                     size_t iterations,
                     double lambda,
                     double mu,
                     int max_nn,
                     bool use_fixed_neighborhoods);
 
void SmoothMLSCPU(const core::Tensor& points,
                  core::Tensor& smoothed_points,
                  core::Tensor& normals,
                  bool update_normals,
                  double radius,
                  int max_nn);
 
void SmoothBilateralCPU(const core::Tensor& points,
                        const core::Tensor& normals,
                        core::Tensor& smoothed_points,
                        double radius,
                        int max_nn,
                        double sigma_s,
                        double sigma_r);
 
#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);
 
void SmoothLaplacianCUDA(const core::Tensor& points,
                         core::Tensor& smoothed_points,
                         size_t iterations,
                         double lambda,
                         int max_nn,
                         bool use_fixed_neighborhoods);
 
void SmoothTaubinCUDA(const core::Tensor& points,
                      core::Tensor& smoothed_points,
                      size_t iterations,
                      double lambda,
                      double mu,
                      int max_nn,
                      bool use_fixed_neighborhoods);
 
void SmoothMLSCUDA(const core::Tensor& points,
                   core::Tensor& smoothed_points,
                   core::Tensor& normals,
                   bool update_normals,
                   double radius,
                   int max_nn);
 
void SmoothBilateralCUDA(const core::Tensor& points,
                         const core::Tensor& normals,
                         core::Tensor& smoothed_points,
                         double radius,
                         int max_nn,
                         double sigma_s,
                         double sigma_r);
#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);
 
void SmoothLaplacianSYCL(const core::Tensor& points,
                         core::Tensor& smoothed_points,
                         size_t iterations,
                         double lambda,
                         int max_nn,
                         bool use_fixed_neighborhoods);
 
void SmoothTaubinSYCL(const core::Tensor& points,
                      core::Tensor& smoothed_points,
                      size_t iterations,
                      double lambda,
                      double mu,
                      int max_nn,
                      bool use_fixed_neighborhoods);
 
void SmoothMLSSYCL(const core::Tensor& points,
                   core::Tensor& smoothed_points,
                   core::Tensor& normals,
                   bool update_normals,
                   double radius,
                   int max_nn);
 
void SmoothBilateralSYCL(const core::Tensor& points,
                         const core::Tensor& normals,
                         core::Tensor& smoothed_points,
                         double radius,
                         int max_nn,
                         double sigma_s,
                         double sigma_r);
#endif
 
}  // namespace pointcloud
}  // namespace kernel
}  // namespace geometry
}  // namespace t
}  // namespace open3d