Merge pull request #1079 from compas-dev/occ_rhino_brep

Occ rhino brep

Author: chenkasirer

CHANGELOG.md

@@ -33,7 +33,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Fixed bug in `intersections.intersection_circle_circle_xy` where the Circle's Plane was accessed instead of the centre. 
 * Fixed bug in `_core.tangent` where the Circle's Plane was accessed instead of the centre.
 * Fixed the `test_tangent` to work with a properly defined circle
-
+* `RhinoBrep` serialization works now with surface types other than NURBS.
 ### Removed
 
 

src/compas_rhino/geometry/brep/brep.py

@@ -103,7 +103,7 @@ def points(self):
     @property
     def edges(self):
         if self._brep:
-            return [RhinoBrepEdge(edge) for edge in self._brep.Edges]
+            return [RhinoBrepEdge(trim) for trim in self._brep.Trims]
 
     @property
     def loops(self):

src/compas_rhino/geometry/brep/edge.py

@@ -5,23 +5,30 @@
 from compas_rhino.geometry import RhinoNurbsCurve
 from compas_rhino.conversions import curve_to_compas_line
 from compas_rhino.conversions import curve_to_compas_circle
+from compas_rhino.conversions import curve_to_compas_ellipse
 from compas_rhino.conversions import line_to_rhino_curve
 from compas_rhino.conversions import circle_to_rhino_curve
+from compas_rhino.conversions import ellipse_to_rhino_curve
+
 
 from .vertex import RhinoBrepVertex
 
 
 class RhinoBrepEdge(BrepEdge):
-    """A wrapper for Rhino.Geometry.BrepEdge
+    """A wrapper for Rhino.Geometry.BrepEdge.
+
+    The expected native type here is a Rhino.Geometry.BrepTrim.
+    a BrepTrim holds a reference to its associated BrepEdge as well as its start a end vertices
+    in a correct topological order (!).
 
     Attributes
     ----------
     curve : :class:`Rhino.Geometry.Curve3D`
         The underlying geometry of this edge.
     start_vertex : :class:`~compas_rhino.geometry.RhinoBrepVertex`, read-only
-        The start vertex of this edge.
+        The start vertex of this edge (taken from BrepTrim).
     end_vertex : :class:`~compas_rhino.geometry.RhinoBrepVertex`, read-only
-        The end vertex of this edge.
+        The end vertex of this edge (taken from BrepTrim).
     vertices : list[:class:`~compas_rhino.geometry.RhinoBrepVertex`], read-only
         The list of vertices which comprise this edge (start and end)
     is_circle : bool, read-only
