strong performance optimizations for the backend

yacv_server/gltf.py

@@ -70,7 +70,7 @@ class GLTFMgr:
     def _vertices_primitive(self) -> Primitive:
         return [p for p in self.gltf.meshes[0].primitives if p.mode == POINTS][0]
 
-    def add_face(self, vertices_raw: List[Tuple[float, float, float]], indices_raw: List[Tuple[int, int, int]],
+    def add_face(self, vertices_raw: List[Vector], indices_raw: List[Tuple[int, int, int]],
                  tex_coord_raw: List[Tuple[float, float]],
                  color: Tuple[float, float, float, float] = (1.0, 0.75, 0.0, 1.0)):
         """Add a face to the GLTF mesh"""

yacv_server/tessellate.py

@@ -43,17 +43,17 @@ def tessellate(
                 _tessellate_face(mgr, face.wrapped, tolerance, angular_tolerance)
                 if edges:
                     for edge in face.edges():
-                        edge_to_faces[_hashcode(edge.wrapped)] = edge_to_faces.get(_hashcode(edge.wrapped), []) + [face.wrapped]
+                        edge_to_faces[(edge.wrapped)] = edge_to_faces.get((edge.wrapped), []) + [face.wrapped]
                 if vertices:
                     for vertex in face.vertices():
-                        vertex_to_faces[_hashcode(vertex.wrapped)] = vertex_to_faces.get(_hashcode(vertex.wrapped), []) + [face.wrapped]
+                        vertex_to_faces[(vertex.wrapped)] = vertex_to_faces.get((vertex.wrapped), []) + [face.wrapped]
         if edges:
             for edge in shape.edges():
-                _tessellate_edge(mgr, edge.wrapped, edge_to_faces.get(_hashcode(edge.wrapped), []), angular_tolerance,
+                _tessellate_edge(mgr, edge.wrapped, edge_to_faces.get((edge.wrapped), []), angular_tolerance,
                                  angular_tolerance)
         if vertices:
             for vertex in shape.vertices():
-                _tessellate_vertex(mgr, vertex.wrapped, vertex_to_faces.get(_hashcode(vertex.wrapped), []))
+                _tessellate_vertex(mgr, vertex.wrapped, vertex_to_faces.get((vertex.wrapped), []))
 
     return mgr.build()
 
@@ -65,12 +65,12 @@ def _tessellate_face(
         angular_tolerance: float = 0.1
 ):
     face = Shape(ocp_face)
-    face.mesh(tolerance, angular_tolerance)
+    # face.mesh(tolerance, angular_tolerance)
+    tri_mesh = face.tessellate(tolerance, angular_tolerance)
     poly = BRep_Tool.Triangulation_s(face.wrapped, TopLoc_Location())
     if poly is None:
         logger.warn("No triangulation found for face")
         return GLTF2()
-    tri_mesh = face.tessellate(tolerance, angular_tolerance)
 
     # Get UV of each face from the parameters
     uv = [
@@ -78,7 +78,7 @@ def _tessellate_face(
         for v in (poly.UVNode(i) for i in range(1, poly.NbNodes() + 1))
     ]
 
-    vertices = [(v.X, v.Y, v.Z) for v in tri_mesh[0]]
+    vertices = tri_mesh[0]
     indices = tri_mesh[1]
     mgr.add_face(vertices, indices, uv)
 

yacv_server/yacv.py

@@ -18,11 +18,11 @@ from OCP.TopoDS import TopoDS_Shape
 from build123d import Shape, Axis, Location, Vector
 from dataclasses_json import dataclass_json
 
-from yacv_server.rwlock import RWLock
 from yacv_server.cad import get_shape, grab_all_cad, CADCoreLike, CADLike
 from yacv_server.myhttp import HTTPHandler
 from yacv_server.mylogger import logger
 from yacv_server.pubsub import BufferedPubSub
+from yacv_server.rwlock import RWLock
 from yacv_server.tessellate import _hashcode, tessellate
 
 
@@ -278,9 +278,10 @@ class YACV:
                                       edges=event.kwargs.get('edges', True),
                                       vertices=event.kwargs.get('vertices', True))
                     glb_list_of_bytes = gltf.save_to_bytes()
-                    publish_to.publish(b''.join(glb_list_of_bytes))
-                    logger.info('export(%s) took %.3f seconds, %d parts', name, time.time() - start,
-                                len(gltf.meshes[0].primitives))
+                    glb_bytes = b''.join(glb_list_of_bytes)
+                    publish_to.publish(glb_bytes)
+                    logger.info('export(%s) took %.3f seconds, %s', name, time.time() - start,
+                                sizeof_fmt(len(glb_bytes)))
 
             # In either case return the elements of a subscription to the async generator
             subscription = self.build_events[name].subscribe()
@@ -326,7 +327,15 @@ def _find_var_name(obj: any, avoid_levels: int = 2) -> str:
     global _find_var_name_count
     for frame in inspect.stack()[avoid_levels:]:
         for key, value in frame.frame.f_locals.items():
-            if value is obj:
+            if get_shape(value) is get_shape(obj):
                 return key
     _find_var_name_count += 1
     return 'unknown_var_' + str(_find_var_name_count)
+
+
+def sizeof_fmt(num, suffix="B"):
+    for unit in ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"):
+        if abs(num) < 1024.0:
+            return f"{num:3.1f}{unit}{suffix}"
+        num /= 1024.0
+    return f"{num:.1f}Yi{suffix}"