Clean up and add readme

Author: ericPrince

README.md

@@ -0,0 +1,39 @@
+# constraint-solver
+
+Pure python geometric constraint solver
+
+See `gcs/solve_elements.py` for a description of the
+mechanics behind this package. Essentially, gcs implements
+a constraint solver that breaks a problem into fully 
+constrained sets of equations/variables and solves each
+set in order of its graph dependencies.
+
+This algorithm was loosely inspired by some light research
+I did on CAD constraint solvers, but the idea to split
+equations/constraints into fully constrained sets was
+original.
+
+## Installing
+
+This repo contains conda environment definitions that
+work with this package (`environment.yml` and
+`environment-windows.yml`).
+
+To install on windows (remove `sh` if not using bash and
+use `create-windows-env.bat`):
+
+```bash
+sh create_windows-env.sh
+pip install -e .
+```
+
+## Running
+
+A couple sample scripts exist in `test/`.
+
+- `test/make_constraint_graph.py`: shows how to set up a
+solver, solve it, and view its geometry and constraint graph
+- `test/problem2_cstr_del_add`: tests adding/deleting constraints
+on a sample problem. Makes an mpl animation showing the solver
+being updated as the constraint controlling the circle's radius
+changes

gcs/constraint_graph.py

@@ -5,7 +5,21 @@
 
 
 def create_solver_graph(gs, cmap=cm.rainbow):
-    """Return an igraph graph that represents a solved solver"""
+    """
+    Returns an igraph graph that represents a solved solver
+
+    Vertices are colored based on which constrained set
+    they belong to. Groups of variables/equations with
+    the same color belong to the same equation set and
+    will be solved together
+
+    Parameters
+    ----------
+    gs
+        Geom solver instance
+    cmap
+        Color map to use to color graph vertices
+    """
     var_list = list(gs.vars)
     eqn_list = list(gs.eqns)
 

gcs/constraint_solver.py

@@ -1,16 +1,18 @@
-from __future__ import print_function
-
 import scipy.optimize as opt
 
+from .solve_elements import EqnSet
+
 
-def solve_numeric(eqn_set, ftol=1.0e-10):
+def solve_numeric(eqn_set: EqnSet, ftol=1.0e-10):
     """
     Solve an equation set numerically
 
     Parameters
     ----------
     eqn_set: EqnSet
         the equation set to solve
+    ftol
+        solver tolerance
 
     Returns
     -------

gcs/constraints_signed.py

@@ -6,8 +6,6 @@
 
 """
 
-from __future__ import division
-
 from math import hypot, atan2
 
 # --------------------------------------------------------------------

gcs/constraints_unsigned.py

