cleanup

Makefile

 	mkdir output
 
 output/%.wav: %.svg
-	./render.py -s 192000 -i 5 -o $@ $<
+	./render.py -s 192000 -o $@ $<
 
 output/%_rotate.wav: %.svg
 	for number in {000..360..5} ; do \
-	   ./render.py -s 192000 -i 5 -t 0.1 -o output/$(@F)_$$number.wav -r $$number $< ; \
+	   ./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

     p = [qx, qy]
     return p
 
+def interpolate(p1, p2, step):
+    p = []
+    for i in range(0, 2):
+        diff = p2[i] - p1[i]
+        v = p1[i] + diff * step
+        p.append(v)
+    return p
+
 def read_image(filename, path_steps, volume_percent, angle_d):
     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]
     p_min = [p0[0], p0[1]]
     p_max = [p0[0], p0[1]]
-
     for path in paths:
-        print("segments={}".format(len(path)))
-
-        # find center
-        dist_min = float('inf')
-        dist_max = 0
-        p_prev = p_min
         for segment in path:
             p = [segment.end.real, segment.end.imag]
             for i in range(0, 2):
                     p_min[i] = p[i]
                 if p[i] > p_max[i]:
                     p_max[i] = p[i]
-
-            dist_curr = math.sqrt((p[0] - p_prev[0]) ** 2 + (p[1] - p_prev[1]) ** 2)
-            p_prev = p
-            if dist_curr > dist_max:
-                dist_max = dist_curr
-            if dist_curr < dist_min:
-                dist_min = dist_curr
-
     p_center = [ p_min[0] + (p_max[0] - p_min[0]) / 2, p_min[1] + (p_max[1] - p_min[1]) / 2 ]
 
+    # 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.
 
     print("min={} max={}".format(p_min, p_max))
     print("center={} ".format(p_center))
-    print("dist min={} max={} ".format(dist_min, dist_max))
 
     data = bytearray()
 
             c = int((v * 2 - 1) * (32767 / 100 * volume_percent))
             data.extend(c.to_bytes(2, byteorder="little", signed=True))
 
-    def interpolate(p1, p2, step):
-        p = []
-        for i in range(0, 2):
-            diff = p2[i] - p1[i]
-            v = p1[i] + diff * step
-            p.append(v)
-        return p
-
-    def add_segment(p1, p2, f):
-        p = interpolate(p1, p2, f)
-        add_point(p)
-
-    def add_path(p1, p2):
+    def add_segment(p1, p2):
         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):
-            add_segment(p1, p2, step / ps)
+            p = interpolate(p1, p2, step / ps)
+            add_point(p)
 
     for path in paths:
-        p = [path[0].start.real, path[0].start.imag]
-        p = rot_p(p_center, p , angle_d)
-        points = [p]
+        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)
+            p = rot_p(p_center, p, angle_d)
             points.append(p)
 
         # walk path forwards
         for n in range(0, len(points) - 1):
-            add_path(points[n], points[n + 1])
-        add_point(points[len(points) - 1])
+            add_segment(points[n], points[n + 1])
 
         # walk path backwards
+        add_point(points[len(points) - 1])
         for n in range(len(points) - 2, -1, -1):
-            add_path(points[n + 1], points[n])
+            add_segment(points[n + 1], points[n])
+        add_point(points[0])
+
+        # improve start/end of path. TODO only in virtual scope?
         add_point(points[0])
 
     return data