Surface from rhino

CHANGELOG.md

@@ -29,6 +29,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Added `VolMesh.vertex_edges`.
 * Added `VolMesh.from_meshes`.
 * Added `VolMesh.from_polyhedrons`.
+* Added pluggable `Surface.from_native`.
+* Added deprecation warning on `RhinoSurface.from_rhino`.
+* Added `Surface.native_surface`.
+* Added `RhinoSurface.native_surface`.
+* Added plugin `RhinoSurface.from_native`.
 
 ### Changed
 
@@ -54,6 +59,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Updated `compas.geometry.vector.__truediv__` to allow element-wise division with another vector.
 * Fixed bug in registration `shapely` boolean plugins.
 * Temporarily restrict `numpy` to versions lower than `2.x`.
+* Changed `RhinoSurface` plugin `new_surface` to create `RhinoSurface` object when `compas.geometry.Surface()` is called. 
 
 ### Removed
 

src/compas/geometry/surfaces/nurbs.py

@@ -26,6 +26,11 @@ def new_nurbssurface_from_parameters(cls, *args, **kwargs):
     raise PluginNotInstalledError
 
 
+@pluggable(category="factories")
+def new_nurbssurface_from_plane(cls, *args, **kwargs):
+    raise PluginNotInstalledError
+
+
 @pluggable(category="factories")
 def new_nurbssurface_from_points(cls, *args, **kwargs):
     raise PluginNotInstalledError
@@ -350,6 +355,10 @@ def from_fill(cls, curve1, curve2, curve3=None, curve4=None, style="stretch"):
         """
         return new_nurbssurface_from_fill(cls, curve1, curve2, curve3, curve4, style)
 
+    @classmethod
+    def from_plane(cls, plane, u_degree=1, v_degree=1):
+        return new_nurbssurface_from_plane(cls, plane, u_degree, v_degree)
+
     # ==============================================================================
     # Conversions
     # ==============================================================================

src/compas/geometry/surfaces/surface.py

@@ -19,6 +19,11 @@ def new_surface(cls, *args, **kwargs):
     return surface
 
 
+@pluggable(category="factories")
+def from_native(cls, *args, **kwargs):
+    raise NotImplementedError
+
+
 @pluggable(category="factories")
 def new_surface_from_plane(cls, *args, **kwargs):
     raise NotImplementedError
@@ -47,6 +52,8 @@ class Surface(Geometry):
         Flag indicating if the surface is periodic in the U direction.
     is_periodic_v : bool, read-only
         Flag indicating if the surface is periodic in the V direction.
+    native_surface : Any, read-only
+        The CAD native surface object.
 
     """
 
@@ -95,6 +102,10 @@ def transformation(self):
             self._transformation = Transformation.from_frame(self.frame)
         return self._transformation
 
+    @property
+    def native_surface(self):
+        raise NotImplementedError
+
     @property
     def point(self):
         if not self._point:
