Add ellipse and elliptical arc support to adapters.

Author: CodeReclaimers

sketch_adapter_freecad/adapter.py

@@ -19,6 +19,8 @@
     Circle,
     ConstraintError,
     ConstraintType,
+    Ellipse,
+    EllipticalArc,
     ExportError,
     GeometryError,
     Line,
@@ -247,6 +249,10 @@ def add_primitive(self, primitive: SketchPrimitive) -> int:
             idx = self._add_point(sketch, primitive)
         elif isinstance(primitive, Spline):
             idx = self._add_spline(sketch, primitive)
+        elif isinstance(primitive, Ellipse):
+            idx = self._add_ellipse(sketch, primitive)
+        elif isinstance(primitive, EllipticalArc):
+            idx = self._add_elliptical_arc(sketch, primitive)
         else:
             raise GeometryError(f"Unsupported primitive type: {type(primitive).__name__}")
 
@@ -325,6 +331,69 @@ def _add_spline(self, sketch: Any, spline: Spline) -> int:
 
         return sketch.addGeometry(bspline, spline.construction)
 
+    def _add_ellipse(self, sketch: Any, ellipse: Ellipse) -> int:
+        """Add an ellipse to the sketch."""
+        center = App.Vector(ellipse.center.x, ellipse.center.y, 0)
+
+        # Calculate major axis endpoint (for FreeCAD ellipse construction)
+        # Major axis is at angle 'rotation' from the X-axis
+        major_axis_x = ellipse.major_radius * math.cos(ellipse.rotation)
+        major_axis_y = ellipse.major_radius * math.sin(ellipse.rotation)
+        major_point = App.Vector(
+            ellipse.center.x + major_axis_x,
+            ellipse.center.y + major_axis_y,
+            0
+        )
+
+        # Calculate minor axis endpoint (perpendicular to major axis)
+        minor_axis_x = ellipse.minor_radius * math.cos(ellipse.rotation + math.pi / 2)
+        minor_axis_y = ellipse.minor_radius * math.sin(ellipse.rotation + math.pi / 2)
+        minor_point = App.Vector(
+            ellipse.center.x + minor_axis_x,
+            ellipse.center.y + minor_axis_y,
+            0
+        )
+
+        # Create ellipse using center, major axis point, and minor axis point
+        geo = Part.Ellipse(center, major_point, minor_point)
+        return sketch.addGeometry(geo, ellipse.construction)
+
+    def _add_elliptical_arc(self, sketch: Any, arc: EllipticalArc) -> int:
+        """Add an elliptical arc to the sketch."""
+        center = App.Vector(arc.center.x, arc.center.y, 0)
+
+        # Calculate major axis endpoint
+        major_axis_x = arc.major_radius * math.cos(arc.rotation)
+        major_axis_y = arc.major_radius * math.sin(arc.rotation)
+        major_point = App.Vector(
+            arc.center.x + major_axis_x,
+            arc.center.y + major_axis_y,
+            0
+        )
+
+        # Calculate minor axis endpoint (perpendicular to major axis)
+        minor_axis_x = arc.minor_radius * math.cos(arc.rotation + math.pi / 2)
+        minor_axis_y = arc.minor_radius * math.sin(arc.rotation + math.pi / 2)
+        minor_point = App.Vector(
+            arc.center.x + minor_axis_x,
+            arc.center.y + minor_axis_y,
+            0
+        )
+
+        # Create base ellipse
+        ellipse = Part.Ellipse(center, major_point, minor_point)
+
+        # Adjust parameters for CW direction if needed
+        start_param = arc.start_param
+        end_param = arc.end_param
+        if not arc.ccw:
+            # Swap start and end for CW direction
+            start_param, end_param = end_param, start_param
+
+        # Create arc from ellipse
+        geo = Part.ArcOfEllipse(ellipse, start_param, end_param)
+        return sketch.addGeometry(geo, arc.construction)
+
     def _extract_knots_and_mults(self, knots: list[float]) -> tuple[list[float], list[int]]:
         """
         Extract unique knots and multiplicities from an expanded knot vector.
@@ -462,8 +531,12 @@ def _infer_vertex_index(self, geo: Any, point_type: PointType) -> int:
 
         if 'Line' in geo_type:
             return get_vertex_index(Line, point_type) or 1
+        elif 'ArcOfEllipse' in geo_type:
+            return get_vertex_index(EllipticalArc, point_type) or 1
         elif 'Arc' in geo_type:
             return get_vertex_index(Arc, point_type) or 1
+        elif 'Ellipse' in geo_type:
+            return get_vertex_index(Ellipse, point_type) or 3
         elif 'Circle' in geo_type:
             return get_vertex_index(Circle, point_type) or 3
         elif 'Point' in geo_type:
@@ -784,6 +857,8 @@ def supports_feature(self, feature: str) -> bool:
         """Check if a feature is supported."""
         supported = {
             "spline": True,
+            "ellipse": True,
+            "elliptical_arc": True,
             "three_point_arc": True,
             "image_capture": True,
             "solver_status": True,
@@ -861,6 +936,51 @@ def _geometry_to_primitive(self, geo: Any, index: int) -> SketchPrimitive | None
                 periodic=geo.isPeriodic(),
                 construction=is_construction
             )
+        elif 'ArcOfEllipse' in geo_type:
+            # Elliptical arc - extract base ellipse properties
+            ellipse = geo.Ellipse
+            center = ellipse.Center
+            major_radius = ellipse.MajorRadius
+            minor_radius = ellipse.MinorRadius
+
+            # Calculate rotation from the major axis direction
+            # FreeCAD ellipse MajorAxis is a vector, we need the angle
+            major_axis = ellipse.XAxis if hasattr(ellipse, 'XAxis') else App.Vector(1, 0, 0)
+            rotation = math.atan2(major_axis.y, major_axis.x)
+
+            # Get parameter range
+            start_param = geo.FirstParameter
+            end_param = geo.LastParameter
+
+            # Determine CCW based on parameter order
+            ccw = end_param > start_param
+
+            return EllipticalArc(
+                center=Point2D(center.x, center.y),
+                major_radius=major_radius,
+                minor_radius=minor_radius,
+                rotation=rotation,
+                start_param=start_param,
+                end_param=end_param,
+                ccw=ccw,
+                construction=is_construction
+            )
+        elif 'Ellipse' in geo_type and 'Arc' not in geo_type:
+            center = geo.Center
+            major_radius = geo.MajorRadius
+            minor_radius = geo.MinorRadius
+
+            # Calculate rotation from the major axis direction
+            major_axis = geo.XAxis if hasattr(geo, 'XAxis') else App.Vector(1, 0, 0)
+            rotation = math.atan2(major_axis.y, major_axis.x)
+
+            return Ellipse(
+                center=Point2D(center.x, center.y),
+                major_radius=major_radius,
+                minor_radius=minor_radius,
+                rotation=rotation,
+                construction=is_construction
+            )
 
         return None
 
@@ -1085,8 +1205,12 @@ def _geo_to_prim_type(self, geo: Any) -> type:
         geo_type = type(geo).__name__
         if 'Line' in geo_type:
             return Line
+        elif 'ArcOfEllipse' in geo_type:
+            return EllipticalArc
         elif 'Arc' in geo_type:
             return Arc
+        elif 'Ellipse' in geo_type:
+            return Ellipse
         elif 'Circle' in geo_type:
             return Circle
         elif 'Point' in geo_type:

sketch_adapter_freecad/vertex_map.py

@@ -12,7 +12,7 @@
 
 from dataclasses import dataclass
 
-from sketch_canonical import Arc, Circle, Line, Point, PointType, Spline
+from sketch_canonical import Arc, Circle, Ellipse, EllipticalArc, Line, Point, PointType, Spline
 
 
 @dataclass
@@ -41,6 +41,14 @@ class VertexMap:
     SPLINE_START = 1
     SPLINE_END = 2
 
+    # Ellipse vertex indices (similar to Circle)
+    ELLIPSE_CENTER = 3
+
+    # EllipticalArc vertex indices (similar to Arc)
+    ELLIPTICAL_ARC_START = 1
+    ELLIPTICAL_ARC_END = 2
+    ELLIPTICAL_ARC_CENTER = 3
+
     # Origin reference
     ORIGIN_GEO_INDEX = -1
     ORIGIN_VERTEX = 1
@@ -84,6 +92,16 @@ def get_vertex_index(primitive_type: type, point_type: PointType) -> int | None:
             PointType.START: VertexMap.SPLINE_START,
             PointType.END: VertexMap.SPLINE_END,
         }
+    elif primitive_type == Ellipse:
+        mapping = {
+            PointType.CENTER: VertexMap.ELLIPSE_CENTER,
+        }
+    elif primitive_type == EllipticalArc:
+        mapping = {
+            PointType.START: VertexMap.ELLIPTICAL_ARC_START,
+            PointType.END: VertexMap.ELLIPTICAL_ARC_END,
+            PointType.CENTER: VertexMap.ELLIPTICAL_ARC_CENTER,
+        }
     else:
         return None
 
@@ -125,6 +143,16 @@ def get_point_type_from_vertex(primitive_type: type, vertex_index: int) -> Point
             VertexMap.SPLINE_START: PointType.START,
             VertexMap.SPLINE_END: PointType.END,
         }
+    elif primitive_type == Ellipse:
+        mapping = {
+            VertexMap.ELLIPSE_CENTER: PointType.CENTER,
+        }
+    elif primitive_type == EllipticalArc:
+        mapping = {
+            VertexMap.ELLIPTICAL_ARC_START: PointType.START,
+            VertexMap.ELLIPTICAL_ARC_END: PointType.END,
+            VertexMap.ELLIPTICAL_ARC_CENTER: PointType.CENTER,
+        }
     else:
         return None