Update app.py

app.py

@@ -11,6 +11,9 @@ from PIL import Image
 
 
 def fourier_transform_drawing(input_image, frames, coefficients, img_size):
+    """
+    
+    """
     # Convert PIL to OpenCV image(array)
     input_image = np.array(input_image)
     img = cv2.cvtColor(input_image, cv2.COLOR_RGB2BGR)
@@ -28,10 +31,11 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
     # 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([len(c) for c in contours])
+
     verts = [tuple(coord) for coord in contours[largest_contour_idx].squeeze()]
 
     xs, ys = zip(*verts)
+    xs, ys = np.asarray(xs), np.asarray(ys)
 
     # calculate the range of xs and ys
     x_range = np.max(xs) - np.min(xs)
@@ -39,46 +43,30 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
     
     # determine the scale factors
     desired_range = 400
-    scale_factor_x = desired_range / x_range
-    scale_factor_y = desired_range / y_range
+    scale_x = desired_range / x_range
+    scale_y = desired_range / y_range
     
     # apply scaling
     # ys needs to be flipped vertically
-    xs = (np.asarray(xs) - np.mean(xs)) * scale_factor_x
-    ys = (-np.asarray(ys) + np.mean(ys)) * scale_factor_y
-
-    t_list = np.linspace(0, tau, len(xs))
+    xs = (xs - np.mean(xs)) * scale_x
+    ys = (-ys + np.mean(ys)) * scale_y
 
     # compute the Fourier coefficients
-    def f(t, t_list, xs, ys):
-        return np.interp(t, t_list, xs + 1j * ys)
+    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(f, n, t_list, xs, ys):
-        num_points = 1000  # Adjust this based on required precision
-        t_values = np.linspace(0, tau, num_points)
-    
-        # Vectorized operation
-        integrand = f(t_values, t_list, xs, ys) * np.exp(-n * t_values * 1j)
-        
-        coef = np.trapz(integrand, t_values) / tau
+    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, t_list, xs + 1j * ys) * np.exp(-n * t_values * 1j)
+        coef = np.trapz(f_exp, t_values) / tau
         return coef
 
-    
-    # # compute the Fourier coefficients
-    # def f(t, t_list, xs, ys):
-    #     return np.interp(t, t_list, xs + 1j*ys)
-
-    # def compute_cn(f, n):
-    #     coef = 1/tau*quad_vec(
-    #         lambda t: f(t, t_list, xs, ys)*np.exp(-n*t*1j), 
-    #         0, 
-    #         tau, 
-    #         limit=100, 
-    #         full_output=False)[0]
-    #     return coef
-
     N = coefficients
-    coefs = [(compute_cn(f, 0, t_list, xs, ys), 0)] + [(compute_cn(f, j, t_list, xs, ys), j) for i in range(1, N+1) for j in (i, -i)]
+    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()
@@ -96,12 +84,11 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
     
     def animate(i, coefs, time):
         t = time[i]
-        coefs = [(c * np.exp(1j*(fr * tau * t)), fr) for c, fr in coefs]
         center = (0, 0)
-
-        for c, _ in coefs:
+        theta = np.linspace(0, tau, 80)
+        for c, fr in coefs:
+            c = c * np.exp(1j*(fr * tau * t)
             r = np.linalg.norm(c)
-            theta = np.linspace(0, tau, 80)
             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) 
@@ -121,7 +108,6 @@ def fourier_transform_drawing(input_image, frames, coefficients, img_size):
     anim.save(output_animation, fps=15)
     plt.close(fig)
 
-    # return the path to the MP4 file
     return output_animation
 
 # Gradio interface