rebase surface

Author: tomvanmele

src/compas_occ/__init__.py

@@ -39,4 +39,5 @@
 
 __all_plugins__ = [
     'compas_occ.geometry.curves',
+    'compas_occ.geometry.surfaces',
 ]

src/compas_occ/geometry/__init__.py

@@ -5,27 +5,16 @@
 
 .. currentmodule:: compas_occ.geometry
 
-Curves
-======
+Classes
+=======
 
 .. autosummary::
     :toctree: generated/
     :nosignatures:
 
-    Curve
-    NurbsCurve
-
-Surfaces
-========
-
-.. autosummary::
-    :toctree: generated/
-    :nosignatures:
-
-    Surface
-    NurbsSurface
+    OCCNurbsCurve
+    OCCNurbsSurface
 
 """
 from .curves import OCCNurbsCurve  # noqa: F401
-from .surfaces import Surface  # noqa: F401
-from .surfaces import NurbsSurface  # noqa: F401
+from .surfaces import OCCNurbsSurface  # noqa: F401

src/compas_occ/geometry/curves/nurbs.py

@@ -113,12 +113,12 @@ def __init__(self, name=None) -> None:
         super().__init__(name=name)
         self.occ_curve = None
 
-    def __eq__(self, other: 'NurbsCurve') -> bool:
+    def __eq__(self, other: 'OCCNurbsCurve') -> bool:
         return self.occ_curve.IsEqual(other.occ_curve)
 
     def __str__(self):
         lines = [
-            'NurbsCurve',
+            'OCCNurbsCurve',
             '------------',
             f'Points: {self.points}',
             f'Weights: {self.weights}',
@@ -166,7 +166,7 @@ def data(self, data: Dict):
         )
 
     @classmethod
-    def from_data(cls, data: Dict) -> 'NurbsCurve':
+    def from_data(cls, data: Dict) -> 'OCCNurbsCurve':
         """Construct a NURBS curve from its data representation.
 
         Parameters
@@ -176,7 +176,7 @@ def from_data(cls, data: Dict) -> 'NurbsCurve':
 
         Returns
         -------
-        :class:`compas_occ.geometry.NurbsCurve`
+        :class:`compas_occ.geometry.OCCNurbsCurve`
             The constructed curve.
 
         """
@@ -193,7 +193,7 @@ def from_data(cls, data: Dict) -> 'NurbsCurve':
     # ==============================================================================
 
     @classmethod
-    def from_occ(cls, occ_curve: Geom_BSplineCurve) -> 'NurbsCurve':
+    def from_occ(cls, occ_curve: Geom_BSplineCurve) -> 'OCCNurbsCurve':
         """Construct a NURBS curve from an existing OCC BSplineCurve."""
         curve = cls()
         curve.occ_curve = occ_curve
@@ -206,7 +206,7 @@ def from_parameters(cls,
                         knots: List[float],
                         multiplicities: List[int],
                         degree: int,
-                        is_periodic: bool = False) -> 'NurbsCurve':
+                        is_periodic: bool = False) -> 'OCCNurbsCurve':
         """Construct a NURBS curve from explicit curve parameters."""
         curve = cls()
         curve.occ_curve = Geom_BSplineCurve(
@@ -220,7 +220,7 @@ def from_parameters(cls,
         return curve
 
     @classmethod
-    def from_points(cls, points: List[Point], degree: int = 3) -> 'NurbsCurve':
+    def from_points(cls, points: List[Point], degree: int = 3) -> 'OCCNurbsCurve':
         """Construct a NURBS curve from control points.
 
         This construction method is similar to the method ``Create`` of the Rhino API for NURBS curves [1]_.
@@ -253,7 +253,7 @@ def from_points(cls, points: List[Point], degree: int = 3) -> 'NurbsCurve':
         return curve
 
     @classmethod
