Reworked edge curve type conversions

Author: chenkasirer

src/compas_rhino/geometry/brep/edge.py

@@ -2,16 +2,32 @@
 from compas.geometry import Line
 from compas.geometry import Circle
 from compas.geometry import Ellipse
+from compas.geometry import Frame
+from compas.geometry import Arc
 from compas_rhino.geometry import RhinoNurbsCurve
 from compas_rhino.conversions import curve_to_compas_line
+from compas_rhino.conversions import plane_to_compas_frame
+from compas_rhino.conversions import circle_to_compas
+from compas_rhino.conversions import ellipse_to_compas
+from compas_rhino.conversions import ellipse_to_rhino
+from compas_rhino.conversions import circle_to_rhino
+from compas_rhino.conversions import frame_to_rhino_plane
+from compas_rhino.conversions import line_to_rhino
+from compas_rhino.conversions import arc_to_compas
+from compas_rhino.conversions import arc_to_rhino
+
+from Rhino.Geometry import ArcCurve
+from Rhino.Geometry import NurbsCurve
+from Rhino.Geometry import LineCurve
+from Rhino.Geometry import NurbsCurve
+from Rhino.Geometry import Interval
 
 # 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
 
 
@@ -62,17 +78,19 @@ def _set_edge(self, rhino_edge):
 
     @property
     def data(self):
-        curve_type, curve = self._get_curve_geometry()
+        curve_type, curve, plane, domain = self._get_curve_geometry()
         return {
             "curve_type": curve_type,
             "curve": curve.data,
+            "frame": plane_to_compas_frame(plane).data,
             "start_vertex": self._edge.StartVertex.VertexIndex,
             "end_vertex": self._edge.EndVertex.VertexIndex,
+            "domain": domain,
         }
 
     @data.setter
     def data(self, value):
-        edge_curve = self._create_curve_from_data(value["curve_type"], value["curve"])
+        edge_curve = self._create_curve_from_data(value["curve_type"], value["curve"], value["frame"], value["domain"])
         edge = self._builder.add_edge(edge_curve, value["start_vertex"], value["end_vertex"])
         self._set_edge(edge)
 
@@ -131,28 +149,45 @@ def is_ellipse(self):
 
     def _get_curve_geometry(self):
         curve = self._edge.EdgeCurve
-        if self.is_line:
-            type_ = "line"
-            curve = curve_to_compas_line(curve)
-        # TODO: there is an edge/trim direction issue when creating and edge from circle
-        # elif self.is_circle:
-        #     type_ = "circle"
-        #     curve = curve_to_compas_circle(curve)
-        # elif self.is_ellipse:
-        #     type_ = "ellipse"
-        #     curve = curve_to_compas_ellipse(curve)
-        else:
-            type_ = "nurbs"
-            curve = self._curve
-        return type_, curve
+        domain = [self._edge.Domain[0], self._edge.Domain[1]]
+        _, frame = curve.FrameAt(0)
+        if isinstance(curve, LineCurve):
+            return "line", curve_to_compas_line(curve), frame, domain
+        if isinstance(curve, NurbsCurve):
+            return "nurbs", RhinoNurbsCurve.from_rhino(curve), frame, domain
+        if isinstance(curve, ArcCurve):
+            if not curve.IsClosed:
+                return "arc", arc_to_compas(curve.Arc), curve.Arc.Plane, domain
+            is_circle, circle = curve.TryGetCircle()
+            if is_circle:
+                return "circle", circle_to_compas(circle), circle.Plane, domain
+            is_ellipse, ellipse = curve.TryGetEllipse()
+            if is_ellipse:
+                return "ellipse", ellipse_to_compas(ellipse), ellipse.Plane, domain
+            return "nurbs", curve.ToNurbsCurve(), frame, domain
+        raise ValueError("Unknown curve type: {}".format(curve.__class__.__name__))
 
     @staticmethod
-    def _create_curve_from_data(curve_type, curve_data):
+    def _create_curve_from_data(curve_type, curve_data, frame_data, domain):
+        frame = Frame.from_data(frame_data)
         if curve_type == "line":
-            return line_to_rhino_curve(Line.from_data(curve_data))
+            line = Line.from_data(curve_data)
+            curve = LineCurve(line_to_rhino(line))
         elif curve_type == "circle":
-            return circle_to_rhino_curve(Circle.from_data(curve_data))
+            circle = circle_to_rhino(Circle.from_data(curve_data))
+            circle.Plane = frame_to_rhino_plane(frame)
+            curve = ArcCurve(circle)
         elif curve_type == "ellipse":
-            return ellipse_to_rhino_curve(Ellipse.from_data(curve_data))
+            ellipse = ellipse_to_rhino(Ellipse.from_data(curve_data))
+            ellipse.Plane = frame_to_rhino_plane(frame)
+            curve = NurbsCurve.CreateFromEllipse(ellipse)
+        elif curve_type == "arc":
+            arc = arc_to_rhino(Arc.from_data(curve_data))
+            curve = ArcCurve(arc)
+        elif curve_type == "nurbs":
+            curve = RhinoNurbsCurve.from_data(curve_data).rhino_curve
         else:
-            return RhinoNurbsCurve.from_data(curve_data).rhino_curve
+            raise ValueError("Unknown curve type: {}".format(curve_type))
+        curve.Domain = (Interval(*domain))
+        return curve
+