Fix for #187. solid.utils.extrude_along_path() was generating polyhedron() code that looked OK in preview, but that failed to render correctly in CGAL. This was caused by reversed face order, which would have been revealed if I'd looked at generated polyhedra with OpenSCAD's F12 'Thrown Together' view, which highlights inverted faces. Everything seems to be working well now, tests passing and the example file rendering correctly (if very slowly) in CGAL.

Note that OpenSCAD can accept vertex lists for non-triangular faces, and then does its own triangulations from them. However, the direction of triangulation for a given quad isn't reliable, which can lead to some odd appearances. At the expense of some extra facets, specify our own, regular, triangulation.

End caps for extruded shapes, though-- those I'm leaving to OpenSCAD to triangulate, since the existing centroid-based system added complexity without covering significantly more edge cases than OpenSCAD's native triangulation

Author: etjones-erisyon

solid/examples/path_extrude_example.py

@@ -148,24 +148,23 @@ def point_trans(point: Point3, path_norm:float, loop_norm: float) -> Point3:
         # Rotate the points sinusoidally up to max_rotation
         p = p.rotate_around(up, max_rotation*sin(tau*path_norm))
 
-
         # Oscillate z values sinusoidally, growing from 
-        # 0 magnitude to max_z_displacement
-        max_z = lerp(path_norm, 0, 1, 0, max_z_displacement)
+        # 0 magnitude to max_z_displacement, then decreasing to 0 magnitude at path_norm == 1
+        max_z = sin(pi*path_norm) * max_z_displacement
         angle = lerp(loop_norm, 0, 1, 0, 10*tau)
         p.z += max_z*sin(angle)
         return p
 
     no_trans = make_label('No Transform')
     no_trans += down(height/2)(
-        extrude_along_path(shape, path, cap_ends=False)
+        extrude_along_path(shape, path, cap_ends=True)
     )
 
     # We can pass transforms a single function that will be called on all points,
     # or pass a list with a transform function for each point along path
     arb_trans = make_label('Arbitrary Transform')
     arb_trans += down(height/2)(
-        extrude_along_path(shape, path, transforms=[point_trans], cap_ends=False)
+        extrude_along_path(shape, path, transforms=[point_trans], cap_ends=True)
     )
 
     return no_trans + right(3*path_rad)(arb_trans)

solid/extrude_along_path.py

@@ -104,29 +104,18 @@ def transform_func(p:Point3, path_norm:float, loop_norm:float): Point3
         polyhedron_pts += this_loop
 
     if connect_ends:
-        next_loop_start_index = len(polyhedron_pts) - shape_pt_count
-        loop_facets = _loop_facet_indices(0, shape_pt_count, next_loop_start_index)
+        connect_loop_start_index = len(polyhedron_pts) - shape_pt_count
+        loop_facets = _loop_facet_indices(connect_loop_start_index, shape_pt_count, 0)
         facet_indices += loop_facets
 
     elif cap_ends:
-        # endcaps at start & end of extrusion
-        # NOTE: this block adds points & indices to the polyhedron, so it's
-        # very sensitive to the order this is happening in
-        start_cap_index = len(polyhedron_pts)
-        end_cap_index = start_cap_index + 1
+        # OpenSCAD's polyhedron will automatically triangulate faces as needed.
+        # So just include all points at each end of the tube 
         last_loop_start_index = len(polyhedron_pts) - shape_pt_count 
-
-        start_loop_pts = polyhedron_pts[:shape_pt_count]
-        end_loop_pts = polyhedron_pts[last_loop_start_index:]
-
-        start_loop_indices = list(range(0, shape_pt_count))
-        end_loop_indices = list(range(last_loop_start_index, last_loop_start_index + shape_pt_count))
-
-        start_centroid, start_facet_indices = _end_cap(start_cap_index, start_loop_pts, start_loop_indices)
-        end_centroid, end_facet_indices = _end_cap(end_cap_index, end_loop_pts, end_loop_indices)
-        polyhedron_pts += [start_centroid, end_centroid]
-        facet_indices += start_facet_indices
-        facet_indices += end_facet_indices
+        start_loop_indices = list(reversed(range(shape_pt_count)))
+        end_loop_indices = list(range(last_loop_start_index, last_loop_start_index + shape_pt_count))   
+        facet_indices.append(start_loop_indices)
+        facet_indices.append(end_loop_indices)
 
     return polyhedron(points=euc_to_arr(polyhedron_pts), faces=facet_indices) # type: ignore
 