-    def from_interpolation(cls, points: List[Point], precision: float = 1e-3) -> 'NurbsCurve':
+    def from_interpolation(cls, points: List[Point], precision: float = 1e-3) -> 'OCCNurbsCurve':
         """Construct a NURBS curve by interpolating a set of points.
 
         This construction method is similar to the method ``CreateHSpline`` of the Rhino API for NURBS curves [1]_.
@@ -271,12 +271,12 @@ def from_interpolation(cls, points: List[Point], precision: float = 1e-3) -> 'Nu
         return curve
 
     @classmethod
-    def from_step(cls, filepath: str) -> 'NurbsCurve':
+    def from_step(cls, filepath: str) -> 'OCCNurbsCurve':
         """Load a NURBS curve from an STP file."""
         pass
 
     @classmethod
-    def from_edge(cls, edge: TopoDS_Edge) -> 'NurbsCurve':
+    def from_edge(cls, edge: TopoDS_Edge) -> 'OCCNurbsCurve':
         """Construct a NURBS curve from an existing OCC TopoDS_Edge."""
         res = BRep_Tool_Curve(edge)
         if len(res) != 3:
@@ -288,7 +288,7 @@ def from_arc(cls, arc, degree, pointcount=None):
         pass
 
     @classmethod
-    def from_circle(cls, circle: Circle) -> 'NurbsCurve':
+    def from_circle(cls, circle: Circle) -> 'OCCNurbsCurve':
         """Construct a NURBS curve from a circle.
 
         This construction method is similar to the method ``CreateFromCircle`` of the Rhino API for NURBS curves [1]_.
@@ -490,7 +490,7 @@ def is_rational(self) -> bool:
     # Methods
     # ==============================================================================
 
-    def copy(self) -> 'NurbsCurve':
+    def copy(self) -> 'OCCNurbsCurve':
         """Make an independent copy of the current curve."""
         return NurbsCurve.from_parameters(
             self.points,
@@ -507,7 +507,7 @@ def transform(self, T: Transformation) -> None:
         occ_T.SetValues(* T.list)
         self.occ_curve.Transform(occ_T)
 
-    def transformed(self, T: Transformation) -> 'NurbsCurve':
+    def transformed(self, T: Transformation) -> 'OCCNurbsCurve':
         """Transform a copy of the curve."""
         copy = self.copy()
         copy.transform(T)
@@ -591,7 +591,11 @@ def curvature_at(self, t):
             The corresponding curvature vector.
 
         """
-        pass
+        point = gp_Pnt()
+        uvec = gp_Vec()
+        vvec = gp_Vec()
+        self.occ_curve.D2(t, point, uvec, vvec)
+        return Vector.from_occ(vvec)
 
     def frame_at(self, t):
         """Compute the local frame at a point on the curve.
@@ -643,20 +647,17 @@ def divide_by_length(self, length):
         """Divide the curve into segments of specified length."""
         pass
 
-    def fair(self):
-        pass
-
     def aabb(self, precision: float = 0.0) -> Box:
         """Compute the axis aligned bounding box of the curve."""
         box = Bnd_Box()
         BndLib_Add3dCurve_Add(GeomAdaptor_Curve(self.occ_curve), precision, box)
         return Box.from_diagonal((
             Point.from_occ(box.CornerMin()),
-            Point.from_occ(box.CornerMax())
-        ))
+            Point.from_occ(box.CornerMax())))
 
     def obb(self, precision: float = 0.0) -> Box:
         """Compute the oriented bounding box of the curve."""
+        pass
 
     def length(self, precision: float = 1e-3) -> float:
         """Compute the length of the curve."""
@@ -686,7 +687,7 @@ def segment(self, u: float, v: float, precision: float = 1e-3) -> None:
             raise ValueError('The given domain is zero length.')
         self.occ_curve.Segment(u, v, precision)
 
