Merge pull request #776 from tpaviot/review/move-tesselator

Refactored Tesselator as a package independent from Display so that i…

Author: tpaviot

CMakeLists.txt

@@ -256,6 +256,19 @@ foreach(OCE_MODULE ${OCE_TOOLKIT_MODEL})
     swig_link_libraries(${OCE_MODULE} ${OCE_MODEL_LIBRARIES} Python3::Module)
 endforeach(OCE_MODULE)
 
+##############
+# Tesselator #
+##############
+execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory src/Tesselator)
+set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/Tesselator/Tesselator.i PROPERTIES CPLUSPLUS ON)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src/Tesselator)
+set(TESSELATOR_SOURCE_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/Tesselator/Tesselator.i
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/Tesselator/ShapeTesselator.cpp)
+
+swig_add_library(Tesselator LANGUAGE python SOURCES ${TESSELATOR_SOURCE_FILES} TYPE MODULE)
+swig_link_libraries(Tesselator ${OCE_MODEL_LIBRARIES} Python3::Module)
+
 #################
 # Visualisation #
 #################
@@ -277,8 +290,7 @@ if(PYTHONOCC_WRAP_VISU)
   include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src/Visualization)
   set(VISUALIZATION_SOURCE_FILES
       ${CMAKE_CURRENT_SOURCE_DIR}/src/Visualization/Visualization.i
-      ${CMAKE_CURRENT_SOURCE_DIR}/src/Visualization/Display3d.cpp
-      ${CMAKE_CURRENT_SOURCE_DIR}/src/Visualization/Tesselator.cpp)
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/Visualization/Display3d.cpp)
 
     swig_add_library(Visualization LANGUAGE python SOURCES ${VISUALIZATION_SOURCE_FILES} TYPE MODULE)
     swig_link_libraries(Visualization  ${OCE_MODEL_LIBRARIES} ${OCE_VISUALIZATION_LIBRARIES} Python3::Module)
@@ -354,6 +366,10 @@ foreach(OCE_MODULE ${OCE_TOOLKIT_MODEL})
     install(FILES ${BUILD_DIR}/${OCE_MODULE}.py DESTINATION ${PYTHONOCC_INSTALL_DIRECTORY}/Core)
     install(TARGETS _${OCE_MODULE} DESTINATION ${PYTHONOCC_INSTALL_DIRECTORY}/Core)
 endforeach(OCE_MODULE)
+# install tesselator
+install(FILES ${BUILD_DIR}/Tesselator.py DESTINATION ${PYTHONOCC_INSTALL_DIRECTORY}/Core)
+install(TARGETS _Tesselator DESTINATION ${PYTHONOCC_INSTALL_DIRECTORY}/Core)
+
 if(PYTHONOCC_WRAP_VISU)
 foreach(OCE_MODULE ${OCE_TOOLKIT_VISUALIZATION})
     install(FILES ${BUILD_DIR}/${OCE_MODULE}.py DESTINATION ${PYTHONOCC_INSTALL_DIRECTORY}/Core)

src/Display/WebGl/jupyter_renderer.py

@@ -48,7 +48,7 @@
 from OCC.Core.TopoDS import TopoDS_Compound
 from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeVertex
 from OCC.Core.BRep import BRep_Builder
-from OCC.Core.Visualization import Tesselator
+from OCC.Core.Tesselator import ShapeTesselator
 
 from OCC.Extend.TopologyUtils import (TopologyExplorer, is_edge, is_wire, discretize_edge,
                                       discretize_wire, get_type_as_string)
@@ -682,7 +682,7 @@ def AddShapeToScene(self,
                         transparency=False,
                         opacity=1.):
         # first, compute the tesselation
-        tess = Tesselator(shp)
+        tess = ShapeTesselator(shp)
         tess.Compute(compute_edges=render_edges,
                      mesh_quality=quality,
                      parallel=True)

src/Display/WebGl/threejs_renderer.py

@@ -22,7 +22,7 @@
 import json
 
 from OCC.Core.gp import gp_Vec
-from OCC.Core.Visualization import Tesselator
+from OCC.Core.Tesselator import ShapeTesselator
 from OCC import VERSION as OCC_VERSION
 
 from OCC.Extend.TopologyUtils import is_edge, is_wire, discretize_edge, discretize_wire
