RenderSystem class in (new) module slvs_solid, two new tests, tests are less verbose (unless you set verbose=True)

BBBSnowball · BBBSnowball · commit 671b4f16f909 · 2013-09-20T14:59:52.000+02:00
diff --git a/solvespace/exposed/slvs_solid.py b/solvespace/exposed/slvs_solid.py
@@ -0,0 +1,78 @@
+from slvs  import *
+from solid import *
+
+
+# call to_openscad(), if it exists
+def _to_openscad(x):
+    if hasattr(x, 'to_openscad'):
+        return x.to_openscad()
+    elif isinstance(x, list) or isinstance(x, tuple):
+        return map(_to_openscad, x)
+    else:
+        return x
+
+def mat_transpose(m):
+    for i in range(4):
+        for j in range(4):
+            if i < j:
+                a = m[i][j]
+                b = m[j][i]
+                m[i][j] = b
+                m[j][i] = a
+
+
+class RenderSystem(object):
+    __slots__ = "itemscale"
+
+    def __init__(self):
+        self.itemscale = 1
+
+    def point3d(self, pt, size = 0.1):
+        pt = Vector(pt)
+        size *= self.itemscale
+        # We want equilateral triangles. I built that in
+        # in SolveSpace and copied the dimensions.
+        side = size
+        hs = side/2
+        height = size*0.8660
+        center_to_baseline = size*0.2887
+        center_to_top      = size*0.5773
+        cb = center_to_baseline
+        ct = center_to_top
+        triangle = [ [-hs, -cb], [hs, -cb], [0, ct] ]
+        pts = [ pt ]
+        for z in [-height, +height]:
+            for p in triangle:
+                pts.append(pt + (p + [z]))
+        ts = []
+        for ps in [[0,1,2,3], [0,4,5,6]]:
+            for a in range(0, 4):
+                for b in range(a+1, 4):
+                    for c in range(b+1, 4):
+                        ts.append([ps[a], ps[b], ps[c]])
+        return polyhedron(points = pts,
+            #triangles = [[1,2,3],[4,6,5]])
+            triangles = ts)
+
+    def line3d(self, a, b, size = 0.01):
+        a = Vector(a)
+        b = Vector(b)
+        length = (b-a).length()
+        width = size*self.itemscale
+        wh = width/2
+        obj = linear_extrude(height = width)(
+            polygon([ [0,-wh], [0, wh], [length, wh], [length, -wh] ]))
+        return multmatrix(move_and_rotate(a, b, a+[0,0,1]))(obj)
+
+    def system(self, system):
+        obj = union()
+
+        for i in range(system.entities):
+            t = system.entity_type(i)
+            if t == SLVS_E_POINT_IN_3D:
+                obj.add(self.point3d(system.get_Point3d(i)))
+            elif t == SLVS_E_LINE_SEGMENT:
+                line = system.get_LineSegment3d(i)
+                obj.add(self.line3d(line.a(), line.b()))
+
+        return obj
diff --git a/solvespace/exposed/test.py b/solvespace/exposed/test.py
@@ -11,6 +11,8 @@
 from slvs import *
 import unittest
 
+verbose = False
+
 def printf(fmt, *args):
     print fmt % args
 
@@ -25,6 +27,9 @@ def floatEqual(self, a, b):
         return abs(a-b) < 0.001
 
     def assertFloatEqual(self, a, b):
+        if not isinstance(a, (int, long, float)) \
+                or not isinstance(b, (int, long, float)):
+            self.assertTrue(False, "not a float")
         if self.floatEqual(a, b):
             self.assertTrue(True)
         else:
@@ -35,7 +40,11 @@ def assertFloatListEqual(self, xs, ys):
             self.assertListEqual(xs, ys)
         else:
             for i,a,b in zip(range(len(xs)), xs, ys):
-                if not self.floatEqual(a, b):
+                aL = isinstance(a, (list, tuple))
+                bL = isinstance(b, (list, tuple))
+                if aL and bL:
+                    self.assertFloatListEqual(a, b)
+                elif not self.floatEqual(a, b):
                     self.assertEqual(a, b, "in list at index %d" % i)
             self.assertTrue(True)
 
@@ -100,11 +109,12 @@ def test_example3d(self):
         Slvs_Solve(sys, g);
 
         if (sys.result == SLVS_RESULT_OKAY):
-            print ("okay; now at (%.3f %.3f %.3f)\n" +
-                   "             (%.3f %.3f %.3f)") % (
-                    sys.get_param(0).val, sys.get_param(1).val, sys.get_param(2).val,
-                    sys.get_param(3).val, sys.get_param(4).val, sys.get_param(5).val)
-            print "%d DOF" % sys.dof
+            if verbose:
+                print ("okay; now at (%.3f %.3f %.3f)\n" +
+                       "             (%.3f %.3f %.3f)") % (
+                        sys.get_param(0).val, sys.get_param(1).val, sys.get_param(2).val,
+                        sys.get_param(3).val, sys.get_param(4).val, sys.get_param(5).val)
+                print "%d DOF" % sys.dof
 
             self.assertFloatEqual(sys.get_param(0).val,  2.698)
             self.assertFloatEqual(sys.get_param(1).val,  2.698)
