Update app.py

app.py

@@ -30,10 +30,21 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
     contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
     
     # find the contour with the largest area
-    largest_contour_idx = np.argmax([cv2.contourArea(c) for c in contours])
-    largest_contour = contours[largest_contour_idx]
+    # largest_contour_idx = np.argmax([cv2.contourArea(c) for c in contours])
+    # largest_contour = contours[largest_contour_idx]
 
-    verts = [tuple(coord) for coord in contours[largest_contour_idx].squeeze()]
+    # combine contours
+    def combine_all_contours(contours):
+        combined_contour = np.array([], dtype=np.int32).reshape(0, 1, 2)
+    
+        for contour in contours:
+            combined_contour = np.vstack((combined_contour, contour))
+    
+        return combined_contour
+    
+    largest_contour = combine_all_contours(contours)
+
+    verts = [tuple(coord) for coord in largest_contour.squeeze()]
 
     xs, ys = zip(*verts)
     xs, ys = np.asarray(xs), np.asarray(ys)
@@ -65,33 +76,19 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
         coef = np.trapz(f_exp * np.exp(-n * t_values * 1j), t_values) / tau
         return coef
     
-    # Pre-compute the interpolated values
-    f_exp_precomputed = np.interp(t_values, t_list, xs + 1j * ys)
+    # pre-compute the interpolated values
+    f_precomputed = np.interp(t_values, t_list, xs + 1j * ys)
     
     N = coefficients
     indices = [0] + [j for i in range(1, N + 1) for j in (i, -i)]
 
-    print("Number of threads used:", os.cpu_count())
-    
-    # Parallelize the computation of coefficients
+    # parallelize the computation of coefficients
     with ThreadPoolExecutor() as executor:
-        coefs = list(executor.map(lambda n: (compute_cn(f_exp_precomputed, n, t_values), n), indices))
+        print("Number of threads used:", executor._max_workers)
+        coefs = list(executor.map(lambda n: (compute_cn(f_precomputed, n, t_values), n), indices))
     
-    # Ensure the zeroth coefficient is computed only once
     coefs = [(coefs[0][0], 0)] + coefs[1:]
 
-    # def compute_cn(n, t_list, xs, ys):
-    #     """
-    #     Integrate the contour along axis (-1) using the composite trapezoidal rule.
-    #     https://numpy.org/doc/stable/reference/generated/numpy.trapz.html#r7aa6c77779c0-2
-    #     """
-    #     f_exp = np.interp(t_values, t_list, xs + 1j * ys) * np.exp(-n * t_values * 1j)
-    #     coef = np.trapz(f_exp, t_values) / tau
-    #     return coef
-
-    # N = coefficients
-    # coefs = [(compute_cn(0, t_list, xs, ys), 0)] + [(compute_cn(j, t_list, xs, ys), j) for i in range(1, N+1) for j in (i, -i)]
-
     # animate the drawings
     fig, ax = plt.subplots()
     circles = [ax.plot([], [], 'b-')[0] for _ in range(-N, N+1)]
@@ -106,17 +103,15 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
 
     draw_x, draw_y = [], []
 
-    # Pre-compute static values outside the animate function
+    # pre-compute static values outside the animate function
     theta = np.linspace(0, tau, 80)
-    coefs_static = [(np.linalg.norm(c), fr) for c, fr in coefs]  # Assuming `r` remains constant
+    coefs_static = [(np.linalg.norm(c), fr) for c, fr in coefs]
     
     def animate(i, coefs, time):
-        t = time[i]
         center = (0, 0)
-    
-        # Loop over coefficients
+
         for _, (r, fr) in enumerate(coefs_static):
-            c_dynamic = coefs[_][0] * np.exp(1j * (fr * tau * t))  # Dynamic part of 'c'
+            c_dynamic = coefs[_][0] * np.exp(1j * (fr * tau * time[i]))
             x, y = center[0] + r * np.cos(theta), center[1] + r * np.sin(theta)
             circle_lines[_].set_data([center[0], center[0] + np.real(c_dynamic)], [center[1], center[1] + np.imag(c_dynamic)])
             circles[_].set_data(x, y)