@@ -139,13 +128,18 @@ def _loop_facet_indices(loop_start_index:int, loop_pt_count:int, next_loop_start
     next_loop_indices = list(range(next_loop_start_index, loop_pt_count + next_loop_start_index )) + [next_loop_start_index]
 
     for i, (a, b) in enumerate(zip(loop_indices[:-1], loop_indices[1:])):
+        c, d = next_loop_indices[i: i+2]
+        # OpenSCAD's polyhedron will accept quads and do its own triangulation with them,
+        # so we could just append (a,b,d,c). 
+        # However, this lets OpenSCAD (Or CGAL?) do its own triangulation, leading
+        # to some strange outcomes. Prefer to do our own triangulation.
         #   c--d
         #   |\ |
         #   | \|
         #   a--b               
-        c, d = next_loop_indices[i: i+2]
-        facet_indices.append((a,c,b))
-        facet_indices.append((b,c,d))
+        # facet_indices.append((a,b,d,c))
+        facet_indices.append((a,b,c))
+        facet_indices.append((b,d,c))
     return facet_indices
 
 def _rotate_loop(points:Sequence[Point3], rotation_degrees:float=None) -> List[Point3]:
@@ -178,22 +172,3 @@ def _transform_loop(points:Sequence[Point3], transform_func:Point3Transform = No
         result.append(new_p)
     return result
 
-def _end_cap(new_point_index:int, points:Sequence[Point3], vertex_indices: Sequence[int]) -> Tuple[Point3, List[FacetIndices]]:
-    # Assume points are a basically planar, basically convex polygon with polyhedron
-    # indices `vertex_indices`. 
-    # Return a new point that is the centroid of the polygon and a list of 
-    # vertex triangle indices that covers the whole polygon.
-    # (We can actually accept relatively non-planar and non-convex polygons, 
-    # but not anything pathological. Stars are fine, internal pockets would 
-    # cause incorrect faceting)
-
-    # NOTE: In order to deal with moderately-concave polygons, we add a point
-    # to the center of the end cap. This will have a new index that we require
-    # as an argument. 
-
-    new_point = centroid(points)
-    new_facets = []
-    second_indices = vertex_indices[1:] + [vertex_indices[0]]
-    new_facets = [(new_point_index, a, b) for a, b in zip(vertex_indices, second_indices)]
-
-    return (new_point, new_facets)

solid/test/test_extrude_along_path.py

@@ -28,65 +28,68 @@ def test_extrude_along_path(self):
         path = [[0, 0, 0], [0, 20, 0]]
         # basic test
         actual = extrude_along_path(tri, path)
-        expected = 'polyhedron(faces = [[0, 3, 1], [1, 3, 4], [1, 4, 2], [2, 4, 5], [2, 5, 0], [0, 5, 3], [6, 0, 1], [6, 1, 2], [6, 2, 0], [7, 3, 4], [7, 4, 5], [7, 5, 3]], points = [[0.0000000000, 0.0000000000, 0.0000000000], [10.0000000000, 0.0000000000, 0.0000000000], [0.0000000000, 0.0000000000, 10.0000000000], [0.0000000000, 20.0000000000, 0.0000000000], [10.0000000000, 20.0000000000, 0.0000000000], [0.0000000000, 20.0000000000, 10.0000000000], [3.3333333333, 0.0000000000, 3.3333333333], [3.3333333333, 20.0000000000, 3.3333333333]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[10.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[10.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,10.0000000000]]);' 
         self.assertEqualOpenScadObject(expected, actual)
 
     def test_extrude_along_path_vertical(self):
         # make sure we still look good extruding along z axis; gimbal lock can mess us up
         vert_path = [[0, 0, 0], [0, 0, 20]]
         actual = extrude_along_path(tri, vert_path)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[6,0,1],[6,1,2],[6,2,0],[7,3,4],[7,4,5],[7,5,3]],points=[[0.0000000000,0.0000000000,0.0000000000],[-10.0000000000,0.0000000000,0.0000000000],[0.0000000000,10.0000000000,0.0000000000],[0.0000000000,0.0000000000,20.0000000000],[-10.0000000000,0.0000000000,20.0000000000],[0.0000000000,10.0000000000,20.0000000000],[-3.3333333333,3.3333333333,0.0000000000],[-3.3333333333,3.3333333333,20.0000000000]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[-10.0000000000,0.0000000000,0.0000000000],[0.0000000000,10.0000000000,0.0000000000],[0.0000000000,0.0000000000,20.0000000000],[-10.0000000000,0.0000000000,20.0000000000],[0.0000000000,10.0000000000,20.0000000000]]); '
         self.assertEqualOpenScadObject(expected, actual)
 
     def test_extrude_along_path_1d_scale(self):
         # verify that we can apply scalar scaling
         path = [[0, 0, 0], [0, 20, 0]]
         scales_1d = [1.5, 0.5]
         actual = extrude_along_path(tri, path, scales=scales_1d)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[6,0,1],[6,1,2],[6,2,0],[7,3,4],[7,4,5],[7,5,3]],points=[[0.0000000000,0.0000000000,0.0000000000],[15.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,15.0000000000],[0.0000000000,20.0000000000,0.0000000000],[5.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,5.0000000000],[5.0000000000,0.0000000000,5.0000000000],[1.6666666667,20.0000000000,1.6666666667]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[15.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,15.0000000000],[0.0000000000,20.0000000000,0.0000000000],[5.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,5.0000000000]]);'
