Inspired by mickael.bosch@posteo.net, Let solid.utils.extrude_along_path() accept a list of Point2 for scale_factors, allowing independent x & y scaling for each point along the extrusion path. Added tests & expanded example

Author: etjones

solid/examples/path_extrude_example.py

@@ -1,22 +1,30 @@
 #! /usr/bin/env python3
+from solid.solidpython import OpenSCADObject
 import sys
-from math import cos, radians, sin
+from math import cos, radians, sin, pi, tau
+from pathlib import Path
 
-from euclid3 import Point3
+from euclid3 import Point2, Point3
 
-from solid import scad_render_to_file
-from solid.utils import extrude_along_path
+from solid import scad_render_to_file, text, translate
+from solid.utils import extrude_along_path, right
+
+
+from typing import Set, Sequence, List, Callable, Optional, Union, Iterable
 
 SEGMENTS = 48
 
 
 def sinusoidal_ring(rad=25, segments=SEGMENTS):
     outline = []
     for i in range(segments):
-        angle = i * 360 / segments
-        x = rad * cos(radians(angle))
-        y = rad * sin(radians(angle))
-        z = 2 * sin(radians(angle * 6))
+        angle = radians(i * 360 / segments)
+        scaled_rad = (1 + 0.18*cos(angle*5)) * rad
+        x = scaled_rad * cos(angle)
+        y = scaled_rad * sin(angle)
+        z = 0
+        # Or stir it up and add an oscillation in z as well
+        # z = 3 * sin(angle * 6)
         outline.append(Point3(x, y, z))
     return outline
 
@@ -29,28 +37,68 @@ def star(num_points=5, outer_rad=15, dip_factor=0.5):
         star_pts.append(Point3(rad * cos(angle), rad * sin(angle), 0))
     return star_pts
 
+def circle_points(rad: float = 15, num_points: int = SEGMENTS) -> List[Point2]:
+    angles = [tau/num_points * i for i in range(num_points)] 
+    points = list([Point2(rad*cos(a), rad*sin(a)) for a in angles])
+    return points
 
 def extrude_example():
     # Note the incorrect triangulation at the two ends of the path.  This
     # is because star isn't convex, and the triangulation algorithm for
     # the two end caps only works for convex shapes.
+    path_rad = 50
     shape = star(num_points=5)
-    path = sinusoidal_ring(rad=50)
+    path = sinusoidal_ring(rad=path_rad, segments=240)
+
+    # # If scale_factors aren't included, they'll default to
+    # # no scaling at each step along path.  Here, let's
+    # # make the shape twice as big at beginning and end of the path
+    # scales = [1] * len(path)
+    # n = len(path)
+    # scales = [1 + 0.5*sin(i*6*pi/n) for i in range(n)]
+    # scales[0] = 2
+    # scales[-1] = 2
+
+    extruded = extrude_along_path( shape_pts=shape, path_pts=path)
+    # Label
+    extruded += translate([-path_rad/2, 2*path_rad])(text('Basic Extrude'))
+    return extruded
+        
+def extrude_example_xy_scaling() -> OpenSCADObject:
+    num_points = SEGMENTS
+    path_rad = 50
+    circle = circle_points(15)
+    path = circle_points(rad = path_rad)
+
+    # angle: from 0 to 6*Pi
+    angles = list((i/(num_points - 1)*tau*3 for i in range(len(path))))
+
 
     # If scale_factors aren't included, they'll default to
-    # no scaling at each step along path.  Here, let's
-    # make the shape twice as big at beginning and end of the path
-    scales = [1] * len(path)
-    scales[0] = 2
-    scales[-1] = 2
+    # no scaling at each step along path.
+    no_scale_obj = translate([-path_rad / 2, 2 * path_rad])(text('No Scale'))
+    no_scale_obj += extrude_along_path(circle, path)
 
-    extruded = extrude_along_path(shape_pts=shape, path_pts=path, scale_factors=scales)
+    # With a 1-D scale factor, an extrusion grows and shrinks uniformly
+    x_scales = [(1 + cos(a)/2) for a in angles]
+    x_obj = translate([-path_rad / 2, 2 * path_rad])(text('1D Scale'))
+    x_obj += extrude_along_path(circle, path, scale_factors=x_scales)
 
-    return extruded
+    # With a 2D scale factor, a shape's X & Y dimensions can scale 
+    # independently, leading to more interesting shapes
+    # X & Y scales vary between 0.5 & 1.5
+    xy_scales = [Point2( 1 + cos(a)/2, 1 + sin(a)/2) for a in angles]
+    xy_obj = translate([-path_rad / 2, 2 * path_rad])( text('2D Scale'))
+    xy_obj += extrude_along_path(circle, path, scale_factors=xy_scales)
+
+    obj = no_scale_obj + right(3*path_rad)(x_obj) + right(6 * path_rad)(xy_obj)
+    return obj
 
+if __name__ == "__main__":
+    out_dir = sys.argv[1] if len(sys.argv) > 1 else Path(__file__).parent
 
-if __name__ == '__main__':
-    out_dir = sys.argv[1] if len(sys.argv) > 1 else None
-    a = extrude_example()
-    file_out = scad_render_to_file(a, out_dir=out_dir, include_orig_code=True)
+    basic_extrude = extrude_example()
+    scaled_extrusions = extrude_example_xy_scaling()
+    a = basic_extrude + translate([0,-250])(scaled_extrusions)
+    file_out = scad_render_to_file(a,  out_dir=out_dir, include_orig_code=True)
     print(f"{__file__}: SCAD file written to: \n{file_out}")