@@ -208,41 +218,45 @@ def test_example2d(self):
         result = sys.solve()
 
         if(result == SLVS_RESULT_OKAY):
-            printf("solved okay");
-            printf("line from (%.3f %.3f) to (%.3f %.3f)",
-                    sys.get_param(7).val, sys.get_param(8).val,
-                    sys.get_param(9).val, sys.get_param(10).val);
+            if verbose:
+                printf("solved okay");
+                printf("line from (%.3f %.3f) to (%.3f %.3f)",
+                        sys.get_param(7).val, sys.get_param(8).val,
+                        sys.get_param(9).val, sys.get_param(10).val);
             self.assertFloatEqual(sys.get_param( 7).val,  10.000)
             self.assertFloatEqual(sys.get_param( 8).val,  11.180)
             self.assertFloatEqual(sys.get_param( 9).val,  10.000)
             self.assertFloatEqual(sys.get_param(10).val, -18.820)
 
-            printf("arc center (%.3f %.3f) start (%.3f %.3f) finish (%.3f %.3f)",
-                    sys.get_param(11).val, sys.get_param(12).val,
-                    sys.get_param(13).val, sys.get_param(14).val,
-                    sys.get_param(15).val, sys.get_param(16).val);
+            if verbose:
+                printf("arc center (%.3f %.3f) start (%.3f %.3f) finish (%.3f %.3f)",
+                        sys.get_param(11).val, sys.get_param(12).val,
+                        sys.get_param(13).val, sys.get_param(14).val,
+                        sys.get_param(15).val, sys.get_param(16).val);
             self.assertFloatListEqual(
                 map(lambda i: sys.get_param(i).val, range(11, 17)),
                 [101.114, 119.042, 116.477, 111.762, 117.409, 114.197])
 
-            printf("circle center (%.3f %.3f) radius %.3f",
-                    sys.get_param(17).val, sys.get_param(18).val,
-                    sys.get_param(19).val);
-            printf("%d DOF", sys.dof);
+            if verbose:
+                printf("circle center (%.3f %.3f) radius %.3f",
+                        sys.get_param(17).val, sys.get_param(18).val,
+                        sys.get_param(19).val);
+                printf("%d DOF", sys.dof);
             self.assertFloatEqual(sys.get_param(17).val, 200.000)
             self.assertFloatEqual(sys.get_param(18).val, 200.000)
             self.assertFloatEqual(sys.get_param(19).val,  17.000)
 
             self.assertEqual(sys.dof, 6)
         else:
-            printf("solve failed: problematic constraints are:");
-            for i in range(sys.faileds):
-                printf(" %lu", sys.failed[i]);
-            printf("");
-            if (sys.result == SLVS_RESULT_INCONSISTENT):
-                printf("system inconsistent");
-            else:
-                printf("system nonconvergent");
+            if verbose:
+                printf("solve failed: problematic constraints are:");
+                for i in range(sys.faileds):
+                    printf(" %lu", sys.failed[i]);
+                printf("");
+                if (sys.result == SLVS_RESULT_INCONSISTENT):
+                    printf("system inconsistent");
+                else:
+                    printf("system nonconvergent");
             self.assertTrue(False, "solve failed")
 
     def test_with_solidpython(self):
@@ -266,5 +280,65 @@ def test_with_solidpython(self):
             "\n\npolygon(paths = [[0, 1, 2, 3]], points = [[10.0000000000, 3.0000000000], [17.0000000000, 23.0000000000], [0, 0], [7.0000000000, 2.0000000000, 0.0000000000]]);")
 
 