-    def segmented(self, u: float, v: float, precision: float = 1e-3) -> 'NurbsCurve':
+    def segmented(self, u: float, v: float, precision: float = 1e-3) -> 'OCCNurbsCurve':
         """Returns a copy of this curve by segmenting it between the parameters u and v.
 
         Parameters

src/compas_occ/geometry/surfaces/__init__.py

@@ -1,2 +1,30 @@
-from ._surface import Surface  # noqa F401
-from .nurbs import NurbsSurface  # noqa F401
+from compas.plugins import plugin
+from compas.geometry import NurbsSurface
+
+from .nurbs import OCCNurbsSurface
+
+
+@plugin(category='factories', requires=['compas_occ'])
+def new_nurbssurface(cls, *args, **kwargs):
+    return super(NurbsSurface, OCCNurbsSurface).__new__(OCCNurbsSurface)
+
+
+@plugin(category='factories', requires=['compas_occ'])
+def new_nurbssurface_from_parameters(*args, **kwargs):
+    return OCCNurbsSurface.from_parameters(*args, **kwargs)
+
+
+@plugin(category='factories', requires=['compas_occ'])
+def new_nurbssurface_from_points(*args, **kwargs):
+    return OCCNurbsSurface.from_points(*args, **kwargs)
+
+
+@plugin(category='factories', requires=['compas_occ'])
+def new_nurbssurface_from_fill(cls, *args, **kwargs):
+    return OCCNurbsSurface.from_fill(*args, **kwargs)
+
+
+@plugin(category='factories', requires=['compas_occ'])
+def new_nurbssurface_from_step(cls, *args, **kwargs):
+    return OCCNurbsSurface.from_step(*args, **kwargs)
+

src/compas_occ/geometry/surfaces/_surface.py

@@ -22,8 +22,9 @@
 from compas_occ.conversions import floats2_from_array2
 from compas_occ.conversions import points2_from_array2
 
-from ..curves import NurbsCurve
-from ._surface import Surface
+from ..curves import OCCNurbsCurve
+
+from compas.geometry import NurbsSurface
 
 from OCC.Core.gp import gp_Trsf
 from OCC.Core.gp import gp_Pnt
@@ -46,6 +47,7 @@
 from OCC.Core.BndLib import BndLib_AddSurface_AddOptimal
 from OCC.Core.BRepBndLib import brepbndlib_AddOBB
 
+
 Point.from_occ = classmethod(compas_point_from_occ_point)
 Point.to_occ = compas_point_to_occ_point
 Vector.from_occ = classmethod(compas_vector_from_occ_vector)
@@ -83,7 +85,7 @@ def __iter__(self):
         return iter(self.points)
 
 
-class NurbsSurface(Surface):
+class OCCNurbsSurface(NurbsSurface):
     """Class representing a NURBS surface based on the BSplineSurface of the OCC geometry kernel.
 
     Attributes
@@ -143,7 +145,7 @@ def __init__(self, name: str = None) -> None:
         self.occ_surface = None
         self._points = None
 
-    def __eq__(self, other: 'NurbsSurface') -> bool:
+    def __eq__(self, other: 'OCCNurbsSurface') -> bool:
         for a, b in zip(flatten(self.points), flatten(other.points)):
             if a != b:
                 return False
@@ -164,7 +166,7 @@ def __eq__(self, other: 'NurbsSurface') -> bool:
 
     def __str__(self):
         lines = [
-            'NurbsSurface',
+            'OCCNurbsSurface',
             '--------------',
             f'Points: {self.points}',
             f'Weights: {self.weights}',
@@ -226,7 +228,7 @@ def data(self, data: Dict):
         )
 
     @classmethod
-    def from_data(cls, data: Dict) -> 'NurbsSurface':
+    def from_data(cls, data: Dict) -> 'OCCNurbsSurface':
         """Construct a BSpline surface from its data representation.
 
         Parameters
@@ -236,7 +238,7 @@ def from_data(cls, data: Dict) -> 'NurbsSurface':
 
         Returns
         -------
-        :class:`compas_occ.geometry.NurbsSurface`
+        :class:`compas_occ.geometry.OCCNurbsSurface`
             The constructed surface.
 
         """
@@ -264,7 +266,7 @@ def from_data(cls, data: Dict) -> 'NurbsSurface':
     # ==============================================================================
 
     @classmethod
-    def from_occ(cls, occ_surface: Geom_BSplineSurface) -> 'NurbsSurface':
+    def from_occ(cls, occ_surface: Geom_BSplineSurface) -> 'OCCNurbsSurface':
         """Construct a NUBRS surface from an existing OCC BSplineSurface."""
         surface = cls()
         surface.occ_surface = occ_surface