@@ -197,6 +208,22 @@ def from_plane(cls, plane, *args, **kwargs):
         """
         return new_surface_from_plane(cls, plane, *args, **kwargs)
 
+    @classmethod
+    def from_native(cls, surface):
+        """Construct a surface from a CAD native surface object.
+
+        Parameters
+        ----------
+        surface : Any
+            A native surface object.
+
+        Returns
+        -------
+        :class:`compas.geometry.Surface`
+
+        """
+        return from_native(cls, surface)
+
     # ==============================================================================
     # Conversions
     # ==============================================================================

src/compas_rhino/geometry/surfaces/__init__.py

@@ -1,16 +1,18 @@
 from .surface import RhinoSurface  # noqa : F401
 from .nurbs import RhinoNurbsSurface
 
-from compas.geometry import Surface
 from compas.geometry import NurbsSurface
 from compas.plugins import plugin
 
 
 @plugin(category="factories", requires=["Rhino"])
 def new_surface(cls, *args, **kwargs):
-    surface = super(Surface, cls).__new__(cls)
-    surface.__init__(*args, **kwargs)
-    return surface
+    return object.__new__(RhinoSurface)
+
+
+@plugin(category="factories", requires=["Rhino"])
+def new_surface_from_plane(cls, *args, **kwargs):
+    return RhinoSurface.from_plane(*args, **kwargs)
 
 
 @plugin(category="factories", requires=["Rhino"])

src/compas_rhino/geometry/surfaces/nurbs.py

@@ -10,6 +10,7 @@
 from compas.geometry import Point
 from compas.geometry import knots_and_mults_to_knotvector
 from compas.itertools import flatten
+from compas_rhino.conversions import plane_to_rhino
 from compas_rhino.conversions import point_to_compas
 from compas_rhino.conversions import point_to_rhino
 
@@ -361,6 +362,45 @@ def from_fill(cls, curve1, curve2):
         surface.rhino_surface = Rhino.Geometry.NurbsSurface.CreateRuledSurface(curve1, curve2)
         return surface
 
+    @classmethod
+    def from_plane(cls, plane, u_degree=1, v_degree=1, u_domain=(0.0, 1.0), v_domain=(0.0, 1.0)):
+        """Construct a NURBS surface from a plane.
+
+        Parameters
+        ----------
+        plane : :class:`compas.geometry.Plane`
+            The plane from which to construct the surface.
+        u_degree : int, optional
+            The degree of the surface in the U direction.
+            Default is ``1``.
+        v_degree : int, optional
+            The degree of the surface in the V direction.
+            Default is ``1``.
+        u_domain : tuple(float), optional
+            The domain of the surface in the U direction.
+            Default is ``(0, 1)``.
+        v_domain : tuple(float), optional
+            The domain of the surface in the V direction.
+            Default is ``(0, 1)``.
+
+        Returns
+        -------
+        :class:`compas_rhino.geometry.RhinoNurbsSurface`
+
+        """
+        plane = plane_to_rhino(plane)
+        surface = cls()
+        surface.rhino_surface = Rhino.Geometry.NurbsSurface.CreateFromPlane(
+            plane,
+            Rhino.Geometry.Interval(*u_domain),
+            Rhino.Geometry.Interval(*v_domain),
+            u_degree,
+            v_degree,
+            u_degree + 1,
+            v_degree + 1,
+        )
+        return surface
+
     # ==============================================================================
     # Conversions
     # ==============================================================================

src/compas_rhino/geometry/surfaces/surface.py

@@ -4,6 +4,12 @@
 
 import Rhino.Geometry  # type: ignore
 
+import compas
+
+if not compas.IPY:
+    from typing import Tuple  # noqa: F401
+
+from compas.geometry import Plane  # noqa: F401
 from compas.geometry import Surface
 from compas_rhino.conversions import box_to_compas
 from compas_rhino.conversions import cylinder_to_rhino
@@ -31,12 +37,19 @@ class RhinoSurface(Surface):
         True if the surface is periodic in the U direction.
     is_periodic_v: bool
         True if the surface is periodic in the V direction.
+    native_surface: :class:`Rhino.Geometry.Surface`
+        The underlying Rhino surface object.
 
     """
 
     def __init__(self, name=None):
         super(RhinoSurface, self).__init__(name=name)
-        self._rhino_surface = None
+        # empty surface is not really a valid RhinoSurface object.
+        self._rhino_surface = Rhino.Geometry.PlaneSurface(Rhino.Geometry.Plane.WorldXY, Rhino.Geometry.Interval(0, 1), Rhino.Geometry.Interval(0, 1))
+
+    @property
+    def native_surface(self):
+        return self._rhino_surface
 
     @property
     def rhino_surface(self):
@@ -95,7 +108,7 @@ 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))
+        return cls.from_native(Rhino.Geometry.NurbsSurface.CreateFromCorners(*rhino_points))
 
     @classmethod
     def from_sphere(cls, sphere):
@@ -113,7 +126,7 @@ def from_sphere(cls, sphere):
         """
         sphere = sphere_to_rhino(sphere)
         surface = Rhino.Geometry.NurbsSurface.CreateFromSphere(sphere)
-        return cls.from_rhino(surface)
+        return cls.from_native(surface)
 
     @classmethod
     def from_cylinder(cls, cylinder):
@@ -131,7 +144,7 @@ def from_cylinder(cls, cylinder):
         """
         cylinder = cylinder_to_rhino(cylinder)
         surface = Rhino.Geometry.NurbsSurface.CreateFromCylinder(cylinder)
