Adding points to RhinoCommon pointcloud

Petras_Vestartas · January 14, 2021, 6:48pm

I have 1500 000 doubles that I am converting to Points xyz coordinates to add to a PointCloud, same for normals and colors.

Can someone explain me why this takes 0.24 sec:

        int cc = 0;
        for (int i = 0; i < P.Length; i += 3) {
            newCloud.Add( new Point3d(P[i + 0], P[i + 1], P[i + 2])            );
            newCloud[cc].Color = System.Drawing.Color.FromArgb((int)C[i  + 0], (int)C[i + 1], (int)C[i  + 2]);
            cc++;
        }

        cc = 0;
        for (int i = 0; i < P.Length; i += 3) {
            newCloud[cc].Normal = new Vector3d(N[i + 0], N[i + 1], N[i + 2]);
            cc++;
        }

And this 5 sec:

        int cc = 0;
        for (int i = 0; i < P.Length; i += 3) {
            newCloud.Add(  new Point3d(P[i + 0], P[i + 1], P[i + 2])      );
            newCloud[cc].Normal = new Vector3d(N[i + 0], N[i  + 1], N[i + 2]);
            newCloud[cc].Color = System.Drawing.Color.FromArgb((int)C[i  + 0], (int)C[i + 1], (int)C[i  + 2]);
            cc++;
        }

dale · January 14, 2021, 10:49pm

Hi @Petras_Vestartas,

It’s all about memory allocation (and reallocation) for the internal arrays that make up the point cloud.

To be most efficient, use this version of PointCloud.Add, or better yet use this version of PointCloud.AddRange.

– Dale

Petras_Vestartas · January 14, 2021, 11:18pm

Thanks,

The first one took 5 sec as well.
I ll try the second one tomorrow.

I imagine Pointcloud is allocated in C++ not .Net?
Every time I get element by index, does rhino interop with c++?

stevebaer · January 14, 2021, 11:23pm

Yes. Use the overload of Add that adds the location, color, and normal all at once. You should see an improvement in speed.

Dale is right that AddRange could even give you faster results, but the simple change to use a single Add should help a lot.

You can see what is happening here

github.com

mcneel/rhino3dm/blob/main/src/dotnet/opennurbs/opennurbs_pointcloud.cs#L458


      
          public int Count
          {
            get
            {
              IntPtr const_ptr_this = ConstPointer();
              return UnsafeNativeMethods.ON_PointCloud_GetInt(const_ptr_this, idx_PointCount);
            }
          }
          /// <summary>
          /// Gets the item at the given index.
          /// </summary>
          /// <param name="index">Index of item to retrieve.</param>
          /// <returns>The item at the given index.</returns>
          public PointCloudItem this[int index]
          {
            get
            {
              if (index < 0) { throw new IndexOutOfRangeException("index must be larger than or equal to zero"); }
              if (index >= Count) { throw new IndexOutOfRangeException("index must be smaller than the Number of points in the PointCloud"); }
              return new PointCloudItem(this, index);
            }

Petras_Vestartas · January 14, 2021, 11:28pm

There is no improvement, something wicked is with normal with that constructor (position, normal, color) same 5 sec.

I ll try addrange, I hope it will be a bit faster than 0.2 sec.

Is it also possible to somehow get around this problem? :

I get pointcloud in grasshopper
convert positions, normals, colors to arrays of doubles
I pass these arrays via Pinvoke to C++
In C++ I construct 3rd party library pointcloud and do something with it
I again convert points, normals, colors to double arrays to Pinvoke
In C# I construct Pointcloud in Rhino .NET which is again sends data to Rhino C++.

What are you doing else to avoid 4 times conversion? Is there any better practices for PInvoke? Simply looping in .Net through pointcloud is very slow even with Parallel loops.

Is it possible to somehow construct Rhino Pointcloud in C++ and share it with .NET to avoid looping through the same points?

stevebaer · January 14, 2021, 11:37pm

Writing your own pInvoke sounds like way too much work. If you have a sample that we can repeat this with, we should be able to figure out what is going wrong and make improvements

Petras_Vestartas · January 14, 2021, 11:39pm

I will share the code tomorrow to make things clearer;)

Petras_Vestartas · January 15, 2021, 8:41am