+        print('test_extrude_along_path_1d_scale')
+
         self.assertEqualOpenScadObject(expected, actual)
 
     def test_extrude_along_path_2d_scale(self):
         # verify that we can apply differential x & y scaling
         path = [[0, 0, 0], [0, 20, 0], [0, 40, 0]]
         scales_2d = [Point2(1,1), Point2(0.5, 1.5), Point2(1.5, 0.5), ]
         actual = extrude_along_path(tri, path, scales=scales_2d)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[3,6,4],[4,6,7],[4,7,5],[5,7,8],[5,8,3],[3,8,6],[9,0,1],[9,1,2],[9,2,0],[10,6,7],[10,7,8],[10,8,6]],points=[[0.0000000000,0.0000000000,0.0000000000],[10.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[5.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,15.0000000000],[0.0000000000,40.0000000000,0.0000000000],[15.0000000000,40.0000000000,0.0000000000],[0.0000000000,40.0000000000,5.0000000000],[3.3333333333,0.0000000000,3.3333333333],[5.0000000000,40.0000000000,1.6666666667]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[3,4,6],[4,7,6],[4,5,7],[5,8,7],[5,3,8],[3,6,8],[2,1,0],[6,7,8]],points=[[0.0000000000,0.0000000000,0.0000000000],[10.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[5.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,15.0000000000],[0.0000000000,40.0000000000,0.0000000000],[15.0000000000,40.0000000000,0.0000000000],[0.0000000000,40.0000000000,5.0000000000]]);'
         self.assertEqualOpenScadObject(expected, actual)
 
     def test_extrude_along_path_2d_scale_list_input(self):
         # verify that we can apply differential x & y scaling
         path = [[0, 0, 0], [0, 20, 0], [0, 40, 0]]
         scales_2d = [(1,1), (0.5, 1.5), (1.5, 0.5), ]
         actual = extrude_along_path(tri, path, scales=scales_2d)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[3,6,4],[4,6,7],[4,7,5],[5,7,8],[5,8,3],[3,8,6],[9,0,1],[9,1,2],[9,2,0],[10,6,7],[10,7,8],[10,8,6]],points=[[0.0000000000,0.0000000000,0.0000000000],[10.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[5.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,15.0000000000],[0.0000000000,40.0000000000,0.0000000000],[15.0000000000,40.0000000000,0.0000000000],[0.0000000000,40.0000000000,5.0000000000],[3.3333333333,0.0000000000,3.3333333333],[5.0000000000,40.0000000000,1.6666666667]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[3,4,6],[4,7,6],[4,5,7],[5,8,7],[5,3,8],[3,6,8],[2,1,0],[6,7,8]],points=[[0.0000000000,0.0000000000,0.0000000000],[10.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[5.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,15.0000000000],[0.0000000000,40.0000000000,0.0000000000],[15.0000000000,40.0000000000,0.0000000000],[0.0000000000,40.0000000000,5.0000000000]]);'
         self.assertEqualOpenScadObject(expected, actual)
 
     def test_extrude_along_path_end_caps(self):
         path = [[0, 0, 0], [0, 20, 0]]
         actual = scad_render(extrude_along_path(tri, path, connect_ends=False))
-        expected = 'polyhedron(faces = [[0, 3, 1], [1, 3, 4], [1, 4, 2], [2, 4, 5], [2, 5, 0], [0, 5, 3], [6, 0, 1], [6, 1, 2], [6, 2, 0], [7, 3, 4], [7, 4, 5], [7, 5, 3]], points = [[0.0000000000, 0.0000000000, 0.0000000000], [10.0000000000, 0.0000000000, 0.0000000000], [0.0000000000, 0.0000000000, 10.0000000000], [0.0000000000, 20.0000000000, 0.0000000000], [10.0000000000, 20.0000000000, 0.0000000000], [0.0000000000, 20.0000000000, 10.0000000000], [3.3333333333, 0.0000000000, 3.3333333333], [3.3333333333, 20.0000000000, 3.3333333333]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[10.0000000000,0.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[10.0000000000,20.0000000000,0.0000000000],[0.0000000000,20.0000000000,10.0000000000]]); '
         self.assertEqualNoWhitespace(expected, actual)
 
     def test_extrude_along_path_connect_ends(self):
         path = [[0, 0, 0], [20, 0, 0], [20,20,0], [0,20, 0]]
         actual = extrude_along_path(tri, path, connect_ends=True)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[3,6,4],[4,6,7],[4,7,5],[5,7,8],[5,8,3],[3,8,6],[6,9,7],[7,9,10],[7,10,8],[8,10,11],[8,11,6],[6,11,9],[0,9,1],[1,9,10],[1,10,2],[2,10,11],[2,11,0],[0,11,9]],points=[[0.0000000000,0.0000000000,0.0000000000],[-7.0710678119,-7.0710678119,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[20.0000000000,0.0000000000,0.0000000000],[27.0710678119,-7.0710678119,0.0000000000],[20.0000000000,0.0000000000,10.0000000000],[20.0000000000,20.0000000000,0.0000000000],[27.0710678119,27.0710678119,0.0000000000],[20.0000000000,20.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[-7.0710678119,27.0710678119,0.0000000000],[0.0000000000,20.0000000000,10.0000000000]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[3,4,6],[4,7,6],[4,5,7],[5,8,7],[5,3,8],[3,6,8],[6,7,9],[7,10,9],[7,8,10],[8,11,10],[8,6,11],[6,9,11],[9,10,0],[10,1,0],[10,11,1],[11,2,1],[11,9,2],[9,0,2]],points=[[0.0000000000,0.0000000000,0.0000000000],[-7.0710678119,-7.0710678119,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[20.0000000000,0.0000000000,0.0000000000],[27.0710678119,-7.0710678119,0.0000000000],[20.0000000000,0.0000000000,10.0000000000],[20.0000000000,20.0000000000,0.0000000000],[27.0710678119,27.0710678119,0.0000000000],[20.0000000000,20.0000000000,10.0000000000],[0.0000000000,20.0000000000,0.0000000000],[-7.0710678119,27.0710678119,0.0000000000],[0.0000000000,20.0000000000,10.0000000000]]); '
         self.assertEqualOpenScadObject(expected, actual)
 
     def test_extrude_along_path_rotations(self):
+
         # confirm we can rotate for each point in path
         path = [[0,0,0], [20, 0,0 ]]
         rotations = [-45, 45]
         actual = extrude_along_path(tri, path, rotations=rotations)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[6,0,1],[6,1,2],[6,2,0],[7,3,4],[7,4,5],[7,5,3]],points=[[0.0000000000,0.0000000000,0.0000000000],[0.0000000000,-7.0710678119,-7.0710678119],[0.0000000000,-7.0710678119,7.0710678119],[20.0000000000,0.0000000000,0.0000000000],[20.0000000000,-7.0710678119,7.0710678119],[20.0000000000,7.0710678119,7.0710678119],[0.0000000000,-4.7140452079,0.0000000000],[20.0000000000,-0.0000000000,4.7140452079]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[0.0000000000,-7.0710678119,-7.0710678119],[0.0000000000,-7.0710678119,7.0710678119],[20.0000000000,0.0000000000,0.0000000000],[20.0000000000,-7.0710678119,7.0710678119],[20.0000000000,7.0710678119,7.0710678119]]); '
         self.assertEqualOpenScadObject(expected, actual)
 
         # confirm we can rotate with a single supplied value
         path = [[0,0,0], [20, 0,0 ]]
         rotations = [45]
         actual = extrude_along_path(tri, path, rotations=rotations)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[6,0,1],[6,1,2],[6,2,0],[7,3,4],[7,4,5],[7,5,3]],points=[[0.0000000000,0.0000000000,0.0000000000],[0.0000000000,-10.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[20.0000000000,0.0000000000,0.0000000000],[20.0000000000,-7.0710678119,7.0710678119],[20.0000000000,7.0710678119,7.0710678119],[0.0000000000,-3.3333333333,3.3333333333],[20.0000000000,-0.0000000000,4.7140452079]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[0.0000000000,-10.0000000000,0.0000000000],[0.0000000000,0.0000000000,10.0000000000],[20.0000000000,0.0000000000,0.0000000000],[20.0000000000,-7.0710678119,7.0710678119],[20.0000000000,7.0710678119,7.0710678119]]); '
         self.assertEqualOpenScadObject(expected, actual)        
 
     def test_extrude_along_path_transforms(self):