solid/test/test_utils.py

@@ -29,6 +29,7 @@
     ('arc_inverted', arc_inverted, [10, 0, 90, 24], '\n\ndifference() {\n\tintersection() {\n\t\trotate(a = 0) {\n\t\t\ttranslate(v = [-990, 0, 0]) {\n\t\t\t\tsquare(center = false, size = [1000, 1000]);\n\t\t\t}\n\t\t}\n\t\trotate(a = 90) {\n\t\t\ttranslate(v = [-990, -1000, 0]) {\n\t\t\t\tsquare(center = false, size = [1000, 1000]);\n\t\t\t}\n\t\t}\n\t}\n\tcircle($fn = 24, r = 10);\n}'),
     ('transform_to_point_scad', transform_to_point, [cube(2), [2, 2, 2], [3, 3, 1]], '\n\nmultmatrix(m = [[0.7071067812, -0.1622214211, -0.6882472016, 2], [-0.7071067812, -0.1622214211, -0.6882472016, 2], [0.0000000000, 0.9733285268, -0.2294157339, 2], [0, 0, 0, 1.0000000000]]) {\n\tcube(size = 2);\n}'),
     ('extrude_along_path', extrude_along_path, [tri, [[0, 0, 0], [0, 20, 0]]], '\n\npolyhedron(faces = [[0, 3, 1], [1, 3, 4], [1, 4, 2], [2, 4, 5], [0, 2, 5], [0, 5, 3], [0, 1, 2], [3, 5, 4]], 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]]);'),
+    ('extrude_along_path_xy_scale', extrude_along_path, [tri, [[0, 0, 0], [0, 20, 0]], [Point2(0.5, 1.5), Point2(1.5, 0.5)]], '\n\npolyhedron(faces = [[0, 3, 1], [1, 3, 4], [1, 4, 2], [2, 4, 5], [0, 2, 5], [0, 5, 3], [0, 1, 2], [3, 5, 4]], points = [[0.0000000000, 0.0000000000, 0.0000000000], [5.0000000000, 0.0000000000, 0.0000000000], [0.0000000000, 0.0000000000, 15.0000000000], [0.0000000000, 20.0000000000, 0.0000000000], [15.0000000000, 20.0000000000, 0.0000000000], [0.0000000000, 20.0000000000, 5.0000000000]]);'),
     ('extrude_along_path_vertical', extrude_along_path, [tri, [[0, 0, 0], [0, 0, 20]]], '\n\npolyhedron(faces = [[0, 3, 1], [1, 3, 4], [1, 4, 2], [2, 4, 5], [0, 2, 5], [0, 5, 3], [0, 1, 2], [3, 5, 4]], 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]]);'),
 
 ]

solid/utils.py

@@ -1120,7 +1120,7 @@ def path_2d_polygon(points:Sequence[Point23], width:float=1, closed:bool=False)
 # ==========================
 def extrude_along_path( shape_pts:Points, 
                         path_pts:Points, 
-                        scale_factors:Sequence[float]=None) -> OpenSCADObject:
+                        scale_factors:Sequence[Union[Vector2, float]]=None) -> OpenSCADObject:
     # Extrude the convex curve defined by shape_pts along path_pts.
     # -- For predictable results, shape_pts must be planar, convex, and lie
     # in the XY plane centered around the origin.
@@ -1132,9 +1132,6 @@ def extrude_along_path( shape_pts:Points,
     polyhedron_pts:Points= []
     facet_indices:List[Tuple[int, int, int]] = []
 
-    if not scale_factors:
-        scale_factors = [1.0] * len(path_pts)
-
     # Make sure we've got Euclid Point3's for all elements
     shape_pts = euclidify(shape_pts, Point3)
     path_pts = euclidify(path_pts, Point3)
@@ -1143,7 +1140,6 @@ def extrude_along_path( shape_pts:Points,
 
     for which_loop in range(len(path_pts)):
         path_pt = path_pts[which_loop]
-        scale = float(scale_factors[which_loop])
 
         # calculate the tangent to the curve at this point
         if which_loop > 0 and which_loop < len(path_pts) - 1:
@@ -1159,17 +1155,21 @@ def extrude_along_path( shape_pts:Points,
             tangent = path_pt - path_pts[which_loop - 1]
 
         # Scale points
-        this_loop:Point3 = []
-        if scale != 1.0:
-            this_loop = [(scale * sh) for sh in shape_pts]
-            # Convert this_loop back to points; scaling changes them to Vectors
-            this_loop = [Point3(v.x, v.y, v.z) for v in this_loop]
-        else:
-            this_loop = shape_pts[:] # type: ignore
+        this_loop = shape_pts[:] # type: ignore
+        scale_x, scale_y = [1, 1]
+        if scale_factors:
+            scale = scale_factors[which_loop]
+            if isinstance(scale, (int, float)):
+                scale_x, scale_y = scale, scale
+            elif isinstance(scale, Vector2):
+                scale_x, scale_y = scale.x, scale.y
+            else:
+                raise ValueError(f'Unable to scale shape_pts with scale value: {scale}')
+        this_loop = [Point3(v.x * scale_x, v.y * scale_y, v.z) for v in this_loop]
 
         # Rotate & translate
-        this_loop = transform_to_point(this_loop, dest_point=path_pt, 
-                                        dest_normal=tangent, src_up=src_up)
+        this_loop = transform_to_point(this_loop, dest_point=path_pt,
+                                       dest_normal=tangent, src_up=src_up)
 
         # Add the transformed points to our final list
         polyhedron_pts += this_loop