@@ -281,7 +283,7 @@ def from_parameters(cls,
                         u_degree: int,
                         v_degree: int,
                         is_u_periodic: bool = False,
-                        is_v_periodic: bool = False) -> 'NurbsSurface':
+                        is_v_periodic: bool = False) -> 'OCCNurbsSurface':
         """Construct a NURBS surface from explicit parameters."""
         surface = cls()
         surface.occ_surface = Geom_BSplineSurface(
@@ -302,7 +304,7 @@ def from_parameters(cls,
     def from_points(cls,
                     points: List[List[Point]],
                     u_degree: int = 3,
-                    v_degree: int = 3) -> 'NurbsSurface':
+                    v_degree: int = 3) -> 'OCCNurbsSurface':
         """Construct a NURBS surface from control points."""
         u = len(points[0])
         v = len(points)
@@ -335,7 +337,7 @@ def from_points(cls,
         )
 
     @classmethod
-    def from_meshgrid(cls, nu: int = 10, nv: int = 10) -> 'NurbsSurface':
+    def from_meshgrid(cls, nu: int = 10, nv: int = 10) -> 'OCCNurbsSurface':
         """Construct a NURBS surface from a mesh grid."""
         UU, VV = meshgrid(linspace(0, nu, nu + 1), linspace(0, nv, nv + 1))
         points = []
@@ -347,18 +349,18 @@ def from_meshgrid(cls, nu: int = 10, nv: int = 10) -> 'NurbsSurface':
         return cls.from_points(points=points)
 
     @classmethod
-    def from_step(cls, filepath: str) -> 'NurbsSurface':
+    def from_step(cls, filepath: str) -> 'OCCNurbsSurface':
         """Load a NURBS surface from a STP file."""
         raise NotImplementedError
 
     @classmethod
-    def from_face(cls, face: TopoDS_Face) -> 'NurbsSurface':
+    def from_face(cls, face: TopoDS_Face) -> 'OCCNurbsSurface':
         """Construct a NURBS surface from an existing OCC TopoDS_Face."""
         srf = BRep_Tool_Surface(face)
         return cls.from_occ(srf)
 
     @classmethod
-    def from_fill(cls, curve1: NurbsCurve, curve2: NurbsCurve) -> 'NurbsSurface':
+    def from_fill(cls, curve1: OCCNurbsCurve, curve2: OCCNurbsCurve) -> 'OCCNurbsSurface':
         """Construct a NURBS surface from the infill between two NURBS curves."""
         surface = cls()
         occ_fill = GeomFill_BSplineCurves(curve1.occ_curve, curve2.occ_curve, GeomFill_CoonsStyle)
@@ -520,7 +522,7 @@ def is_v_periodic(self) -> bool:
     # Methods
     # ==============================================================================
 
-    def copy(self) -> 'NurbsSurface':
+    def copy(self) -> 'OCCNurbsSurface':
         """Make an independent copy of the surface."""
         return NurbsSurface.from_parameters(
             self.points,
@@ -541,7 +543,7 @@ def transform(self, T: Transformation) -> None:
         _T.SetValues(* T.list[:12])
         self.occ_surface.Transform(_T)
 
-    def transformed(self, T: Transformation) -> 'NurbsSurface':
+    def transformed(self, T: Transformation) -> 'OCCNurbsSurface':
         """Transform an independent copy of this surface."""
         copy = self.copy()
         copy.transform(T)
@@ -569,17 +571,17 @@ def v_space(self, n: int = 10) -> Generator[float, None, None]:
         vmin, vmax = self.v_domain
         return np.linspace(vmin, vmax, n)
 
-    def u_isocurve(self, u: float) -> NurbsCurve:
+    def u_isocurve(self, u: float) -> OCCNurbsCurve:
         """Compute the isoparametric curve at parameter u."""
         occ_curve = self.occ_surface.UIso(u)
-        return NurbsCurve.from_occ(occ_curve)
+        return OCCNurbsCurve.from_occ(occ_curve)
 
-    def v_isocurve(self, v: float) -> NurbsCurve:
+    def v_isocurve(self, v: float) -> OCCNurbsCurve:
         """Compute the isoparametric curve at parameter v."""
         occ_curve = self.occ_surface.VIso(v)
-        return NurbsCurve.from_occ(occ_curve)
+        return OCCNurbsCurve.from_occ(occ_curve)
 
-    def boundary(self) -> List[NurbsCurve]:
+    def boundary(self) -> List[OCCNurbsCurve]:
         """Compute the boundary curves of the surface."""
         umin, umax, vmin, vmax = self.occ_surface.Bounds()
         curves = [