@@ -95,13 +98,13 @@ def test_extrude_along_path_transforms(self):
         # Make sure we can take a transform function for each point in path
         transforms = [lambda p, path, loop: 2*p, lambda p, path, loop: 0.5*p]
         actual = extrude_along_path(tri, path, transforms=transforms)
-        expected = 'polyhedron(faces=[[0,3,1],[1,3,4],[1,4,2],[2,4,5],[2,5,0],[0,5,3],[6,0,1],[6,1,2],[6,2,0],[7,3,4],[7,4,5],[7,5,3]],points=[[0.0000000000,0.0000000000,0.0000000000],[0.0000000000,-20.0000000000,0.0000000000],[0.0000000000,0.0000000000,20.0000000000],[20.0000000000,0.0000000000,0.0000000000],[20.0000000000,-5.0000000000,0.0000000000],[20.0000000000,0.0000000000,5.0000000000],[0.0000000000,-6.6666666667,6.6666666667],[20.0000000000,-1.6666666667,1.6666666667]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[0.0000000000,-20.0000000000,0.0000000000],[0.0000000000,0.0000000000,20.0000000000],[20.0000000000,0.0000000000,0.0000000000],[20.0000000000,-5.0000000000,0.0000000000],[20.0000000000,0.0000000000,5.0000000000]]); '
         self.assertEqualOpenScadObject(expected, actual)
 
         # Make sure we can take a single transform function for all points
         transforms = [lambda p, path, loop: 2*p]
         actual = extrude_along_path(tri, path, transforms=transforms)