Dear @stevebaer and @dale this is my source code, do you think it is possible to avoid conversion to doubles and directly pass C# PointCloud to C++ ? (Let me know if you need compiled dll, I can add it too)

The pointcloud processing methods I am using is fast and the main bottleneck is this data transfer via PInvoke.

Headers

C#:

    [DllImport(dllNameOpen3D, CallingConvention = CallingConvention.Cdecl)]
    internal static extern int Open3DDownsample(

      [MarshalAs(UnmanagedType.LPArray)] double[] p, ulong p_c,
      [MarshalAs(UnmanagedType.LPArray)] double[] n, ulong n_n,
      [MarshalAs(UnmanagedType.LPArray)] double[] c, ulong c_c,

      int numberOfPoints,

      ref IntPtr p_o, ref int p_c_o,
      ref IntPtr n_o, ref int n_n_o,
      ref IntPtr c_o, ref int c_c_o
  );

C++:

PINVOKE void Open3DDownsample (

    double* p, size_t p_c,
    double* n, size_t n_c,
    double* c, size_t c_c,

    int numberOfPoints,

    double*& p_o, int& p_c_o,
    double*& n_o, int& n_c_o,
    double*& c_o, int& c_c_o
);

Implementations:

C# :

public static PointCloud Downsample(PointCloud cloud, int numberOfPoints = 5000) {

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //Conversion from Rhino PointCloud to Flat Array
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////




    double[] p = new double[cloud.Count * 3];
    ulong p_c = (ulong)cloud.Count;

    double[] n =new double[cloud.Count * 3] ;
    ulong n_c = p_c;

    double[] c = new double[cloud.Count * 3];
    ulong c_c = p_c;

    bool hasColors = cloud.ContainsColors;

    System.Threading.Tasks.Parallel.For(0, cloud.Count, i =>
    {
    //for (int i = 0; i < cloud.Count; i++) {
        p[i * 3 + 0] = cloud[i].Location.X;
        p[i * 3 + 1] = cloud[i].Location.Y;
        p[i * 3 + 2] = cloud[i].Location.Z;
        if (cloud.ContainsNormals) {
            n[i * 3 + 0] = cloud[i].Normal.X;
            n[i * 3 + 1] = cloud[i].Normal.Y;
            n[i * 3 + 2] = cloud[i].Normal.Z;
        }
        if (cloud.ContainsColors) {
            c[i * 3 + 0] = cloud[i].Color.R;
            c[i * 3 + 1] = cloud[i].Color.G;
            c[i * 3 + 2] = cloud[i].Color.B;
        }
   
    });


    //watch.Stop();
   // Rhino.RhinoApp.WriteLine("Convert PointCloud to double array "+watch.ElapsedMilliseconds.ToString());


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //Call C++
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    IntPtr p_pointer = IntPtr.Zero;
    int p_pointer_c = 0;
    IntPtr n_pointer = IntPtr.Zero;
    int n_pointer_c = 0;
    IntPtr c_pointer = IntPtr.Zero;
    int c_pointer_c = 0;


    UnsafeOpen3D.Open3DDownsample(
        p, p_c,
        n, n_c,
        c, c_c,
        numberOfPoints,
        ref p_pointer, ref p_pointer_c,
        ref n_pointer, ref n_pointer_c,
        ref c_pointer, ref c_pointer_c
        );

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //Convert Pointers to double arrays
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //Convert faceIndicesPointer to C# int[]


    double[] P = new double[p_pointer_c ];
    Marshal.Copy(p_pointer, P, 0, P.Length);

    double[] N = new double[n_pointer_c ];
    Marshal.Copy(n_pointer, N, 0, P.Length);

    double[] C = new double[c_pointer_c ];
    Marshal.Copy(c_pointer, C, 0, P.Length);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //Release C++ memory
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UnsafeOpen3D.ReleaseDouble(p_pointer, true);
    UnsafeOpen3D.ReleaseDouble(n_pointer, true);
    UnsafeOpen3D.ReleaseDouble(c_pointer, true);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //Convert C++ to C# Pointcloud
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PointCloud newCloud = new PointCloud();


    for (int i = 0; i < P.Length; i += 3) {
        newCloud.Add(new Point3d(P[i + 0], P[i + 1], P[i + 2]));

        if (C[i + 0] == 0 && C[i + 1] == 0 && C[i + 2] == 0) continue;
        newCloud[(int)Math.Round((i / 3.0))].Color = System.Drawing.Color.FromArgb((int)C[i + 0], (int)C[i + 1], (int)C[i + 2]);

    }


    for (int i = 0; i < P.Length; i += 3) {
        if (N[i + 0] == 0 && N[i + 1] == 0 && N[i + 2] == 0) continue;
        newCloud[(int)Math.Round((i / 3.0))].Normal = new Vector3d(N[i + 0], N[i + 1], N[i + 2]);
    }




    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //Output
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return newCloud;

}

