Add new solvespace solver

__init__.py

@@ -42,7 +42,7 @@ def register():
 
     # Check Module and register all modules
     try:
-        check_module("py_slvs")
+        check_module("solvespace")
         register_full()
 
         global_data.registered = True

base/install_op.py

@@ -33,7 +33,7 @@ def execute(self, context):
 
         if install_package(self.package):
             try:
-                check_module("py_slvs")
+                check_module("solvespace")
                 from ..registration import register_full
 
                 register_full()
@@ -46,7 +46,7 @@ def execute(self, context):
                     {"WARNING"},
                     msg,
                 )
-            show_package_info("py_slvs")
+            show_package_info("solvespace")
         else:
             self.report({"WARNING"}, "Cannot install package: {}".format(self.package))
             return {"CANCELLED"}

base/preferences.py

@@ -178,7 +178,7 @@ def draw(self, context):
         box.label(text="Solver Module")
         if global_data.registered:
             box.label(text="Registered", icon="CHECKMARK")
-            module = sys.modules["py_slvs"]
+            module = sys.modules["solvespace"]
             box.label(text="Path: " + module.__path__[0])
         else:
             row = box.row()

model/angle.py

@@ -71,22 +71,9 @@ def needs_wp(self):
     def to_displayed_value(self, value):
         return HALF_TURN - value if self.setting else value
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        kwargs = {
-            "group": group,
-        }
-
+    def create_slvs_data(self, solvesys):
         wp = self.get_workplane()
-        if wp:
-            kwargs["wrkpln"] = wp
-
-        return solvesys.addAngle(
-            math.degrees(self.value),
-            self.setting,
-            self.entity1.py_data,
-            self.entity2.py_data,
-            **kwargs,
-        )
+        return solvesys.angle(self.entity1.py_data, self.entity2.py_data, math.degrees(self.value), wp, self.setting)
 
     def matrix_basis(self):
         if self.sketch_i == -1:

model/arc.py

