Update app.py

app.py

@@ -8,6 +8,7 @@ import gradio as gr
 from scipy.integrate import quad_vec
 from math import tau
 from PIL import Image
+from concurrent.futures import ThreadPoolExecutor
 
 
 def fourier_transform_drawing(input_image, frames, coefficients, img_size):
@@ -55,18 +56,41 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
     num_points = 1000  # how many points to use for numerical integration
     t_values = np.linspace(0, tau, num_points)
     t_list = np.linspace(0, tau, len(xs))
-
-    def compute_cn(n, t_list, xs, ys):
+    
+    def compute_cn(f_exp, n, t_values):
         """
         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
+        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)
+    
     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)]
+    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
+    with ThreadPoolExecutor() as executor:
+        coefs = list(executor.map(lambda n: (compute_cn(f_exp_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()
@@ -102,23 +126,6 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
         draw_y.append(center[1])
         drawing.set_data(draw_x[:i+1], draw_y[:i+1])
 
-    # def animate(i, coefs, time):
-    #     t = time[i]
-    #     center = (0, 0)
-    #     theta = np.linspace(0, tau, 80)
-    #     for _, (c, fr) in enumerate(coefs):
-    #         c = c * np.exp(1j*(fr * tau * t))
-    #         r = np.linalg.norm(c)
-    #         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)], [center[1], center[1] + np.imag(c)])
-    #         circles[_].set_data(x, y) 
-    #         center = (center[0] + np.real(c), center[1] + np.imag(c))
-        
-    #     draw_x.append(center[0])
-    #     draw_y.append(center[1])
-
-    #     drawing.set_data(draw_x[:i+1], draw_y[:i+1])
-
     drawing_time = 1
     time = np.linspace(0, drawing_time, num=frames)    
     anim = animation.FuncAnimation(fig, animate, frames=frames, interval=5, fargs=(coefs, time))