-        expected = 'polyhedron(faces = [[0, 3, 1], [1, 3, 4], [1, 4, 2], [2, 4, 5], [2, 5, 0], [0, 5, 3], [6, 0, 1], [6, 1, 2], [6, 2, 0], [7, 3, 4], [7, 4, 5], [7, 5, 3]], points = [[0.0000000000, 0.0000000000, 0.0000000000], [0.0000000000, -20.0000000000, 0.0000000000], [0.0000000000, 0.0000000000, 20.0000000000], [20.0000000000, 0.0000000000, 0.0000000000], [20.0000000000, -20.0000000000, 0.0000000000], [20.0000000000, 0.0000000000, 20.0000000000], [0.0000000000, -6.6666666667, 6.6666666667], [20.0000000000, -6.6666666667, 6.6666666667]]);'
+        expected = 'polyhedron(faces=[[0,1,3],[1,4,3],[1,2,4],[2,5,4],[2,0,5],[0,3,5],[2,1,0],[3,4,5]],points=[[0.0000000000,0.0000000000,0.0000000000],[0.0000000000,-20.0000000000,0.0000000000],[0.0000000000,0.0000000000,20.0000000000],[20.0000000000,0.0000000000,0.0000000000],[20.0000000000,-20.0000000000,0.0000000000],[20.0000000000,0.0000000000,20.0000000000]]);'
         self.assertEqualOpenScadObject(expected, actual)
 
     def test_extrude_along_path_numpy(self):