do rotation animation in script instead of makefile

Makefile

 	./render.py -s 192000 -o $@ $<
 
 output/%_rotate.wav: %.svg
-	for number in {000..360..5} ; do \
-	   ./render.py -s 192000 -t 0.07 -o output/$(@F)_$$number.wav -r $$number $< ; \
-	done
-	ffmpeg -f concat -safe 0 -i <( for f in output/$(@F)_*.wav; do echo "file '$$(pwd)/$$f'"; done ) $@
-	rm output/$(@F)_*.wav
+	./render.py -s 192000 -p 72 -o $@ $<
 
 .PHONY: clean
 clean:

render.py

         p.append(v)
     return p
 
-def read_image(filename, path_steps, volume_percent, angle_d):
+def read_image(filename, path_steps, volume_percent,
+               samplerate, time,
+               angle_d, rot_steps, rot_size):
     paths, attributes = svg2paths(filename)
     print("paths={}".format(len(paths)))
     for i, path in enumerate(paths):
         print("path={} segments={}".format(i, len(path)))
 
     # find center point to rotate around
-    p0 = [paths[0][0].start.real, paths[0][0].start.imag]
+    p0 = [ paths[0][0].start.real, paths[0][0].start.imag ]
     p_min = [p0[0], p0[1]]
     p_max = [p0[0], p0[1]]
     for path in paths:
         for segment in path:
-            p = [segment.end.real, segment.end.imag]
+            p = [ segment.end.real, segment.end.imag ]
             for i in range(0, 2):
                 if p[i] < p_min[i]:
                     p_min[i] = p[i]
 
     # find bounding box for rotated object
     for path in paths:
-        # TODO this is not nice.
-        # Doing both range(0, 360, 5) and angle_d is redundant.
-        # But also, it bakes in the assumption of the animation
-        # that's specified in the Makefile.
-        # Ideally the animation should be handled here in the
-        # script instead, with proper parameters.
-
-        # find min max for all rotations
         for segment in path:
-            p_org = [segment.end.real, segment.end.imag]
-            for a in range(0, 360, 5):
-                p = rot_p(p_center, p_org , a)
+            a = angle_d
+            while (a < (angle_d + (rot_steps * rot_size))) or ((rot_steps <= 0) and (a == angle_d)):
+                p = rot_p(p_center, [ segment.end.real, segment.end.imag ], a)
                 for i in range(0, 2):
                     if p[i] < p_min[i]:
                         p_min[i] = p[i]
                     if p[i] > p_max[i]:
                         p_max[i] = p[i]
-
-        # find min max for this specific rotation
-        for segment in path:
-            p = [segment.end.real, segment.end.imag]
-            p = rot_p(p_center, p, angle_d)
-            for i in range(0, 2):
-                if p[i] < p_min[i]:
-                    p_min[i] = p[i]
-                if p[i] > p_max[i]:
-                    p_max[i] = p[i]
+                a += rot_size
 
     print("min={} max={}".format(p_min, p_max))
     print("center={} ".format(p_center))
 
-    data = bytearray()
-
-    def add_point(p):
+    def add_point(p, data):
         for i in range(0, 2):
             v = p[i]
             v -= p_min[i]
             c = int((v * 2 - 1) * (32767 / 100 * volume_percent))
             data.extend(c.to_bytes(2, byteorder="little", signed=True))
 
-    def add_segment(p1, p2):
+    def add_segment(p1, p2, data):
         l = math.sqrt((p2[0] - p1[0]) ** 2 + (p2[1] - p1[1]) ** 2)
         ps = max(1, int(path_steps * l))
         for step in range(0, ps):
             p = interpolate(p1, p2, step / ps)
-            add_point(p)
+            add_point(p, data)
 
-    for path in paths:
-        p0 = [path[0].start.real, path[0].start.imag]
-        points = [rot_p(p_center, p0, angle_d)]
-        for segment in path:
-            p = [segment.end.real, segment.end.imag]
-            p = rot_p(p_center, p, angle_d)
-            points.append(p)
+    wave = bytearray()
+
+    a = angle_d
+    while (a < (angle_d + (rot_steps * rot_size))) or ((rot_steps <= 0) and (a == angle_d)):
+        data = bytearray()
+
+        for path in paths:
+            p0 = [ path[0].start.real, path[0].start.imag ]
+            points = [ rot_p(p_center, p0, a) ]
+            for segment in path:
+                p = [ segment.end.real, segment.end.imag ]
+                p = rot_p(p_center, p, a)
+                points.append(p)
+
+            # walk path forwards
+            for n in range(0, len(points) - 1):
+                add_segment(points[n], points[n + 1], data)
+
+            # walk path backwards
+            add_point(points[len(points) - 1], data)
+            for n in range(len(points) - 2, -1, -1):
+                add_segment(points[n + 1], points[n], data)
+            add_point(points[0], data)
 
-        # walk path forwards
-        for n in range(0, len(points) - 1):
-            add_segment(points[n], points[n + 1])
+            # improve start/end of path. TODO only in virtual scope?
+            add_point(points[0], data)
 
-        # walk path backwards
-        add_point(points[len(points) - 1])
-        for n in range(len(points) - 2, -1, -1):
-            add_segment(points[n + 1], points[n])
-        add_point(points[0])
+        # extend data to required length / runtime
+        samplecount = int(len(data) / 2 / 2) # stereo, int16
+        drawrate = samplerate / samplecount
+        drawcount = drawrate * (time / max(1, rot_steps))
 
-        # improve start/end of path. TODO only in virtual scope?
-        add_point(points[0])
+        for n in range(0, max(1, int(drawcount))):
+            wave.extend(data)
 
-    return data
+        a += rot_size
+
+    return wave
 
 def write_waveform(data, filename, samplerate):
     with wave.open(filename, "w") as f:
                         help="Steps on interpolated paths. Defaults to 3.")
     parser.add_argument("-r", "--rotate", dest="angle_d", default=0.0, type=float,
                         help="Angle to rotate image, in degrees. Defaults to 0 deg.")
+    parser.add_argument("-p", "--rot-steps", dest="rot_steps", default=0, type=int,
+                        help="Number of steps to animate rotation. Defaults to 0.")
+    parser.add_argument("-z", "--rot-size", dest="rot_size", default=5.0, type=float,
+                        help="Step size for rotation animation. Defaults to 5 deg.")
 
     args = parser.parse_args()
     print(args)
 
-    wave = read_image(args.input, args.interpolate, args.volume, args.angle_d)
-
-    samplecount = int(len(wave) / 2 / 2) # stereo, int16
-    drawrate = args.samplerate / samplecount
-    drawcount = drawrate * args.time
-    print("len={} samples={} drawrate={:.2f} count={:.2f}".format(len(wave), samplecount, drawrate, drawcount))
-
-    data = bytearray()
-    for n in range(0, int(drawcount)):
-        data.extend(wave)
-    print("len={}".format(len(data)))
-
+    data = read_image(args.input, args.interpolate, args.volume,
+                      args.samplerate, args.time,
+                      args.angle_d, args.rot_steps, args.rot_size)
     write_waveform(bytes(data), args.output, args.samplerate)
 
 if __name__ == "__main__":