raw tessellation methods for body/design in place

Author: jacobrkerstetter

src/ansys/geometry/core/_grpc/_services/v0/designs.py

@@ -30,6 +30,8 @@
     _check_write_body_facets_input,
     build_grpc_id,
     from_design_file_format_to_grpc_part_export_format,
+    from_grpc_tess_to_pd,
+    from_tess_options_to_grpc_tess_options,
 )
 
 
@@ -261,27 +263,30 @@ def request_generator(
     def stream_design_tessellation(self, **kwargs) -> dict:  # noqa: D102
         from ansys.api.dbu.v0.designs_pb2 import DesignTessellationRequest
 
+        # If there are options, convert to gRPC options
+        options = (
+            from_tess_options_to_grpc_tess_options(kwargs["options"])
+            if kwargs["options"] is not None
+            else None
+        )
+
         # Create the request - assumes all inputs are valid and of the proper type
         request = DesignTessellationRequest(
-            chordal_deviation=kwargs["chordal_deviation"],
-            angle_deviation=kwargs["angle_deviation"],
-            max_aspect_ratio=kwargs["max_aspect_ratio"],
-            min_edge_length=kwargs["min_edge_length"],
-            max_edge_length=kwargs["max_edge_length"],
-            deflection_type=kwargs["deflection_type"],
+            options=options
         )
 
         # Call the gRPC service
         response = self.designs_stub.StreamDesignTessellation(request)
 
         # Return the response - formatted as a dictionary
-        points = []
-        triangles = []
+        tess_map = {}
         for elem in response:
-            points.extend(elem.points)
-            triangles.extend(elem.triangles)
+            for body_id, body_tess in elem.body_tessellation.items():
+                tess = {}
+                for face_id, face_tess in body_tess.face_tessellation.items():
+                    tess[face_id] = from_grpc_tess_to_pd(face_tess)
+                tess_map[body_id] = tess
 
         return {
-            "points": points,
-            "triangles": triangles,
+            "tessellation": tess_map,
         }

src/ansys/geometry/core/designer/body.py

@@ -594,6 +594,21 @@ def copy(self, parent: "Component", name: str = None) -> "Body":
         """
         return
 
+    @abstractmethod
+    def get_raw_tessellation(self, tess_options: TessellationOptions | None = None) -> dict:
+        """Tessellate the body and return the raw tessellation data.
+        
+        Parameters
+        ----------
+        tess_options : TessellationOptions | None, default: None
+            A set of options to determine the tessellation quality.
+
+        Returns
+        -------
+        dict
+            Dictionary with face IDs as keys and :class:`pyvista.PolyData` as values.
+        """
+
     @abstractmethod
     def tessellate(
         self, merge: bool = False, tess_options: TessellationOptions | None = None
@@ -1281,6 +1296,38 @@ def copy(self, parent: "Component", name: str = None) -> "Body":  # noqa: D102
         body_id = f"{parent.id}/{tb.id}" if parent.parent_component else tb.id
         return Body(body_id, response.get("name"), parent, tb)
 
+    @graphics_required
+    def get_raw_tessellation(self, tess_options: TessellationOptions | None = None) -> dict:  # noqa: D102
+        if not self.is_alive:
+            return {}
+
+        # If the server does not support tessellation options, ignore them
+        if tess_options is not None and self._grpc_client.backend_version < (25, 2, 0):
+            self._grpc_client.log.warning(
+                "Tessellation options are not supported by server"
+                f" version {self._grpc_client.backend_version}. Ignoring options."
+            )
+            tess_options = None
+
+        self._grpc_client.log.debug(f"Requesting tessellation for body {self.id}.")
+
+        # cache tessellation
+        if not self._tessellation:
+            if tess_options is not None:
+                response = self._grpc_client.services.bodies.get_tesellation_with_options(
+                    id=self.id,
+                    options=tess_options,
+                )
+            else:
+                response = self._grpc_client.services.bodies.get_tesellation(
+                    id=self.id,
+                    backend_version=self._grpc_client.backend_version,
+                )
+
+            self._tessellation = response.get("tessellation")
+
+        return self._tessellation
+
     @graphics_required
     def tessellate(  # noqa: D102
         self,
@@ -1849,6 +1896,10 @@ def get_collision(self, body: "Body") -> CollisionType:  # noqa: D102
     def copy(self, parent: "Component", name: str = None) -> "Body":  # noqa: D102
         return self._template.copy(parent, name)
 
+    @ensure_design_is_active
+    def get_raw_tessellation(self, tess_options: TessellationOptions | None = None) -> dict:  # noqa: D102
+        return self._template.get_raw_tessellation(tess_options)
+
     @ensure_design_is_active
     def tessellate(  # noqa: D102
         self, merge: bool = False, tess_options: TessellationOptions | None = None

src/ansys/geometry/core/designer/design.py

@@ -1040,30 +1040,25 @@ def insert_file(
     @min_backend_version(26, 1, 0)
     @check_input_types
     @graphics_required
-    def tessellate(
-        self, merge: bool = False, tess_options: TessellationOptions | None = None
-    ) -> Union["PolyData", "MultiBlock"]:
+    def tessellate(self, tess_options: TessellationOptions | None = None) -> dict:
         """Tessellate the entire design and return the geometry as triangles.
 
         Parameters
         ----------
-        merge : bool, default: False
-            Whether to merge all bodies into a single mesh.
         tess_options : TessellationOptions, optional
             Options for the tessellation. If None, default options are used.
 
         Returns
         -------
-        ~pyvista.PolyData | ~pyvista.MultiBlock
-            The tessellated mesh. If `merge` is True, a single PolyData is returned.
-            Otherwise, a MultiBlock is returned with each block corresponding to a body.
+        dict
+            A dictionary with body IDs as keys and another dictionary as values.
+            The inner dictionary has face IDs as keys and the corresponding PyVista
+            PolyData objects as values.
         """
-        import pyvista as pv
-
         if not self.is_alive:
-            return pv.PolyData() if merge else pv.MultiBlock()
+            return {}  # Return an empty dictionary if the design is not alive
 
-        self._grpc_client.log.debug(f"Requesting tessellation for body {self.id}.")
+        self._grpc_client.log.debug(f"Requesting tessellation for design {self.id}.")
 
         # cache tessellation
         if not self._tessellation:
@@ -1073,14 +1068,7 @@ def tessellate(
 
             self._tessellation = response.get("tessellation")
 
-        pdata = [tess for tess in self._tessellation.values()]
-        comp = pv.MultiBlock(pdata)
-
-        if merge:
-            ugrid = comp.combine()
-            return pv.PolyData(var_inp=ugrid.points, faces=ugrid.cells)
-        else:
-            return comp
+        return self._tessellation
 
     def __repr__(self) -> str:
         """Represent the ``Design`` as a string."""

tests/integration/test_tessellation.py

@@ -161,3 +161,67 @@ def test_component_tessellate(modeler: Modeler):
             rel=1e-6,
             abs=1e-8,
         )
+
+    
+def test_get_design_tessellation(modeler: Modeler):
+    """Test getting the entire design tessellation."""
+    import pyvista as pv
+
+    design = modeler.create_design("revolve_edges")
+    box = design.extrude_sketch("box", Sketch().box(Point2D([0, 0]), 2, 2), 2)
+    cyl = design.extrude_sketch("cylinder", Sketch().circle(Point2D([1, 0]), 0.5), 2)
+
+    design_tess = design.tessellate()
+    assert isinstance(design_tess, dict)
+    assert len(design_tess) == 2  # Two bodies in the design
+
+    box_tess = design_tess[box.id]
+    assert isinstance(box_tess, dict)
+    assert len(box_tess) == 6  # Six faces on the box
+
+    for face_id, face_tess in box_tess.items():
+        assert isinstance(face_id, str)
+        assert isinstance(face_tess, pv.PolyData)
+        assert face_tess.n_cells == 2
+        assert face_tess.n_points == 4
+
+    cyl_tess = design_tess[cyl.id]
+    assert isinstance(cyl_tess, dict)
+    assert len(cyl_tess) == 3  # Three faces on the cylinder
+
+    for face_id, face_tess in cyl_tess.items():
+        assert isinstance(face_id, str)
+        assert isinstance(face_tess, pv.PolyData)
+        assert face_tess.n_cells > 0
+        assert face_tess.n_points > 0
+
+
+def test_get_body_raw_tessellation(modeler: Modeler):
+    """Test getting the raw tessellation from a body."""
+    import pyvista as pv
+    
+    design = modeler.create_design("revolve_edges")
+    box = design.extrude_sketch("box", Sketch().box(Point2D([0, 0]), 2, 2), 2)
+    cylinder = design.extrude_sketch("cylinder", Sketch().circle(Point2D([1, 0]), 0.5), 2)
+
+    # Get the raw tessellation from the box body
+    box_tess = box.get_raw_tessellation()
+    assert isinstance(box_tess, dict)
+    assert len(box_tess) == 6  # Six faces on the box
+
+    for face_id, face_tess in box_tess.items():
+        assert isinstance(face_id, str)
+        assert isinstance(face_tess, pv.PolyData)
+        assert face_tess.n_cells == 2
+        assert face_tess.n_points == 4
+    
+    # Get the raw tessellation from the cylinder body
+    cyl_tess = cylinder.get_raw_tessellation()
+    assert isinstance(cyl_tess, dict)
+    assert len(cyl_tess) == 3  # Three faces on the cylinder
+
+    for face_id, face_tess in cyl_tess.items():
+        assert isinstance(face_id, str)
+        assert isinstance(face_tess, pv.PolyData)
+        assert face_tess.n_cells > 0
+        assert face_tess.n_points > 0