WIP: Face and Edge from primitives

Author: chenkasirer

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,35 @@ 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)
+        return {"boundary": boundary, "holes": holes, "surface_type": surface_type, "surface": surface}
 
     @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"])
+        type_ = value["surface_type"]
+        # 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 = value["surface"]
+        if type_ == "plane":
+            surface = self._make_surface_from_plane_loop(surface, boundary)
+        elif type_ == "sphere":
+            surface = RhinoNurbsSurface.from_sphere(surface)
+        elif type_ == "cylinder":
+            surface = RhinoNurbsSurface.from_cylinder(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 +100,39 @@ 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_plane_loop(plane, loop):
+    #     # TODO: replace guesswork here with an actual calculation..
+    #     u_degree, v_degree = 1, 1
+    #     u_p_count, v_p_count = 2, 2
+    #     curve_lengths = [edge.curve.GetLength() for edge in loop.edges]
+    #     max_length = max(curve_lengths)
+    #     u_interval, v_interval = (0.0, max_length), (0.0, max_length)
+    #     return RhinoNurbsSurface.from_plane(plane, u_interval, v_interval, u_degree, v_degree, u_p_count, v_p_count)
+
+    @staticmethod
+    def _make_surface_from_plane_loop(plane, loop):
+        # TODO: replace guesswork here with an actual calculation..
+        c0 = loop.edges[0].start_point
+        c1 = loop.edges[1].start_point
+        c2 = loop.edges[2].start_point
+        c3 = loop.edges[3].start_point
+        surface = RhinoNurbsSurface.from_corners([c3, c2, c1, c0])
+        return surface

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,35 @@ def is_v_periodic(self):
     # Constructors
     # ==============================================================================
 
+    @classmethod
+    def from_plane(cls, plane, u_interval, v_interval, u_degree, v_degree, u_point_count, v_point_count):
+        plane = plane_to_rhino(plane)
+        u_interval = Rhino.Geometry.Interval(u_interval[0], u_interval[1])
+        v_interval = Rhino.Geometry.Interval(v_interval[0], v_interval[1])
+        rhino_surface = Rhino.Geometry.NurbsSurface.CreateFromPlane(plane, u_interval, v_interval, u_degree, v_degree, u_point_count, v_point_count)
+        return cls.from_rhino(rhino_surface)
+
+    @classmethod
+    def from_corners(cls, corners):
+        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):
+        sphere = sphere_to_rhino(sphere)
+        surface = Rhino.Geometry.NurbsSurface.CreateFromSphere(sphere)
+        return cls.from_rhino(surface)
+
+    @classmethod
+    def from_cylinder(cls, cylinder):
+        cylinder = cylinder_to_rhino(cylinder)
+        surface = Rhino.Geometry.NurbsSurface.CreateFromCylinder(cylinder)
+        return cls.from_rhino(surface)
+
+    @classmethod
+    def from_torus(cls, cylinder):
+        raise NotImplementedError
+
     @classmethod
     def from_rhino(cls, rhino_surface):
         """Construct a NURBS surface from an existing Rhino surface.
@@ -255,3 +287,21 @@ def aabb(self, precision=0.0, optimal=False):
         """
         box = self.rhino_surface.GetBoundingBox(optimal)
         return box_to_compas(Rhino.Geometry.Box(box))
+
+    def extend_u_by(self, value):
+        self._extend_domain(0, value)
+
+    def extend_v_by(self, value):
+        self._extend_domain(1, value)
+
+    def _extend_domain(self, domain, value):
+        if not (domain == 0 or domain == 1):
+            raise ValueError("Expected domain: 0 or 1")
+        lower = self.rhino_surface.Domain(domain)[0]
+        upper = self.rhino_surface.Domain(domain)[1]
+        self.rhino_surface.Extend(domain, Rhino.Geometry.Interval(lower - value, upper + value))
+
+    def reverse(self):
+        brep = self.rhino_surface.ToBrep()
+        brep.Flip()
+        self.rhino_surface = brep.Surfaces[0]