Hello, when I use EstimateNormals and ComputeFPFHFeature, I found that geometry::KDTreeFlann kdtree (that is, building kdtree) takes a lot of time. I want to update it here. Do you have any suggestions for improvement?

Hi, I am trying to use cupoch to mapping with L515 Lidar sensor.

I am using python script 'realsense_occupancygrid_viewer.py'

My goal is using cupoch in Jetson Nano Developer Kit but now I am working in laptop.

My hardware environment (DELL XPS Laptop) is

• GTX 1050 Ti with 4042MiB memory
• nvidia driver 460.32.03
• CUDA Version 11.2

At first, the default voxel_size and resolution seems too high (ocgd = cph.geometry.OccupancyGrid(0.05, 512)). With default configuration, I got error

MemoryError: std::bad_alloc: RMM failure at:/home/runner/work/cupoch/cupoch/third_party/rmm/includermm/mr/device/pool_memory_resource.hpp:188: Maximum pool size exceeded.

So I changed it to ocgd = cph.geometry.OccupancyGrid(0.1, 128).

The script looks working but memory-usage(check with nvidia-smi) surge very quickly and got same memory error in temp = temp.voxel_down_sample(0.03)

I could not found memory related parameters. Can you suggest any solution to solve the problem?

Thank you.

As #60 did, I gave more tests on performance.

The passfilter function costs 0.096551ms to filter 119978 points to 5510.

But this output is in a simple execution context, you can find the code in #60

When the function run in ros callback context, the performance becomes really low, as 0.670853ms

Any ideas about the reason?

Hi everyone,

I am so greatly to hear that the libray was able to process 3D point cloud data using CUDA. Furthermore, cupoch is based on the functionality of Open3D.

From this issue: https://github.com/neka-nat/cupoch/issues/3, I know that the libray didn't support either MINGW or MSVC on windows.

However, my app developed with MSVC and ran on windows. Up to now, I use Open3D to implement my requirements on CPU yet. I'm very anxious to speed up my app by running on GPU.

When will windows be supported?

I have installed Cupoch via pip as described in the docs. The Python bindings seems to work, however, when building the cpp examples I get the following error:

In the examples subfolder, I ran

mkdir build
cd build
cmake ..
make

This was tested on an Nvidia Jetson Nano

Hi everyone,

I am trying to find the best way to copy points between host and device, and I found several methods in cupoch. So which method is of best performance(in time comsuming)

thrust copy constructable function

may not be the best

// d2h
auto pointcloud_points_host = pointcloud->GetPoints();
// h2d
void PointCloud::SetPoints(const thrust::host_vector<Eigen::Vector3f> &points) {
    points_ = points;
}

memcpy with thrust raw pointer

in src/cupoch/io/class_io/pointcloud_io.cu

void HostPointCloud::FromDevice(const geometry::PointCloud& pointcloud) {
    points_.resize(pointcloud.points_.size());
    normals_.resize(pointcloud.normals_.size());
    colors_.resize(pointcloud.colors_.size());
    cudaSafeCall(cudaMemcpy(points_.data(), thrust::raw_pointer_cast(pointcloud.points_.data()),
                            points_.size() * sizeof(Eigen::Vector3f), cudaMemcpyDeviceToHost));
    cudaSafeCall(cudaMemcpy(normals_.data(), thrust::raw_pointer_cast(pointcloud.normals_.data()),
                            normals_.size() * sizeof(Eigen::Vector3f), cudaMemcpyDeviceToHost));
    cudaSafeCall(cudaMemcpy(colors_.data(), thrust::raw_pointer_cast(pointcloud.colors_.data()),
                            colors_.size() * sizeof(Eigen::Vector3f), cudaMemcpyDeviceToHost));
}

void HostPointCloud::ToDevice(geometry::PointCloud& pointcloud) const {
    pointcloud.points_.resize(points_.size());
    pointcloud.normals_.resize(normals_.size());
    pointcloud.colors_.resize(colors_.size());
    cudaSafeCall(cudaMemcpy(thrust::raw_pointer_cast(pointcloud.points_.data()), points_.data(),
                            points_.size() * sizeof(Eigen::Vector3f), cudaMemcpyHostToDevice));
    cudaSafeCall(cudaMemcpy(thrust::raw_pointer_cast(pointcloud.normals_.data()), normals_.data(),
                            normals_.size() * sizeof(Eigen::Vector3f), cudaMemcpyHostToDevice));
    cudaSafeCall(cudaMemcpy(thrust::raw_pointer_cast(pointcloud.colors_.data()), colors_.data(),
                            colors_.size() * sizeof(Eigen::Vector3f), cudaMemcpyHostToDevice));
}

thrust::copy (even with cudastream)

src/cupoch/geometry/down_sample.cu