@@ -444,7 +444,7 @@ def DisplayShape(self,
         shape_uuid = uuid.uuid4().hex
         shape_hash = "shp%s" % shape_uuid
         # tesselate
-        tess = Tesselator(shape)
+        tess = ShapeTesselator(shape)
         tess.Compute(compute_edges=export_edges,
                      mesh_quality=mesh_quality,
                      parallel=True)

src/Display/WebGl/x3dom_renderer.py

@@ -21,7 +21,7 @@
 import uuid
 from xml.etree import ElementTree
 
-from OCC.Core.Visualization import Tesselator
+from OCC.Core.Tesselator import ShapeTesselator
 from OCC import VERSION as OCC_VERSION
 
 from OCC.Extend.TopologyUtils import is_edge, is_wire, discretize_edge, discretize_wire
@@ -284,7 +284,7 @@ def __init__(self,
         self._x3d_string = ""  # the string that contains the x3d description
 
     def compute(self):
-        shape_tesselator = Tesselator(self._shape)
+        shape_tesselator = ShapeTesselator(self._shape)
         shape_tesselator.Compute(compute_edges=self._export_edges,
                                  mesh_quality=self._mesh_quality,
                                  parallel=True)

src/Visualization/Tesselator.cpp renamed to src/Tesselator/ShapeTesselator.cpp

@@ -16,7 +16,7 @@
 //along with pythonOCC.  If not, see <http://www.gnu.org/licenses/>.
 
 //---------------------------------------------------------------------------
-#include "Tesselator.h"
+#include "ShapeTesselator.h"
 #include <sstream>
 #include <algorithm>
 #include <cmath>
@@ -40,7 +40,7 @@
 #include <TopoDS_Face.hxx>
 
 //---------------------------------------------------------------------------
-Tesselator::Tesselator(TopoDS_Shape aShape):
+ShapeTesselator::ShapeTesselator(TopoDS_Shape aShape):
   myShape(aShape),
   locVertexcoord(NULL),
   locNormalcoord(NULL),
@@ -50,13 +50,13 @@ Tesselator::Tesselator(TopoDS_Shape aShape):
     ComputeDefaultDeviation();
 }
 
-void Tesselator::Compute(bool compute_edges, float mesh_quality, bool parallel)
+void ShapeTesselator::Compute(bool compute_edges, float mesh_quality, bool parallel)
 {
     Tesselate(compute_edges, mesh_quality, parallel);
     computed=true;
 }
 
-Tesselator::~Tesselator()
+ShapeTesselator::~ShapeTesselator()
 {
     if (locVertexcoord)
       delete [] locVertexcoord;
@@ -81,14 +81,14 @@ Tesselator::~Tesselator()
 }
 
 //---------------------------------------------------------------------------
-void Tesselator::SetDeviation(Standard_Real aDeviation)
+void ShapeTesselator::SetDeviation(Standard_Real aDeviation)
 {
     myDeviation = aDeviation;   
 }
 
 
 //---------------------------------------------------------------------------
-void Tesselator::Tesselate(bool compute_edges, float mesh_quality, bool parallel)
+void ShapeTesselator::Tesselate(bool compute_edges, float mesh_quality, bool parallel)
 {
     TopExp_Explorer ExpFace;
     // clean shape to remove any previous tringulation
@@ -184,7 +184,7 @@ void Tesselator::Tesselate(bool compute_edges, float mesh_quality, bool parallel
 
 
 //---------------------------INTERFACE---------------------------------------
-void Tesselator::ComputeDefaultDeviation()
+void ShapeTesselator::ComputeDefaultDeviation()
 {
     // This method automatically computes precision from the bounding box of the shape
     Bnd_Box aBox;
@@ -198,7 +198,7 @@ void Tesselator::ComputeDefaultDeviation()
     myDeviation = adeviation;
 }
 
-void Tesselator::ComputeEdges()
+void ShapeTesselator::ComputeEdges()
 {
   TopLoc_Location aTrsf;
 
@@ -293,7 +293,7 @@ void Tesselator::ComputeEdges()
   }
 }
 
-void Tesselator::EnsureMeshIsComputed()
+void ShapeTesselator::EnsureMeshIsComputed()
 {
   // this method ensures that the mesh is computed before returning any
   // related data
@@ -318,36 +318,33 @@ std::string formatFloatNumber(float f)
   return formatted_float.str();
 }
 
-std::vector<float> Tesselator::GetVerticesPositionAsTuple()
+std::vector<float> ShapeTesselator::GetVerticesPositionAsTuple()
 {
   EnsureMeshIsComputed();
   // create the vector and allocate memory
   std::vector<float> vertices_position;
   vertices_position.reserve(tot_triangle_count);
   // loop over tertices
-  int pID = 0;
-  int qID = 0;
-  int rID = 0;
   for (int i=0;i<tot_triangle_count;i++) {
-      pID = locTriIndices[(i * 3) + 0] * 3;
+      int pID = locTriIndices[(i * 3) + 0] * 3;
       vertices_position.push_back(locVertexcoord[pID]);
       vertices_position.push_back(locVertexcoord[pID+1]);
       vertices_position.push_back(locVertexcoord[pID+2]);
       // Second vertex
-      qID = locTriIndices[(i * 3) + 1] * 3;
+      int qID = locTriIndices[(i * 3) + 1] * 3;
       vertices_position.push_back(locVertexcoord[qID]);
       vertices_position.push_back(locVertexcoord[qID+1]);
       vertices_position.push_back(locVertexcoord[qID+2]);
       // Third vertex
-      rID = locTriIndices[(i * 3) + 2] * 3;
+      int rID = locTriIndices[(i * 3) + 2] * 3;
       vertices_position.push_back(locVertexcoord[rID]);
       vertices_position.push_back(locVertexcoord[rID+1]);
       vertices_position.push_back(locVertexcoord[rID+2]);
     }
   return vertices_position;
 }
 
-std::vector<float> Tesselator::GetNormalsAsTuple()
+std::vector<float> ShapeTesselator::GetNormalsAsTuple()
 {
   EnsureMeshIsComputed();
   // create the vector and allocate memory
@@ -373,7 +370,7 @@ std::vector<float> Tesselator::GetNormalsAsTuple()
   return normals;
 }
 
-std::string Tesselator::ExportShapeToX3DIndexedFaceSet()
+std::string ShapeTesselator::ExportShapeToX3DIndexedFaceSet()
 {
   EnsureMeshIsComputed();
   std::stringstream str_ifs, str_vertices, str_normals;
@@ -427,7 +424,7 @@ std::string Tesselator::ExportShapeToX3DIndexedFaceSet()
   return str_ifs.str();
 }
 
-void Tesselator::ExportShapeToX3D(char * filename, int diffR, int diffG, int diffB)
+void ShapeTesselator::ExportShapeToX3D(char * filename, int diffR, int diffG, int diffB)
 {
   EnsureMeshIsComputed();
     std::ofstream X3Dfile;
@@ -448,7 +445,7 @@ void Tesselator::ExportShapeToX3D(char * filename, int diffR, int diffG, int dif
 
 }
 
-std::string Tesselator::ExportShapeToThreejsJSONString(char *shape_function_name)
+std::string ShapeTesselator::ExportShapeToThreejsJSONString(char *shape_function_name)
 {
     EnsureMeshIsComputed();
     // a method that export a shape to a JSON BufferGeometry object
@@ -531,55 +528,55 @@ std::string Tesselator::ExportShapeToThreejsJSONString(char *shape_function_name
 }
 
 //---------------------------------------------------------------------------
-Standard_Real* Tesselator::VerticesList()
+Standard_Real* ShapeTesselator::VerticesList()
 {
   EnsureMeshIsComputed();
   return locVertexcoord;
 }
 //---------------------------------------------------------------------------
-Standard_Real* Tesselator::NormalsList()
+Standard_Real* ShapeTesselator::NormalsList()
 {
   EnsureMeshIsComputed();
   return locNormalcoord;
 }
 //---------------------------------------------------------------------------
-Standard_Integer Tesselator::ObjGetInvalidTriangleCount()
+Standard_Integer ShapeTesselator::ObjGetInvalidTriangleCount()
 {
   EnsureMeshIsComputed();
   return tot_invalid_triangle_count;
 }
 //---------------------------------------------------------------------------
-Standard_Integer Tesselator::ObjGetTriangleCount()
+Standard_Integer ShapeTesselator::ObjGetTriangleCount()
 {
   EnsureMeshIsComputed();
   return tot_triangle_count;
 }
 //---------------------------------------------------------------------------
-Standard_Integer Tesselator::ObjGetVertexCount()
+Standard_Integer ShapeTesselator::ObjGetVertexCount()
 {
   EnsureMeshIsComputed();
   return tot_vertex_count;
 }
 //---------------------------------------------------------------------------
-Standard_Integer Tesselator::ObjGetNormalCount()
+Standard_Integer ShapeTesselator::ObjGetNormalCount()
 {
   EnsureMeshIsComputed();
   return tot_normal_count;
 }
 //---------------------------------------------------------------------------
-Standard_Integer Tesselator::ObjGetInvalidNormalCount()
+Standard_Integer ShapeTesselator::ObjGetInvalidNormalCount()
 {
   EnsureMeshIsComputed();
   return tot_invalid_normal_count;
 }
 //---------------------------------------------------------------------------
-Standard_Integer Tesselator::ObjGetEdgeCount()
+Standard_Integer ShapeTesselator::ObjGetEdgeCount()
 {
   EnsureMeshIsComputed();
   return edgelist.size();
 }
 //---------------------------------------------------------------------------
-Standard_Integer Tesselator::ObjEdgeGetVertexCount(int iEdge)
+Standard_Integer ShapeTesselator::ObjEdgeGetVertexCount(int iEdge)
 {
   EnsureMeshIsComputed();
   aedge* edge = edgelist.at(iEdge);
@@ -589,31 +586,31 @@ Standard_Integer Tesselator::ObjEdgeGetVertexCount(int iEdge)
   return edge->number_of_coords;
 }
 //---------------------------------------------------------------------------
-void Tesselator::GetVertex(int ivert, float& x, float& y, float& z)
+void ShapeTesselator::GetVertex(int ivert, float& x, float& y, float& z)
 {
   EnsureMeshIsComputed();
   x = locVertexcoord[ivert*3 + 0];
   y = locVertexcoord[ivert*3 + 1];
   z = locVertexcoord[ivert*3 + 2];
 }
 //---------------------------------------------------------------------------
-void Tesselator::GetNormal(int ivert, float& x, float& y, float& z)
+void ShapeTesselator::GetNormal(int ivert, float& x, float& y, float& z)
 {
   EnsureMeshIsComputed();
   x = locNormalcoord[ivert*3 + 0];
   y = locNormalcoord[ivert*3 + 1];
   z = locNormalcoord[ivert*3 + 2];
 }
 //---------------------------------------------------------------------------
-void Tesselator::GetTriangleIndex(int triangleIdx, int &v1, int &v2, int &v3)
+void ShapeTesselator::GetTriangleIndex(int triangleIdx, int &v1, int &v2, int &v3)
 {
   EnsureMeshIsComputed();
   v1 = locTriIndices[3*triangleIdx + 0];
   v2 = locTriIndices[3*triangleIdx + 1];
   v3 = locTriIndices[3*triangleIdx + 2];
 }
 //---------------------------------------------------------------------------
-void Tesselator::GetEdgeVertex(int iEdge, int ivert, float &x, float &y, float &z)
+void ShapeTesselator::GetEdgeVertex(int iEdge, int ivert, float &x, float &y, float &z)
 {
   EnsureMeshIsComputed();
   aedge* e = edgelist.at(iEdge);
@@ -626,7 +623,7 @@ void Tesselator::GetEdgeVertex(int iEdge, int ivert, float &x, float &y, float &
   z = e->vertex_coord[3*ivert + 2];
 }
 //---------------------------------------------------------------------------
-void Tesselator::ObjGetTriangle(int trianglenum, int *vertices, int *normals)
+void ShapeTesselator::ObjGetTriangle(int trianglenum, int *vertices, int *normals)
 {
   EnsureMeshIsComputed();
   int pID = locTriIndices[(trianglenum * 3) + 0] * 3;
@@ -644,7 +641,7 @@ void Tesselator::ObjGetTriangle(int trianglenum, int *vertices, int *normals)
 //---------------------------------------------------------------------------
 //---------------------------------HELPERS-----------------------------------
 //---------------------------------------------------------------------------
-void Tesselator::JoinPrimitives()
+void ShapeTesselator::JoinPrimitives()
 {
   int obP = 0;
   int obN = 0;
@@ -670,7 +667,7 @@ void Tesselator::JoinPrimitives()
     tot_normal_count = tot_normal_count + myface->number_of_normals;
     tot_invalid_normal_count = tot_invalid_normal_count + myface->number_of_invalid_normals;
 
-    anIterator++;
+    ++anIterator;
   }
 
   locTriIndices= new Standard_Integer[tot_triangle_count * 3 ];

src/Visualization/Tesselator.h renamed to src/Tesselator/ShapeTesselator.h

@@ -42,7 +42,7 @@ struct aedge {
   Standard_Integer number_of_coords;
 };
 
-class Tesselator
+class ShapeTesselator
 {
   protected:
       Standard_Boolean computed;
@@ -66,8 +66,8 @@ class Tesselator
       void EnsureMeshIsComputed();
 
   public:
-      Tesselator(TopoDS_Shape aShape);
-      ~Tesselator();
+      ShapeTesselator(TopoDS_Shape aShape);
+      ~ShapeTesselator();
       void Compute(bool compute_edges=false, float mesh_quality=1.0, bool parallel=false);
       void Tesselate(bool compute_edges, float mesh_quality, bool parallel);
       void JoinPrimitives();