-        return cls.from_rhino(surface)
+        return cls.from_native(surface)
 
     @classmethod
     def from_torus(cls, torus):
@@ -153,6 +166,9 @@ def from_torus(cls, torus):
     def from_rhino(cls, rhino_surface):
         """Construct a NURBS surface from an existing Rhino surface.
 
+        .. deprecated:: 2.1.1
+                ``from_rhino`` will be removed in the future. Use ``from_native`` instead.
+
         Parameters
         ----------
         rhino_surface : :rhino:`Rhino.Geometry.Surface`
@@ -162,29 +178,60 @@ def from_rhino(cls, rhino_surface):
         -------
         :class:`compas_rhino.geometry.RhinoSurface`
 
+        """
+        from warnings import warn
+
+        warn("RhinoSurface.from_rhino will be removed in the future. Use RhinoSurface.from_native instead.", DeprecationWarning)
+        return cls.from_native(rhino_surface)
+
+    @classmethod
+    def from_native(cls, native_surface):
+        """Construct a surface from an existing Rhino surface.
+
+        Parameters
+        ----------
+        native_surface : :rhino:`Rhino.Geometry.Surface`
+            A Rhino surface.
+
+        Returns
+        -------
+        :class:`compas_rhino.geometry.RhinoSurface`
+
         """
         curve = cls()
-        curve.rhino_surface = rhino_surface
+        curve.rhino_surface = native_surface
         return curve
 
     @classmethod
-    def from_plane(cls, plane, box):
+    def from_plane(cls, plane, u_domain=(0.0, 1.0), v_domain=(0.0, 1.0)):
+        # type: (Plane, Tuple[float, float], Tuple[float, float]) -> RhinoSurface
         """Construct a surface from a plane.
 
         Parameters
         ----------
         plane : :class:`compas.geometry.Plane`
             The plane.
+        u_domain : tuple(float, float), optional
+            The parametric domain of the U parameter. u_domain[0] => u_domain[1].
+            Default is ``(0.0, 1.0)``.
+        v_domain : tuple(float, float), optional
+            The parametric domain of the V parameter. v_domain[0] => v_domain[1].
+            Default is ``(0.0, 1.0)``.
+
+        Note
+        ----
+        While the plane's origin is its center, the surface's parametric origin is at the surface's corner.
+        For the plane to overlap with the surface, the plane's origin should be first shifted by half it's domain.
+        Alternatively, the surface's domain can be adjusted to match the plane's origin.
 
         Returns
         -------
         :class:`compas_rhino.geometry.RhinoSurface`
 
         """
         plane = plane_to_rhino(plane)
-        box = Rhino.Geometry.BoundingBox(box.xmin, box.ymin, box.zmin, box.xmax, box.ymax, box.zmax)
-        rhino_surface = Rhino.Geometry.PlaneSurface.CreateThroughBox(plane, box)
-        return cls.from_rhino(rhino_surface)
+        rhino_surface = Rhino.Geometry.PlaneSurface(plane, Rhino.Geometry.Interval(*u_domain), Rhino.Geometry.Interval(*v_domain))
+        return cls.from_native(rhino_surface)
 
     @classmethod
     def from_frame(cls, frame, u_interval, v_interval):
@@ -213,7 +260,7 @@ def from_frame(cls, frame, u_interval, v_interval):
         if not surface:
             msg = "Failed creating PlaneSurface from frame:{} u_interval:{} v_interval:{}"
             raise ValueError(msg.format(frame, u_interval, v_interval))
-        return cls.from_rhino(surface)
+        return cls.from_native(surface)
 
     # ==============================================================================
     # Conversions
@@ -264,7 +311,7 @@ def u_isocurve(self, u):
 
         """
         curve = self.rhino_surface.IsoCurve(1, u)  # type: ignore
-        return RhinoCurve.from_rhino(curve)
+        return RhinoCurve.from_native(curve)
 
     def v_isocurve(self, v):
         """Compute the isoparametric curve at parameter v.
@@ -279,7 +326,7 @@ def v_isocurve(self, v):
 
         """
         curve = self.rhino_surface.IsoCurve(0, v)  # type: ignore
-        return RhinoCurve.from_rhino(curve)
+        return RhinoCurve.from_native(curve)
 
     def point_at(self, u, v):
         """Compute a point on the surface.