thrust::copy(utility::exec_policy(utility::GetStream(0))
                         ->on(utility::GetStream(0)),
                 range_points.begin(), range_points.end(),
                 output->points_.begin());
    if (has_normals) {
        thrust::strided_range<
                utility::device_vector<Eigen::Vector3f>::const_iterator>
                range_normals(normals_.begin(), normals_.end(), every_k_points);
        thrust::copy(utility::exec_policy(utility::GetStream(1))
                             ->on(utility::GetStream(1)),
                     range_normals.begin(), range_normals.end(),
                     output->normals_.begin());
    }
    if (has_colors) {
        thrust::strided_range<
                utility::device_vector<Eigen::Vector3f>::const_iterator>
                range_colors(colors_.begin(), colors_.end(), every_k_points);
        thrust::copy(utility::exec_policy(utility::GetStream(2))
                             ->on(utility::GetStream(2)),
                     range_colors.begin(), range_colors.end(),
                     output->colors_.begin());
    }
    cudaSafeCall(cudaDeviceSynchronize());

Hello @neka-nat,

A huge thanks for Cupoch

But im facing issue while building from source

system config

Nvidia geforce 1650 cuda toolkit 10.2 ubuntu 19.10 inbuilt Eigen : eigen 3.3.7

I tried with both eigen3 3rdparty and inbuilt version using cmake -DBUILD_EIGEN3=OFF and cmake -DBUILD_EIGEN3=ON

the make make install-pip-package -j is getting killed

few error snippets are

/home/shankar/3D projects/cupoch/cupoch/src/cupoch/geometry/boundingvolume.cu(26): error: identifier "Eigen::MatrixBase< ::Eigen::Matrix<float, (int)3, (int)3, (int)0, (int)3, (int)3> > ::determinant const" is undefined in device code

36 errors detected in the compilation of "/tmp/tmpxft_00007184_00000000-6_boundingvolume.cpp1.ii". CMake Error at cupoch_geometry_generated_boundingvolume.cu.o.cmake:280 (message): Error generating file /home/shankar/3D projects/cupoch/cupoch/build/src/cupoch/geometry/CMakeFiles/cupoch_geometry.dir//./cupoch_geometry_generated_boundingvolume.cu.o

make[1]: *** [CMakeFiles/Makefile2:755: src/cupoch/geometry/CMakeFiles/cupoch_geometry.dir/all] Error 2 make: *** [Makefile:130: all] Error 2

Hello,

I tried to test Cupoch on Windows 10.

1. Build with VS2019 --> no problem.
2. Test normal calculation with the same 18519 points PCD --> Open3D needs 10ms, Cupoch needs 52 ms

Here is the code

pcd->EstimateNormals(open3d::geometry::KDTreeSearchParamHybrid(radius_normal, MAX_NN));
pcd_gpu->EstimateNormals(cupoch::geometry::KDTreeSearchParamHybrid(radius_normal, MAX_NN));

I guess that the calculation was not run on GPU. But how to make sure it is run on GPU? I already had this line in my code

cupoch::utility::InitializeAllocator();

All python examples complain about cph.PoolAllocation. Has anyone else seen that? cuda toolkit 11.6 NVIDIA-SMI 510.60.02 Driver Version: 510.60.02 CUDA Version: 11.6
There is plenty of GPU mem available. The 1G fits in easily. I can reduce the size heavily and same issue

traceback (most recent call last): File "basic/benchmarks3.py", line 5, in cph.initialize_allocator(cph.PoolAllocation, 1000000000) MemoryError: std::bad_alloc: RMM failure at:/home/adolf/cupoch/third_party/rmm/include/rmm/mr/device/pool_memory_resource.hpp:179: Maximum pool size exceeded

Test using a small point cloud with 15million points, and it takes extremely long to process. The gpu is nvidia a600 with 48gb memory. Cuda version is 11.2. Is cuml used in the library? It suffers the batch shrinking problem

[2021-10-12 12:00:22.331] [debug] Read geometry::PointCloud: 15636915 vertices.

[2021-10-12 12:00:22.340] [debug] [RemoveNoneFinitePoints] 15636915 nan points have been removed. (15636915, 3) (15636915, 3) block_0 has 15636915 points | ID | GPU | MEM |

| 0 | 18% | 2% | [2021-10-12 12:00:22.798] [debug] Precompute Neighbours Precompute Neighbours[================> ] 40%

Hi @neka-nat,

I have created the following simple ROS node to convert from a PointCloud2 to a Cupoch point cloud back to PointCloud2. This is based on your latest python example to convert from Cupoch to PointCloud2, however using the unchanged pointcloud does not work:

class PointCloudFilter:

    def __init__(self):
        self._point_cloud_sub = rospy.Subscriber('/camera1/depth/color/points', PointCloud2, self.point_cloud_callback)
        self._filtered_point_cloud_pub = rospy.Publisher('/camera1/depth/color/filtered', PointCloud2, queue_size=1)

    def point_cloud_callback(self, msg):
        pointcloud = cph.io.create_from_pointcloud2_msg(msg.data, cph.io.PointCloud2MsgInfo.default(msg.width, msg.point_step))

        data, info = cph.io.create_to_pointcloud2_msg(pointcloud)