@@ -102,13 +102,13 @@ def update(self):
         self._batch = batch_for_shader(self._shader, "LINE_STRIP", kwargs)
         self.is_dirty = False
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        handle = solvesys.addArcOfCircle(
-            self.wp.py_data,
+    def create_slvs_data(self, solvesys):
+        handle = solvesys.add_arc(
+            self.nm.py_data,
             self.ct.py_data,
             self.start.py_data,
             self.end.py_data,
-            group=group,
+            self.wp.py_data,
         )
         self.py_data = handle
 

model/base_constraint.py

@@ -48,9 +48,8 @@ def get_workplane(self):
         elif needs_wp == WpReq.NOT_FREE:
             return None
         else:
-            from py_slvs import slvs
-
-            return slvs.SLVS_FREE_IN_3D
+            from solvespace import Entity
+            return Entity.FREE_IN_3D
 
     def entities(self):
         props = []

model/circle.py

@@ -80,25 +80,18 @@ def update(self):
         self._batch = batch_for_shader(self._shader, "LINE_STRIP", kwargs)
         self.is_dirty = False
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        self.param = solvesys.addParamV(self.radius, group)
-
-        nm = None
-        if self.nm != -1:
-            nm = self.nm
-        else:
-            nm = self.wp.nm
-
-        handle = solvesys.addCircle(
-            self.ct.py_data,
+    def create_slvs_data(self, solvesys):
+        self._radius = solvesys.add_distance(self.radius, self.wp.py_data)
+        handle = solvesys.add_circle(
             self.nm.py_data,
-            solvesys.addDistance(self.param),
-            group=group,
+            self.ct.py_data,
+            self._radius,
+            self.wp.py_data
         )
         self.py_data = handle
 
     def update_from_slvs(self, solvesys):
-        self.radius = solvesys.getParam(self.param).val
+        self.radius = solvesys.params(self._radius.params)[0]
 
     def point_on_curve(self, angle):
         return pol2cart(self.radius, angle) + self.ct.co

model/coincident.py

@@ -6,7 +6,7 @@
 from ..solver import Solver
 from ..global_data import WpReq
 from .base_constraint import GenericConstraint
-from .utilities import slvs_entity_pointer, make_coincident
+from .utilities import slvs_entity_pointer
 from .categories import POINT, LINE
 from .workplane import SlvsWorkplane
 from .arc import SlvsArc
@@ -37,10 +37,8 @@ def needs_wp(self):
             return WpReq.FREE
         return WpReq.OPTIONAL
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        return make_coincident(
-            solvesys, self.entity1.py_data, self.entity2, self.get_workplane(), group
-        )
+    def create_slvs_data(self, solvesys):
+        return solvesys.coincident(self.entity1.py_data, self.entity2.py_data, self.get_workplane())
 
     def placements(self):
         return (self.entity1,)

model/diameter.py

@@ -76,8 +76,8 @@ def radius(self):
     def needs_wp(self):
         return WpReq.OPTIONAL
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        return solvesys.addDiameter(self.diameter, self.entity1.py_data, group=group)
+    def create_slvs_data(self, solvesys):
+        return solvesys.diameter(self.entity1.py_data, self.diameter)
 
     def init_props(self, **kwargs):
 

model/distance.py

@@ -107,77 +107,102 @@ def get_value(self):
             return value * -1
         return value
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
+    # def create_slvs_data(self, solvesys, group=Solver.group_fixed):
+    #     if self.entity1 == self.entity2:
+    #         raise AttributeError("Cannot create constraint between one entity itself")
+    #     # TODO: don't allow Distance if Point -> Line if (Point in Line)
+
+    #     e1, e2 = self.entity1, self.entity2
+    #     if e1.is_line():
+    #         e1, e2 = e1.p1, e1.p2
+
+    #     func = None
+    #     set_wp = False
+    #     wp = self.get_workplane()
+    #     alignment = self.align
+    #     align = self.use_align() and alignment != "NONE"
+    #     handles = []
+
+    #     value = self.get_value()
+
+    #     # circle/arc -> line/point
+    #     if type(e1) in CURVE:
+    #         # TODO: make Horizontal and Vertical alignment work
+    #         if type(e2) in LINE:
+    #             return solvesys.addPointLineDistance(
+    #                 value + e1.radius, e1.ct.py_data, e2.py_data, wp, group
+    #             )
+    #         else:
+    #             assert isinstance(e2, SlvsPoint2D)
+    #             return solvesys.addPointsDistance(
+    #                 value + e1.radius, e1.ct.py_data, e2.py_data, wp, group
+    #             )
+
+    #     elif type(e2) in LINE:
+    #         func = solvesys.addPointLineDistance
+    #         set_wp = True
+    #     elif isinstance(e2, SlvsWorkplane):
+    #         func = solvesys.addPointPlaneDistance
+    #     elif type(e2) in POINT:
+    #         if align and all([e.is_2d() for e in (e1, e2)]):
+    #             # Get Point in between
+    #             p1, p2 = e1.co, e2.co
+    #             coords = (p2.x, p1.y)
+
+    #             params = [solvesys.addParamV(v, group) for v in coords]
+    #             p = solvesys.addPoint2d(wp, *params, group=group)
+
+    #             handles.append(
+    #                 solvesys.addPointsHorizontal(p, e2.py_data, wp, group=group)
+    #             )
+    #             handles.append(
+    #                 solvesys.addPointsVertical(p, e1.py_data, wp, group=group)
+    #             )
+
+    #             base_point = e1 if alignment == "VERTICAL" else e2
+    #             handles.append(
+    #                 solvesys.addPointsDistance(
+    #                     value, p, base_point.py_data, wrkpln=wp, group=group
+    #                 )
+    #             )
+    #             return handles
+    #         else:
+    #             func = solvesys.addPointsDistance
+    #         set_wp = True
+
+    #     kwargs = {
+    #         "group": group,
+    #     }
+
+    #     if set_wp:
+    #         kwargs["wrkpln"] = self.get_workplane()
+
+    #     return func(value, e1.py_data, e2.py_data, **kwargs)
+
+    def create_slvs_data(self, solvesys):
         if self.entity1 == self.entity2:
-            raise AttributeError("Cannot create constraint between one entity itself")
-        # TODO: don't allow Distance if Point -> Line if (Point in Line)
+            raise AttributeError(
+                "Cannot create constraint between one entity itself")
 
         e1, e2 = self.entity1, self.entity2
         if e1.is_line():
             e1, e2 = e1.p1, e1.p2
 
-        func = None
-        set_wp = False
         wp = self.get_workplane()
-        alignment = self.align
-        align = self.use_align() and alignment != "NONE"
-        handles = []
-
         value = self.get_value()
 
-        # circle/arc -> line/point
-        if type(e1) in CURVE:
-            # TODO: make Horizontal and Vertical alignment work
-            if type(e2) in LINE:
-                return solvesys.addPointLineDistance(
-                    value + e1.radius, e1.ct.py_data, e2.py_data, wp, group
-                )
-            else:
-                assert isinstance(e2, SlvsPoint2D)
-                return solvesys.addPointsDistance(
-                    value + e1.radius, e1.ct.py_data, e2.py_data, wp, group
-                )
-
-        elif type(e2) in LINE:
-            func = solvesys.addPointLineDistance
-            set_wp = True
-        elif isinstance(e2, SlvsWorkplane):
-            func = solvesys.addPointPlaneDistance
-        elif type(e2) in POINT:
-            if align and all([e.is_2d() for e in (e1, e2)]):
-                # Get Point in between
-                p1, p2 = e1.co, e2.co
-                coords = (p2.x, p1.y)
-
-                params = [solvesys.addParamV(v, group) for v in coords]
-                p = solvesys.addPoint2d(wp, *params, group=group)
-
-                handles.append(
-                    solvesys.addPointsHorizontal(p, e2.py_data, wp, group=group)
-                )
-                handles.append(
-                    solvesys.addPointsVertical(p, e1.py_data, wp, group=group)
-                )
-
-                base_point = e1 if alignment == "VERTICAL" else e2
-                handles.append(
-                    solvesys.addPointsDistance(
-                        value, p, base_point.py_data, wrkpln=wp, group=group
-                    )
+        if e1.is_curve():
+            if e2.is_line() or (e2.is_point() and e2.is_2d()):
+                return solvesys.distance(
+                    e1.ct.py_data, e2.py_data, value + e1.radius, wp
                 )
-                return handles
             else:
-                func = solvesys.addPointsDistance
-            set_wp = True
-
-        kwargs = {
-            "group": group,
-        }
+                raise NotImplementedError()
 
-        if set_wp:
-            kwargs["wrkpln"] = self.get_workplane()
+        kwargs = {} if isinstance(e2, SlvsWorkplane) else {
+            "wp": self.get_workplane()}
 
-        return func(value, e1.py_data, e2.py_data, **kwargs)
+        return solvesys.distance(e1.py_data, e2.py_data, value, **kwargs)
 
     def matrix_basis(self):
         if self.sketch_i == -1 or not self.entity1.is_2d():

model/equal.py

@@ -10,6 +10,7 @@
 from .line_2d import SlvsLine2D
 from .arc import SlvsArc
 from .circle import SlvsCircle
+from functools import partial
 
 logger = logging.getLogger(__name__)
 
@@ -41,31 +42,8 @@ def get_types(cls, index, entities):
             return (type(e),)
         return cls.signature[index]
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        # TODO: Don't allow to add Equal between Line and Circle
-        e1, e2 = self.entity1, self.entity2
-
-        func = None
-        set_wp = False
-
-        if all([type(e) in LINE for e in (e1, e2)]):
-            func = solvesys.addEqualLength
-            set_wp = True
-        elif all([type(e) in CURVE for e in (e1, e2)]):
-            func = solvesys.addEqualRadius
-        else:
-            # TODO: Do a proper check to see if there's really one Arc and one Line
-            func = solvesys.addEqualLineArcLength
-            set_wp = True
-
-        kwargs = {
-            "group": group,
-        }
-
-        if set_wp:
-            kwargs["wrkpln"] = self.get_workplane()
-
-        return func(e1.py_data, e2.py_data, **kwargs)
+    def create_slvs_data(self, solvesys):
+        return solvesys.equal(self.entity1.py_data, self.entity2.py_data, self.get_workplane())
 
     def placements(self):
         return (self.entity1, self.entity2)

model/horizontal.py

@@ -35,13 +35,11 @@ def get_types(cls, index, entities):
     def needs_wp(self):
         return WpReq.NOT_FREE
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
+    def create_slvs_data(self, solvesys):
         wp = self.get_workplane()
-        if self.entity1.is_point():
-            return solvesys.addPointsHorizontal(
-                self.entity1.py_data, self.entity2.py_data, wp, group=group
-            )
-        return solvesys.addLineHorizontal(self.entity1.py_data, wrkpln=wp, group=group)
+        if self.entity2:
+            return solvesys.horizontal(self.entity1.py_data, wp, self.entity2.py_data)
+        return solvesys.horizontal(self.entity1.py_data, wp)
 
     def placements(self):
         return (self.entity1,)

model/line_2d.py

@@ -58,8 +58,8 @@ def update(self):
         self._batch = batch_for_shader(self._shader, "LINES", kwargs)
         self.is_dirty = False
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        handle = solvesys.addLineSegment(self.p1.py_data, self.p2.py_data, group=group)
+    def create_slvs_data(self, solvesys):
+        handle = solvesys.add_line_2d(self.p1.py_data, self.p2.py_data, self.wp.py_data)
         self.py_data = handle
 
     def closest_picking_point(self, origin, view_vector):

model/line_3d.py

@@ -52,8 +52,8 @@ def update(self):
 
         self.is_dirty = False
 
-    def create_slvs_data(self, solvesys, group=Solver.group_fixed):
-        handle = solvesys.addLineSegment(self.p1.py_data, self.p2.py_data, group=group)
+    def create_slvs_data(self, solvesys):
+        handle = solvesys.add_line_3d(self.p1.py_data, self.p2.py_data)
         self.py_data = handle
 
     def closest_picking_point(self, origin, view_vector):