@@ -6,8 +6,6 @@
 
 """
 
-from __future__ import division
-
 from math import hypot, atan2
 
 # --------------------------------------------------------------------

gcs/eqn_set_splitting_proto.py

@@ -1,13 +1,8 @@
-from __future__ import print_function, division
+#note: these functions are not used, see equation_solving instead
 
-# from operator import methodcaller # TODO: can use this for sort key
-
-# for sorted insertion: heapq, bisect, blist, sortedcontainers...
 from blist import sortedlist
 
-# from sortedcontainers import SortedList as sortedlist
-
-from equation_solving import EqnSet
+from .solve_elements import EqnSet
 
 
 # original

gcs/equation_solving.py

@@ -24,7 +24,7 @@ def split_equation_set(eqn_set):
     """Split an equation set up into smaller solvable equation sets"""
 
     # used for tiebreaker of priority key
-    nEq = len(eqn_set.eqns) + 1
+    n_eq = len(eqn_set.eqns) + 1
 
     solve_sets = set()
 
@@ -34,7 +34,7 @@ def split_equation_set(eqn_set):
 
     # Initialize priority queue with the equations in the input set
     pq = sortedlist(
-        [EqnSet().add(eqn) for eqn in eqn_set.eqns], key=methodcaller("key", nEq)
+        [EqnSet().add(eqn) for eqn in eqn_set.eqns], key=methodcaller("key", n_eq)
     )
 
     while pq:
@@ -51,7 +51,7 @@ def split_equation_set(eqn_set):
                 p.discard(eqn_set)
 
             # delete any empty eqn sets and re-sort the pq
-            pq = sortedlist(filter(None, pq), key=methodcaller("key", nEq))
+            pq = sortedlist(filter(None, pq), key=methodcaller("key", n_eq))
 
             unique_eqn_combos = set(frozenset(eqs.eqns | eqs.vars) for eqs in pq)
 
@@ -73,23 +73,23 @@ def split_equation_set(eqn_set):
         underconstrained_set.set_solved()
         solve_sets.add(underconstrained_set)
 
-    #    while unsolved_eqns:
-    #        eqn = unsolved_eqns.pop()
-    #        eqn_set = EqnSet()
+    # while unsolved_eqns:
+    #     eqn = unsolved_eqns.pop()
+    #     eqn_set = EqnSet()
     #
-    #        connected_eqns = {eqn}
+    #     connected_eqns = {eqn}
     #
-    #        while connected_eqns:
-    #            eqn = connected_eqns.pop()
-    #            unsolved_eqns.discard(eqn)
-    #            eqn_set.add(eqn)
+    #     while connected_eqns:
+    #         eqn = connected_eqns.pop()
+    #         unsolved_eqns.discard(eqn)
+    #         eqn_set.add(eqn)
     #
-    #            for var in eqn.vars:
-    #                connected_eqns.update(eqn for eqn in var.eqns
-    #                                          if  eqn not in eqn_set.eqns)
+    #         for var in eqn.vars:
+    #             connected_eqns.update(eqn for eqn in var.eqns
+    #                                       if  eqn not in eqn_set.eqns)
     #
-    #        eqn_set.set_solved()
-    #        solve_sets.add(eqn_set)
+    #     eqn_set.set_solved()
+    #     solve_sets.add(eqn_set)
 
     return solve_sets
 

gcs/geom2d.py

@@ -7,7 +7,7 @@
 from .solve_elements import Eqn, Var
 from . import constraints_unsigned as cstr
 
-# form . import constraints_signed   as cstr
+# from . import constraints_signed   as cstr
 
 try:
     from ccad import model
@@ -19,7 +19,7 @@
 # ----------------------------------------------------------
 
 
-class Geometry(object):
+class Geometry:
     def __init__(self, name):
         self.vars = []
         self.name = name
@@ -37,14 +37,16 @@ def delete(self):
 
 class Point(Geometry):
     def __init__(self, name, x=0.0, y=0.0):
+        super().__init__(name)
+
         self.x = Var(name + ".x", x)
         self.y = Var(name + ".y", y)
+
         self.vars = [self.x, self.y]
-        self.name = name
 
     def plot(self, ax=None):
         ax = ax or plt.gca()
-        plt.scatter(x=(self.x.val,), y=(self.y.val,))
+        ax.scatter(x=(self.x.val,), y=(self.y.val,))
 
     def draw(self, view):
         self.geom = model.vertex([self.x.val, self.y.val, 0])
@@ -54,12 +56,13 @@ def draw(self, view):
 # TODO: add Line (instead of / in addition to, line segment)
 
 
-class Line_Segment(Geometry):
+class LineSegment(Geometry):
     def __init__(self, name, x1=0.0, y1=0.0, x2=0.0, y2=0.0):
+        super().__init__(name)
+
         self.p1 = Point(name + ".p1", x1, y1)
         self.p2 = Point(name + ".p2", x2, y2)
         self.vars = [self.p1.x, self.p1.y, self.p2.x, self.p2.y]
-        self.name = name
 
     def plot(self, ax=None):
         ax = ax or plt.gca()
@@ -79,6 +82,8 @@ def draw(self, view):
 
 class Circle(Geometry):
     def __init__(self, name, cx=0.0, cy=0.0, cr=1.0):
+        super().__init__(name)
+
         self.p = Point(name + ".p", cx, cy)
         self.r = Var(name + ".r", cr)
         self.vars = [self.p.x, self.p.y, self.r]
@@ -101,12 +106,15 @@ def draw(self, view):
 
 
 class Constraint(object):
-    def __init__(self):
+    def __init__(self, name):
+        self.name = name
         self.equations = []
 
 
 class SetVar(Constraint):
     def __init__(self, name, var, val):
+        super().__init__(name)
+
         self.var = var
         self.val = val
 
@@ -115,6 +123,8 @@ def __init__(self, name, var, val):
 
 class HorzDist(Constraint):
     def __init__(self, name, p1, p2, d):
+        super().__init__(name)
+
         self.p1 = p1
         self.p2 = p2
         self.d = d
@@ -126,6 +136,8 @@ def __init__(self, name, p1, p2, d):
 
 class VertDist(Constraint):
     def __init__(self, name, p1, p2, d):
+        super().__init__(name)
+
         self.p1 = p1
         self.p2 = p2
         self.d = d
@@ -137,6 +149,8 @@ def __init__(self, name, p1, p2, d):
 
 class LineLength(Constraint):
     def __init__(self, name, L, d):
+        super().__init__(name)
+
         self.L = L
         self.d = d
 
@@ -151,6 +165,8 @@ def __init__(self, name, L, d):
 
 class AnglePoint3(Constraint):
     def __init__(self, name, p1, p2, p3, a):
+        super().__init__(name)
+
         self.p1 = p1
         self.p2 = p2
         self.p3 = p3
@@ -169,6 +185,8 @@ def __init__(self, name, p1, p2, p3, a):
 
 class TangentLineCircle(Constraint):
     def __init__(self, name, L, C):
+        super().__init__(name)
+
         self.L = L
         self.C = C
 
@@ -185,6 +203,8 @@ def __init__(self, name, L, C):
 
 class PointOnCircle(Constraint):
     def __init__(self, name, p, C):
+        super().__init__(name)
+
         self.p = p
         self.C = C
 
@@ -200,6 +220,8 @@ def __init__(self, name, p, C):
 class GroundPoint(Constraint):
     # note: untested
     def __init__(self, name, p):
+        super().__init__(name)
+
         self.p = p
         self.gx = p.x.val
         self.gy = p.y.val
@@ -212,6 +234,8 @@ def __init__(self, name, p):
 
 class CoincidentPoint2(Constraint):
     def __init__(self, name, p1, p2):
+        super().__init__(name)
+
         self.p1 = p1
         self.p2 = p2
 

gcs/geom_solver.py

@@ -2,7 +2,7 @@
 from .system_solver import Solver
 
 
-class GCS(object):
+class GCS:
     """Geometric constraint solver (GCS)"""
 
     __slots__ = (

gcs/sample_problems.py

@@ -19,7 +19,7 @@ def problem2():
     p2 = g2d.Point("p2", 2.0, 2.0)
     p3 = g2d.Point("p3", 3.0, 3.0)
     c1 = g2d.Circle("c1", 0.0, 0.0, 1.0)
-    L1 = g2d.Line_Segment("L1", 1.0, 1.0, 3.0, 3.0)
+    L1 = g2d.LineSegment("L1", 1.0, 1.0, 3.0, 3.0)
 
     geometry = (p0, p1, p2, p3, c1, L1)
 

gcs/solve_elements.py

@@ -1,13 +1,11 @@
-from __future__ import division
-
 """
 Classes that act as nodes in a system-of-equations solve-graph.
 
 Var nodes are connected to Eqn nodes, and vice versa. Eqn nodes
 are grouped together to make EqnSets, and when an A* search is
 performed, constrained equation sets are found which can be solved.
 
-As the search is performed, the nodes track the implicit heirarchy:
+As the search is performed, the nodes track the implicit hierarchy:
 each variable has one equation set that solves for it, and a variable
 may be required to be solved for before an EqnSet can be solved.
 
@@ -238,16 +236,16 @@ def degrees_of_freedom(self):
         """The number of degrees of freedom of this set (#var - #eq)"""
         return len(self.vars) - len(self.eqns)
 
-    def key(self, nEq=None):
+    def key(self, n_eq=None):
         """
         Sorting key: value of key is higher for sets with more deg of freedom
-        
-        `nEq` is meant to be the total number of equations in a larger set
+
+        `n_eq` is meant to be the total number of equations in a larger set
         and should be at least `len(self.eqns) + 1`, and should be the same
         for the key for all equation sets being used
         """
         # last term is tie-breaker to value sets with more equations
-        return -self.degrees_of_freedom() + (len(self.eqns) / nEq if nEq else 0.0)
+        return -self.degrees_of_freedom() + (len(self.eqns) / n_eq if n_eq else 0.0)
 
     def is_constrained(self):
         """Does the number of equations equal the number of variables?"""