C++:

PINVOKE void Open3DDownsample (
double* p, size_t p_c, 
double* n, size_t n_c, 
double* c, size_t c_c,

int numberOfPoints,

double*& p_o, int& p_c_o, 
double*& n_o, int& n_c_o, 
double*& c_o, int& c_c_o) {
 

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Convert Input to Open3D PointCloud
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
shared_ptr<PC> Open3DCloud (new PC);

Open3DCloud->points_.resize (p_c);
Open3DCloud->normals_.resize (p_c);
Open3DCloud->colors_.resize (p_c);



for ( size_t i = 0; i < p_c; i++ ) {

    Open3DCloud->points_[i] = Eigen::Vector3d (p[3 * i + 0], p[3 * i + 1], p[3 * i + 2]);
    Open3DCloud->normals_[i] = Eigen::Vector3d (n[3 * i + 0], n[3 * i + 1], n[3 * i + 2]);
    Open3DCloud->colors_[i] = Eigen::Vector3d (c[3 * i + 0], c[3 * i + 1], c[3 * i + 2]);

}








////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Run Open3D Method
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int nOfPoints = numberOfPoints;
int b = (int)(Open3DCloud->points_.size () * (1.0 / numberOfPoints *1.0));
int nth = max (1,b );

Open3DCloud = Open3DCloud->UniformDownSample (nth);



////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Run Open3D Method
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

p_c_o = Open3DCloud->points_.size ()*3;
p_o = new double[p_c_o];

n_c_o = Open3DCloud->normals_.size ()*3 ;
n_o = new double[n_c_o];

c_c_o = Open3DCloud->colors_.size ()*3 ;
c_o = new double[c_c_o];

int i = 0;
for ( auto& p : Open3DCloud->points_ ) {
    p_o[i++] = p.x ();
    p_o[i++] = p.y ();
    p_o[i++] = p.z ();


}

i = 0;
for ( auto& p : Open3DCloud->normals_ ) {
    n_o[i++] = p.x ();
    n_o[i++] = p.y ();
    n_o[i++] = p.z ();


}

i = 0;
for ( auto& p : Open3DCloud->colors_ ) {
    c_o[i++] = p.x ();
    c_o[i++] = p.y ();
    c_o[i++] = p.z ();

}

}

Something is just wrong with Add and AddRange constructor when 3 values are given, look at the performance below for 5000 points for creating a pointcloud in .NET. And yes I refereshed several times components to get a correct time stamp:

stevebaer · May 23, 2021, 4:15pm

I’m sorry, this one slipped through the cracks. We need to add functionality to our PointCloud class to directly expose the underlying arrays in order to give you much faster access. We have already written this type of functionality on the Mesh class so it shouldn’t be too hard to do.
https://mcneel.myjetbrains.com/youtrack/issue/RH-64318

Petras_Vestartas · May 23, 2021, 8:26pm

Thank you. Would it be possible to update me after this addition?

stevebaer · May 23, 2021, 8:29pm

Yes; this post is referenced in our bugtracking system. When that is done you should see a post from Brian here that mentions this issue being fixed

Topic		Replies	Views
Rhino.Geometry.PointCloud RhinoCommon feature request Rhino Developer windows , rhinocommon , featurerequest	5	510	August 23, 2023
PointCloud.AddRange does not accept list of Point3d Rhino Developer python	3	782	December 26, 2018
New Rhino.Geometry.PointCloudItem every time point is added Grasshopper Developer windows , csharp	4	333	June 20, 2024
C++ Array of ON_PointCloud Rhino Developer	4	263	December 10, 2020
PointCloud AddRange Scripting python	41	2529	August 2, 2019

Adding points to RhinoCommon pointcloud

Related topics