Update app.py

app.py

@@ -1,16 +1,17 @@
-import gradio as gr
+import os
+import io
 import cv2
 import matplotlib.animation as animation
 import matplotlib.pyplot as plt
 import numpy as np
+import gradio as gr
 from scipy.integrate import quad_vec
 from math import tau
-import os
 from PIL import Image
-import io
+
 
 def fourier_transform_drawing(input_image, frames, coefficients):
-    # Convert input_image to an OpenCV image
+    # Convert PIL to OpenCV image(array)
     input_image = np.array(input_image)
     img = cv2.cvtColor(input_image, cv2.COLOR_RGB2BGR)
 
@@ -18,26 +19,30 @@ def fourier_transform_drawing(input_image, frames, coefficients):
     imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     blurred = cv2.GaussianBlur(imgray, (7, 7), 0)
 
-    (T, thresh) = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
+    # apply Otsu threshold
+    (_, thresh) = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
 
+    # find contours of the binary image
     contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    
+    # take only the largest contour
     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 = np.asarray(xs) - np.mean(xs)
-    ys = - np.asarray(ys) + np.mean(ys)
+    #xs = np.asarray(xs) - np.mean(xs)
+    #ys = - np.asarray(ys) + np.mean(ys)
 
-    # Calculate the range of xs and ys
+    # calculate the range of xs and ys
     x_range = np.max(xs) - np.min(xs)
     y_range = np.max(ys) - np.min(ys)
     
-    # Determine the scale factors
-    desired_range = 500
+    # determine the scale factors
+    desired_range = 400
     scale_factor_x = desired_range / x_range
     scale_factor_y = desired_range / y_range
     
-    # Apply scaling
+    # apply scaling
     xs = (xs - np.mean(xs)) * scale_factor_x
     ys = (ys - np.mean(ys)) * scale_factor_y
 
@@ -65,11 +70,11 @@ def fourier_transform_drawing(input_image, frames, coefficients):
     circle_lines = [ax.plot([], [], 'g-')[0] for _ in range(-N, N+1)]
     drawing, = ax.plot([], [], 'r-', linewidth=2)
 
-    ax.set_xlim(-500, 500)
-    ax.set_ylim(-500, 500)
+    ax.set_xlim(-desired_range, desired_range)
+    ax.set_ylim(-desired_range, desired_range)
     ax.set_axis_off()
-    ax.set_aspect('equal')
-    fig.set_size_inches(15, 15)
+    #ax.set_aspect('equal')
+    #fig.set_size_inches(15, 15)
 
     draw_x, draw_y = [], []
     
@@ -82,7 +87,7 @@ def fourier_transform_drawing(input_image, frames, coefficients):
             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)])
+            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))
         
@@ -94,12 +99,12 @@ def fourier_transform_drawing(input_image, frames, coefficients):
     time = np.linspace(0, drawing_time, num=frames)    
     anim = animation.FuncAnimation(fig, animate, frames=frames, interval=5, fargs=(coefs, time)) 
 
-    # Save the animation as an MP4 file
+    # save the animation as an MP4 file
     output_animation = "output.mp4"
     anim.save(output_animation, fps=15)
     plt.close(fig)
 
-    # Return the path to the MP4 file
+    # return the path to the MP4 file
     return output_animation
 
 # Gradio interface