if __name__ == '__main__':
    rospy.init_node('point_cloud_filter')
    filter = PointCloudFilter()
    rospy.spin()

However, this results in the following error: [error] [CreateToPointCloud2Msg] Width and Step sizes must be greater than 0.

This is running on my laptop (x86_64), Python 3.6.9, CUDA 11.4. Thank you in advance.

import cupoch as cph

target = cph.io.read_point_cloud("PointCloud_1.ply")
source = cph.io.read_point_cloud("PointCloud_2.ply")

import numpy as np
source.estimate_normals(cph.geometry.KDTreeSearchParamRadius(radius=1 * 2, max_nn=30))
target.estimate_normals(cph.geometry.KDTreeSearchParamRadius(radius=1 * 2, max_nn=30))
reg_p2p = cph.registration.registration_icp(
    source, target, 0.15,np.identity(4).astype(np.float32),
    estimation_method = cph.registration.TransformationEstimationPointToPlane())
print(reg_p2p.transformation,reg_p2p.inlier_rmse,reg_p2p.fitness)

result:

[warning] check_det failed, empty vector will be returned [[ 9.9999994e-01 -2.3211574e-04 3.1052838e-04 -5.6119312e-02] [ 2.3210575e-04 1.0000000e+00 4.1026891e-05 1.5950035e-01] [-3.1053583e-04 -4.0970357e-05 9.9999994e-01 1.3352202e-01] [ 0.0000000e+00 0.0000000e+00 0.0000000e+00 1.0000000e+00]] 0.11659056693315506 0.5279329419136047

def icp_p2plane(source,target,distance):
    source.estimate_normals(o3d.geometry.KDTreeSearchParamHybrid(radius=1*2,max_nn=30))
    target.estimate_normals(o3d.geometry.KDTreeSearchParamHybrid(radius=1*2,max_nn=30))
    reg_p2p = o3d.pipelines.registration.registration_icp(
        source, target, distance,init = np.identity(4).astype(np.float32),
        estimation_method = o3d.pipelines.registration.TransformationEstimationPointToPlane())
    return reg_p2p

target = o3d.io.read_point_cloud("PointCloud_1.ply")
source = o3d.io.read_point_cloud("PointCloud_2.ply")
reg_p2p_cpu = icp_p2plane(source,target,0.15)
print(reg_p2p_cpu.transformation,reg_p2p_cpu.inlier_rmse,reg_p2p_cpu.fitness)

result: [[ 9.99999876e-01 -1.51703967e-04 4.75125722e-04 -3.06633247e-02] [ 1.51902093e-04 9.99999902e-01 -4.16987856e-04 5.89422629e-01] [-4.75062417e-04 4.17059977e-04 9.99999800e-01 2.32936885e-01] [ 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00]] 0.0851198294781214 0.8659489299658403

PointCloud_2.ply.zip PointCloud_1.ply.zip

edit: if i simply use source.estimate_normals(), the results are also different it seems like during icp process, some condition were not considered and then the program breaks and throw halfway output. really appreciate your help.

When I call the fgr algorithm, the prompt crashes here, line 141 in fastglobalregistration.cu thrust::sort(utility::exec_policy(0)->on(0), corres.begin(), corres.end()); and the following error is prompted, How to solve this problem please? thank you！

Hi This library is awesome! Thank you, author. I am working on big-size point clouds (in ply format). I am trying this code (https://github.com/neka-nat/cupoch/blob/master/examples/python/advanced/pointcloud_outlier_removal.py) to filter point cloud noises. On a few MBs or around 1Gbs size point cloud file works like a charm. But when I try on a bigger point cloud file(5GB - approx 97million points) then I after remove_statistical_outlier I am getting cudaErrorMemoryAllocation out of memory.

cl, ind = voxel_down_pcd.remove_statistical_outlier(nb_neighbors=20, std_ratio=2.0)
Memory Error: std::bad_alloc: CUDA error at /home/path/cupoch/cupoch/third_party/rmm/include/rmm/mr/device/cuda_memory_resource.hpp:69: cudaErrorMemoryAllocation out of memory

I really wanted to use this library as it is much faster than other alternatives. Can you help me with how to solve this issue? I really appreciate this. Thank you again in advance!! P.S. System: Ubuntu 20.04 RTX3090 24GB I installed cupoch using pip

Hello, Any plans to add Poisson's surface reconstruction that runs on GPU? Currently I am doing everything(registration,cropping etc..) with cupoch gpu, saving the ply file on hardisk and then using open 3d to read the ply file from harddisk and then do the poisons surface reconstruction on cpu with open 3d

Cupoch having Poisson's surface reconstruction on gpu will be really helpful.

Hi,

I think that in many aspects Cupoch and Open3D are really mutually complementary. But when using both together side by side, there may issue variable redefinition error from the compiler, since both may use the same 3rd party lib in several parts?

Perhaps, could add some flags in cmake files to deal with it?

Thanks