made c-extension vs. python+numpy selectable

Author: thearn

examples.py

@@ -21,7 +21,7 @@
 A =  A[:, :, 0] + 1.*A[:,:, 3] # Compose some elements from RGBA to give depth
 A = gaussian_filter(A, 2)  # smoothing
 numpy2stl(A, "examples/OpenMDAO-logo.stl",
-          scale=0.05, mask_val=1., solid=True)
+          scale=0.05, mask_val=1., min_thickness_percent=0.005, solid=True)
 
 text = ("$\oint_{\Gamma} (A\, dx + B\, dy) = \iint_{U} \left(\\frac{\partial "
         "B}{\partial x} - \\frac{\partial A}{\partial y}\\right)\ dxdy$ \n\n "

stl_tools/cwrapped.c

@@ -1,6 +1,6 @@
 import struct
 import numpy as np
-
+from itertools import product
 try:
     from .cwrapped import tessellate
     c_lib = True
@@ -61,7 +61,6 @@ def roll2d(image, shifts):
 
 
 def numpy2stl(A, fn, scale=0.1, mask_val=None, ascii=False,
-              calc_normals=False,
               max_width=235.,
               max_depth=140.,
               max_height=150.,
@@ -85,8 +84,6 @@ def numpy2stl(A, fn, scale=0.1, mask_val=None, ascii=False,
 
      ascii (bool)  -  sets the STL format to ascii or binary (default)
 
-     calc_normals (bool) - sets whether surface normals are calculated or not
-
      max_width, max_depth, max_height (floats) - maximum size of the stl
                                                 object (in mm). Match this to
                                                 the dimensions of a 3D printer
@@ -104,15 +101,90 @@ def numpy2stl(A, fn, scale=0.1, mask_val=None, ascii=False,
 
     m, n = A.shape
     if n >= m:
+        # rotate to best fit a printing platform
         A = np.rot90(A, k=3)
         m, n = n, m
     A = scale * (A - A.min())
 
     if not mask_val:
         mask_val = A.min() - 1.
-    A = np.ascontiguousarray(A, dtype=float)
 
-    facets = np.asarray(tessellate(A, mask_val, min_thickness_percent, solid))
+    if c_lib and not force_python:  # try to use c library
+        # needed for memoryviews
+        A = np.ascontiguousarray(A, dtype=float)
+
+        facets = np.asarray(tessellate(A, mask_val, min_thickness_percent,
+                            solid))
+        # center on platform
+        facets[:, 3::3] += -m / 2
+        facets[:, 4::3] += -n / 2
+
+    else:  # use python + numpy
+        facets = []
+        mask = np.zeros((m, n))
+        print("Creating top mesh...")
+        for i, k in product(range(m - 1), range(n - 1)):
+
+            this_pt = np.array([i - m / 2., k - n / 2., A[i, k]])
+            top_right = np.array([i - m / 2., k + 1 - n / 2., A[i, k + 1]])
+            bottom_left = np.array([i + 1. - m / 2., k - n / 2., A[i + 1, k]])
+            bottom_right = np.array(
+                [i + 1. - m / 2., k + 1 - n / 2., A[i + 1, k + 1]])
+
+            n1, n2 = np.zeros(3), np.zeros(3)
+
+            if (this_pt[-1] > mask_val and top_right[-1] > mask_val and
+                    bottom_left[-1] > mask_val):
+
+                facet = np.concatenate([n1, top_right, this_pt, bottom_right])
+                mask[i, k] = 1
+                mask[i, k + 1] = 1
+                mask[i + 1, k] = 1
+                facets.append(facet)
+
+            if (this_pt[-1] > mask_val and bottom_right[-1] > mask_val and
+                    bottom_left[-1] > mask_val):
+
+                facet = np.concatenate(
+                    [n2, bottom_right, this_pt, bottom_left])
+                facets.append(facet)
+                mask[i, k] = 1
+                mask[i + 1, k + 1] = 1
+                mask[i + 1, k] = 1
+        facets = np.array(facets)
+
+        if solid:
+            print("Computed edges...")
+            edge_mask = np.sum([roll2d(mask, (i, k))
+                               for i, k in product([-1, 0, 1], repeat=2)],
+                               axis=0)
+            edge_mask[np.where(edge_mask == 9.)] = 0.
+            edge_mask[np.where(edge_mask != 0.)] = 1.
+            edge_mask[0::m - 1, :] = 1.
+            edge_mask[:, 0::n - 1] = 1.
+            X, Y = np.where(edge_mask == 1.)
+            locs = zip(X - m / 2., Y - n / 2.)
+
+            zvals = facets[:, 5::3]
+            zmin, zthickness = zvals.min(), zvals.ptp()
+
+            minval = zmin - min_thickness_percent * zthickness
+
+            bottom = []
+            print("Extending edges, creating bottom...")
+            for i, facet in enumerate(facets):
+                if (facet[3], facet[4]) in locs:
+                    facets[i][5] = minval
+                if (facet[6], facet[7]) in locs:
+                    facets[i][8] = minval
+                if (facet[9], facet[10]) in locs:
+                    facets[i][11] = minval
+                this_bottom = np.concatenate(
+                    [facet[:3], facet[6:8], [minval], facet[3:5], [minval],
+                     facet[9:11], [minval]])
+                bottom.append(this_bottom)
+
+            facets = np.concatenate([facets, bottom])
 
     xsize = facets[:, 3::3].ptp()
     if xsize > max_width:

stl_tools/numpy2stl.py

@@ -33,11 +33,11 @@ def test_text2array(self):
 
     def test_png(self):
         """ Tests creation of an STL from a PNG.
-        Covers the text2array function.
+        Covers the numpy2stl function.
         """
         output_name = "OUT_.stl"
         # test ascii output
-        A = 100*np.random.randn(64, 64)
+        A = 100 * np.random.randn(64, 64)
         numpy2stl(A, output_name, scale=0.05, mask_val=3., ascii=True)
         assert os.path.exists(output_name)
         assert os.stat(output_name).st_size > 1e5
@@ -48,10 +48,21 @@ def test_png(self):
         assert os.stat(output_name).st_size > 1e5
         os.remove(output_name)
 
-    def test_calc_normals(self):
+    def test_png_force_py(self):
+        """ Tests creation of an STL from a PNG.
+        Covers the pure-python section of the numpy2stl function.
+        """
         output_name = "OUT_.stl"
-        A = 100*np.random.randn(64, 64)
-        numpy2stl(A, output_name, scale=0.05, mask_val=3., calc_normals=True)
+        # test ascii output
+        A = 100 * np.random.randn(64, 64)
+        numpy2stl(A, output_name, scale=0.05, mask_val=3., ascii=True,
+                  force_python=True)
+        assert os.path.exists(output_name)
+        assert os.stat(output_name).st_size > 1e5
+
+        # test binary output
+        numpy2stl(A, output_name, scale=0.05, mask_val=3.,
+                  force_python=True)
         assert os.path.exists(output_name)
         assert os.stat(output_name).st_size > 1e5
         os.remove(output_name)