@@ -31,20 +38,20 @@ class RhinoBrepEdge(BrepEdge):
 
     """
 
-    def __init__(self, rhino_edge=None):
+    def __init__(self, rhino_trim=None):
         super(RhinoBrepEdge, self).__init__()
         self._edge = None
         self._curve = None
         self._start_vertex = None
         self._end_vertex = None
-        if rhino_edge:
-            self._set_edge(rhino_edge)
+        if rhino_trim:
+            self._set_edge(rhino_trim)
 
-    def _set_edge(self, native_edge):
-        self._edge = native_edge
+    def _set_edge(self, rhino_trim):
+        self._edge = rhino_trim.Edge
         self._curve = self._edge.EdgeCurve
-        self._start_vertex = RhinoBrepVertex(self._edge.StartVertex)
-        self._end_vertex = RhinoBrepVertex(self._edge.EndVertex)
+        self._start_vertex = RhinoBrepVertex(rhino_trim.StartVertex)
+        self._end_vertex = RhinoBrepVertex(rhino_trim.EndVertex)
 
     # ==============================================================================
     # Data
@@ -58,13 +65,16 @@ def data(self):
         elif self.is_circle:
             type_ = "circle"
             curve = curve_to_compas_circle(self._curve)
+        elif self.is_ellipse:
+            type_ = "ellipse"
+            curve = curve_to_compas_ellipse(self._curve)
         else:
             type_ = "nurbs"
             curve = RhinoNurbsCurve.from_rhino(self._curve)
         return {
             "type": type_,
             "value": curve.data,
-            "points": [self._start_vertex.point.data, self._end_vertex.point.data],
+            "points": [self.start_vertex.point.data, self.end_vertex.point.data],
         }
 
     @data.setter
@@ -78,9 +88,11 @@ def data(self, value):
             self._curve = circle_to_rhino_curve(
                 Circle.from_data(value["value"])
             )  # this returns a Nurbs Curve, why?
+        elif curve_type == "ellipse":
+            self._curve = ellipse_to_rhino_curve(value["value"])
         else:
             self._curve = RhinoNurbsCurve.from_data(value["value"]).rhino_curve
-        # TODO: can a single edge be defined with more than start and end vertices?
+
         self._start_vertex, self._end_vertex = RhinoBrepVertex(), RhinoBrepVertex()
         self._start_vertex._point = Point.from_data(value["points"][0])
         self._end_vertex._point = Point.from_data(value["points"][1])
@@ -103,7 +115,7 @@ def end_vertex(self):
 
     @property
     def vertices(self):
-        return [self._start_vertex, self._end_vertex]
+        return [self.start_vertex, self.end_vertex]
 
     @property
     def is_circle(self):
@@ -112,3 +124,7 @@ def is_circle(self):
     @property
     def is_line(self):
         return self._curve.IsLinear()
+
+    @property
+    def is_ellipse(self):
+        return self._curve.IsEllipse()

src/compas_rhino/geometry/brep/face.py

@@ -1,5 +1,11 @@
 from compas.geometry import BrepFace
 from compas_rhino.geometry import RhinoNurbsSurface
+from compas_rhino.conversions import plane_to_compas
+from compas_rhino.conversions import sphere_to_compas
+from compas_rhino.conversions import cylinder_to_compas
+from compas_rhino.conversions import plane_to_rhino
+from compas_rhino.conversions import sphere_to_rhino
+from compas_rhino.conversions import cylinder_to_rhino
 
 from .loop import RhinoBrepLoop
 
@@ -35,9 +41,7 @@ def __init__(self, rhino_face=None):
     def _set_face(self, native_face):
         self._face = native_face
         self._loops = [RhinoBrepLoop(loop) for loop in self._face.Loops]
-        self._surface = RhinoNurbsSurface.from_rhino(
-            self._face.ToNurbsSurface()
-        )  # surface in Rhino will always be NURBS
+        self._surface = self._face.UnderlyingSurface()
 
     # ==============================================================================
     # Data
@@ -47,26 +51,42 @@ def _set_face(self, native_face):
     def data(self):
         boundary = self._loops[0].data
         holes = [loop.data for loop in self._loops[1:]]
-        surface = {"type": "nurbs"}
-        surface.update(self.surface.data)
-        return {"boundary": boundary, "surface": surface, "holes": holes}
+        surface_type, surface = self._get_surface_geometry(self._surface)
+        surface_data = {"value": surface.data, "type": surface_type}
+        return {"boundary": boundary, "surface": surface_data, "holes": holes}
 
     @data.setter
     def data(self, value):
         boundary = RhinoBrepLoop.from_data(value["boundary"])
         holes = [RhinoBrepLoop.from_data(loop) for loop in value["holes"]]
         self._loops = [boundary] + holes
-        # TODO: should we check surface type here? should we support surfaces other than NURBS?
-        self._surface = RhinoNurbsSurface.from_data(value["surface"])
+
+        # TODO: using the new serialization mechanism, surface.to_nurbs() should replace all this branching..
+        # TODO: given that Plane, Sphere, Cylinder etc. all implement to_nurbs()
+        surface_data = value["surface"]
+        type_ = surface_data["type"]
+        surface = surface_data["value"]
+        if type_ == "plane":
+            surface = self._make_surface_from_loop(boundary)
+        elif type_ == "sphere":
+            surface = RhinoNurbsSurface.from_sphere(Sphere.from_data(surface))
+        elif type_ == "cylinder":
+            surface = RhinoNurbsSurface.from_cylinder(Cylinder.from_data(surface))
+        elif type_ == "nurbs":
+            surface = RhinoNurbsSurface.from_data(surface)
+        elif type_ == "torus":
+            raise NotImplementedError(
+                "Support for torus surface is not yet implemented!"
+            )
+        self._surface = surface.rhino_surface
 
     # ==============================================================================
     # Properties
     # ==============================================================================
 
     @property
     def native_surface(self):
-        if self._surface:
-            return self._surface.rhino_surface
+        return self._surface
 
     @property
     def loops(self):
@@ -87,3 +107,28 @@ def holes(self):
     @property
     def is_plane(self):
         return
+
+    @staticmethod
+    def _get_surface_geometry(surface):
+        success, cast_surface = surface.TryGetPlane()
+        if success:
+            return "plane", plane_to_compas(cast_surface)
+        success, cast_surface = surface.TryGetSphere()
+        if success:
+            return "sphere", sphere_to_compas(cast_surface)
+        success, cast_surface = surface.TryGetCylinder()
+        if success:
+            return "cylinder", cylinder_to_compas(cast_surface)
+        success, cast_surface = surface.TryGetTorus()
+        if success:
+            raise NotImplementedError(
+                "Support for torus surface is not yet implemented!"
+            )
+        return "nurbs", RhinoNurbsSurface.from_rhino(surface.ToNurbsSurface())
+
+    @staticmethod
+    def _make_surface_from_loop(loop):
+        # order of corners determines the normal of the resulting surface
+        corners = [loop.edges[i].start_vertex.point for i in range(4)]
+        surface = RhinoNurbsSurface.from_corners(corners)
+        return surface

src/compas_rhino/geometry/brep/loop.py

@@ -3,6 +3,7 @@
 import Rhino
 
 from .edge import RhinoBrepEdge
+from .vertex import RhinoBrepVertex
 
 
 class LoopType(object):
@@ -54,7 +55,7 @@ def __init__(self, rhino_loop=None):
     def _set_loop(self, native_loop):
         self._loop = native_loop
         self._type = int(self._loop.LoopType)
-        self._edges = [RhinoBrepEdge(t.Edge) for t in self._loop.Trims]
+        self._edges = [RhinoBrepEdge(trim) for trim in self._loop.Trims]
 
     # ==============================================================================
     # Data

src/compas_rhino/geometry/surfaces/surface.py

@@ -10,6 +10,9 @@
 from compas_rhino.conversions import plane_to_compas_frame
 from compas_rhino.conversions import box_to_compas
 from compas_rhino.conversions import xform_to_rhino
+from compas_rhino.conversions import plane_to_rhino
+from compas_rhino.conversions import sphere_to_rhino
+from compas_rhino.conversions import cylinder_to_rhino
 
 from compas_rhino.geometry.curves import RhinoCurve
 
@@ -76,6 +79,81 @@ def is_v_periodic(self):
     # Constructors
     # ==============================================================================
 
+    @classmethod
+    def from_corners(cls, corners):
+        """Creates a NURBS surface using the given 4 corners.
+
+        The order of the given points determins the normal direction of the generated surface.
+
+        Parameters
+        ----------
+        corners : list(:class:`~compas.geometry.Point`)
+            4 points in 3d space to represent the corners of the planar surface.
+
+        Returns
+        -------
+        :class:`~compas_rhino.geometry.RhinoNurbsSurface`
+
+        """
+        rhino_points = [
+            Rhino.Geometry.Point3d(corner.x, corner.y, corner.z) for corner in corners
+        ]
+        return cls.from_rhino(
+            Rhino.Geometry.NurbsSurface.CreateFromCorners(*rhino_points)
+        )
+
+    @classmethod
+    def from_sphere(cls, sphere):
+        """Creates a NURBS surface from a sphere.
+
+        Parameters
+        ----------
+        sphere : :class:`~compas.geometry.Sphere`
+            The surface's geometry.
+
+        Returns
+        -------
+        :class:`~compas_rhino.geometry.RhinoNurbsSurface`
+
+        """
+        sphere = sphere_to_rhino(sphere)
+        surface = Rhino.Geometry.NurbsSurface.CreateFromSphere(sphere)
+        return cls.from_rhino(surface)
+
+    @classmethod
+    def from_cylinder(cls, cylinder):
+        """Create a NURBS surface from a cylinder.
+
+        Parameters
+        ----------
+        cylinder : :class:`~compas.geometry.Cylinder`
+            The surface's geometry.
+
+        Returns
+        -------
+        :class:`~compas_rhino.geometry.RhinoNurbsSurface`
+
+        """
+        cylinder = cylinder_to_rhino(cylinder)
+        surface = Rhino.Geometry.NurbsSurface.CreateFromCylinder(cylinder)
+        return cls.from_rhino(surface)
+
+    @classmethod
+    def from_torus(cls, torus):
+        """Create a NURBS surface from a torus.
+
+        Parameters
+        ----------
+        torus : :class:`~compas.geometry.Torus`
+            The surface's geometry.
+
+        Returns
+        -------
+        :class:`~compas_rhino.geometry.RhinoNurbsSurface`
+
+        """
+        raise NotImplementedError
+
     @classmethod
     def from_rhino(cls, rhino_surface):
         """Construct a NURBS surface from an existing Rhino surface.