Handle vs SharedPointer

[petrasvestartas]

Hi,

I would like to ask if I could use Shared Pointer from the C++ standard library instead of Handle?
Or Handle does much more than shared pointer?

[dpasukhi]

The difference between OpenCascade's Handle and C++'s std::shared_ptr is similar to the difference between std::shared_ptr and boost::intrusive_ptr.

Key differences:

1. Intrusive vs. Non-intrusive Reference Counting:

   • Handle<T> is intrusive - the reference count is stored in the object itself
   • std::shared_ptr is non-intrusive - the reference count is stored separately from the object

2. Object Requirements:

   • Handle<T> requires objects to inherit from Standard_Transient
   • std::shared_ptr can wrap any object

3. Memory Layout:

   • Handle<T> has less overhead since the reference count is inside the object
   • std::shared_ptr has more overhead (typically two pointers - one to the object and one to the control block)

4. Creation Pattern:

   • OCCT objects are designed to be created with new and immediately wrapped in a Handle
   • This is why you see patterns like: Handle(SomeClass) obj = new SomeClass()

5. Integration with OCCT:

   • OCCT's entire class hierarchy and serialization system expects Handle<T>
   • Many OCCT functions accept and return Handle<T> objects

If you want to use OCCT effectively, it's better to stick with Handle<T> for OCCT objects. Mixing smart pointer types could lead to reference counting issues and potentially memory leaks or double-frees.

You can still use std::shared_ptr for your own classes that don't need to integrate with OCCT's persistent object framework.

[petrasvestartas]

Thank you.

The reason to ask is that I am writing a Python wrapper. I can expose a surface as a shared pointer.
Then I can transfer geometry via Tesselation as vertices and faces 3 times faster than existing OCC wrapper.

But it can be done a bit faster :) I hope.

Problem: I need to iterate through faces and vertices and copy this data to a new collection.
Can OCC triangulation expose one single array for vertex coordinates and one single array for faces?

This is what I am struggling with:

std::tuple<Eigen::Matrix<double, Eigen::Dynamic, 3, Eigen::RowMajor>, 
          Eigen::Matrix<int, Eigen::Dynamic, 3, Eigen::RowMajor>> get_mesh(
    const NB_Geom_BSplineSurface& nurbs_surface, 
    double deflection = 0.01) {
    const Handle(Geom_BSplineSurface)& surface = nurbs_surface.surface;
    
    // Create a topological face from the surface
    TopoDS_Face face = BRepBuilderAPI_MakeFace(surface, 1e-6);
    
    // Mesh the face with specified deflection
    BRepMesh_IncrementalMesh mesh(face, deflection);
    
    // Get the triangulation
    TopLoc_Location loc;
    Handle(Poly_Triangulation) triangulation = BRep_Tool::Triangulation(face, loc);
    
    if (triangulation.IsNull()) {
        throw std::runtime_error("Failed to tessellate the surface");
    }
    
    // Get size of vertex and triangle arrays
    const int num_vertices = triangulation->NbNodes();
    const int num_triangles = triangulation->NbTriangles();
    
    // Create matrices for vertices and triangles
    Eigen::Matrix<double, Eigen::Dynamic, 3, Eigen::RowMajor> vertices(num_vertices, 3);
    Eigen::Matrix<int, Eigen::Dynamic, 3, Eigen::RowMajor> triangles(num_triangles, 3);
    
    // Extract vertices
    for (int i = 1; i <= num_vertices; i++) {
        gp_Pnt p = triangulation->Node(i).Transformed(loc);
        vertices(i-1, 0) = p.X();
        vertices(i-1, 1) = p.Y();
        vertices(i-1, 2) = p.Z();
    }
    
    // Extract triangles (convert from 1-based to 0-based indexing)
    for (int i = 1; i <= num_triangles; i++) {
        int n1, n2, n3;
        triangulation->Triangle(i).Get(n1, n2, n3);
        triangles(i-1, 0) = n1 - 1;
        triangles(i-1, 1) = n2 - 1;
        triangles(i-1, 2) = n3 - 1;
    }
    
    return std::make_tuple(vertices, triangles);
}

[dpasukhi]

I guess it is not issue with pointer. But all OCCT objects, especially geometry must to be with opencascade::handle.

As for a tessellation presentation. You have only Poly_Triangulation as a common class.

You can exctract list of alliased nodes

  //! Returns an internal array of nodes.
  //! Node()/SetNode() should be used instead in portable code.
  Poly_ArrayOfNodes& InternalNodes() { return myNodes; }

Also you can extract list of triangles

  //! Returns an internal array of triangles.
  //! Triangle()/SetTriangle() should be used instead in portable code.
  Poly_Array1OfTriangle& InternalTriangles() { return myTriangles; }

[petrasvestartas]

This helped to reduce the data transfer 4 times faster.
I guess tesselation is quite computation intensive method. Even for this simple mesh it takes 0.05 seconds with tolerance 0.001