+    def test_to_openscad(self):
+        sys = System()
+
+        # We want to find the plane for three points. The points
+        # shouldn't change, so we put them into another group.
+
+        p1 = Point3d(1, 1, 9, sys)
+        p2 = Point3d(5, 2, 2, sys)
+        p3 = Point3d(0, 7, 5, sys)
+
+        # Other entities go into another group
+        sys.default_group = 2
+
+        wrkpl = Workplane(p1, Normal3d(Param(1), Param(0), Param(0), Param(0), sys))
+
+        # Some constraints: all points are in the plane
+        # (p1 is its origin, so we don't need a constraint)
+        Constraint.on(wrkpl, p2)
+        Constraint.on(wrkpl, p3)
+
+        # Solve it (group 2 is still active)
+        sys.solve()
+
+        self.assertEqual(sys.result, SLVS_RESULT_OKAY)
+        self.assertFloatListEqual(wrkpl.origin().to_openscad(),
+            [ 1.000, 1.000, 9.000 ])
+        self.assertFloatListEqual(wrkpl.normal().vector(),
+            [ 0.863, -0.261, 0.432, -0.000 ])
+        self.assertFloatListEqual(wrkpl.to_openscad(),
+            [[0.6270915888275256, -0.22570772255200192, 0.7455281102701327, 1.0], [-0.22570772255200203, 0.8633874310873447, 0.45124069832139596, 1.0], [-0.7455281102701327, -0.45124069832139607, 0.49047901991447185, 9.0], [0, 0, 0, 1]])
+
+    def test_rendersystem_points_and_lines(self):
+        from slvs_solid import RenderSystem, union, scad_render
+
+        r = RenderSystem()
+        r.itemscale = 4
+
+        p1 = [ 2,  0, 0]
+        p2 = [ 0,  0, 0]
+        p3 = [ 2,  4, 2]
+        p4 = [-3, 2, -2]
+
+        pts = [ p1, p2, p3, p4 ]
+
+        #obj = r.point3d([2, 0, 0]) + r.point3d([0, 0, 0]) + linear_extrude(height = 0.5)(polygon([[0,0,0], [2,0,0], [0,2,0]]))
+        #obj = union()(map(r.point3d, pts)) + r.line3d(p3, p4)
+
+        sys = System()
+        p1s = Point3d(*(p1 + [sys]))
+        p2s = Point3d(*(p2 + [sys]))
+        p3s = Point3d(*(p3 + [sys]))
+        p4s = Point3d(*(p4 + [sys]))
+        line = LineSegment3d(p3s, p4s)
+
+        obj = r.system(sys)
+
+        self.assertEqual(scad_render(obj),
+            '\n\nunion() {\n\tpolyhedron(points = [[2.0000000000, 0.0000000000, 0.0000000000], [1.8000000000, -0.1154800000, -0.3464000000], [2.2000000000, -0.1154800000, -0.3464000000], [2.0000000000, 0.2309200000, -0.3464000000], [1.8000000000, -0.1154800000, 0.3464000000], [2.2000000000, -0.1154800000, 0.3464000000], [2.0000000000, 0.2309200000, 0.3464000000]], triangles = [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3], [0, 4, 5], [0, 4, 6], [0, 5, 6], [4, 5, 6]]);\n\tpolyhedron(points = [[0.0000000000, 0.0000000000, 0.0000000000], [-0.2000000000, -0.1154800000, -0.3464000000], [0.2000000000, -0.1154800000, -0.3464000000], [0.0000000000, 0.2309200000, -0.3464000000], [-0.2000000000, -0.1154800000, 0.3464000000], [0.2000000000, -0.1154800000, 0.3464000000], [0.0000000000, 0.2309200000, 0.3464000000]], triangles = [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3], [0, 4, 5], [0, 4, 6], [0, 5, 6], [4, 5, 6]]);\n\tpolyhedron(points = [[2.0000000000, 4.0000000000, 2.0000000000], [1.8000000000, 3.8845200000, 1.6536000000], [2.2000000000, 3.8845200000, 1.6536000000], [2.0000000000, 4.2309200000, 1.6536000000], [1.8000000000, 3.8845200000, 2.3464000000], [2.2000000000, 3.8845200000, 2.3464000000], [2.0000000000, 4.2309200000, 2.3464000000]], triangles = [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3], [0, 4, 5], [0, 4, 6], [0, 5, 6], [4, 5, 6]]);\n\tpolyhedron(points = [[-3.0000000000, 2.0000000000, -2.0000000000], [-3.2000000000, 1.8845200000, -2.3464000000], [-2.8000000000, 1.8845200000, -2.3464000000], [-3.0000000000, 2.2309200000, -2.3464000000], [-3.2000000000, 1.8845200000, -1.6536000000], [-2.8000000000, 1.8845200000, -1.6536000000], [-3.0000000000, 2.2309200000, -1.6536000000]], triangles = [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3], [0, 4, 5], [0, 4, 6], [0, 5, 6], [4, 5, 6]]);\n\tmultmatrix(m = [[-0.7453559925, -0.4444444444, -0.2981423970, 2.0000000000], [-0.2981423970, -0.1777777778, 0.7453559925, 4.0000000000], [-0.5962847940, 0.6444444444, 0.0000000000, 2.0000000000], [0, 0, 0, 1]]) {\n\t\tlinear_extrude(height = 0.0400000000) {\n\t\t\tpolygon(paths = [[0, 1, 2, 3]], points = [[0, -0.0200000000], [0, 0.0200000000], [6.7082039325, 0.0200000000], [6.7082039325, -0.0200000000]]);\n\t\t}\n\t}\n}')
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/solvespace/exposed/test2.scad.py b/solvespace/exposed/test2.scad.py
@@ -32,6 +32,8 @@
     print "solved okay"
     for p in [p1, p2, p3]:
     	print "point at (%.3f, %.3f, %.3f)" % tuple(p.to_openscad())
+    print "normal at (%.3f, %.3f, %.3f, %.3f)" % tuple(wrkpl.normal().vector())
+    print wrkpl.to_openscad()
     print "%d DOF" % sys.dof
 else:
     print("solve failed")
@@ -76,4 +78,4 @@
 plane2 = multmatrix(move_and_rotate(p1, p2, p3))(plane)
 geom += plane2
 
-scad_render_to_file(geom, "/tmp/test2.scad")
+scad_render_to_file(geom, "/tmp/out.scad")
diff --git a/solvespace/exposed/test3.scad.py b/solvespace/exposed/test3.scad.py
