I tried to implement a formula, from which a coefficients of Fourier Series could be calculated. (I used 3B1B's video about it: Video) and writing code for that, my first test subject was singular contour of batman logo, I first take a binary picture of batman logo and use marching squares algorithm to find contour of it. after that i rescale values and get this results:  And Here is Code for creating this points: (Contour_Classifier.py) import numpy as np import matplotlib.pyplot as plt from skimage import measure, draw def read_binary_image(file_path): # Open the file and read line by line with open(file_path, 'r') as file: lines = file.readlines() height, width = len(lines), len(lines[0]) print(height, width) # Process lines into a 2D numpy array image_data = [] for i in range(height + 2): arr = [] for j in range(width + 2): arr.append(0) image_data.append(arr) for i in range(2, height + 1): for j in range(2, width + 1): if(lines[i - 2][j - 2] != '1'): image_data[i][j] = 0 else: image_data[i][j] = 1 # Convert list to numpy array for easier manipulation image_array = np.array(image_data) return image_array def display_image(image_array): # Display the binary image using matplotlib plt.imshow(image_array, cmap="gray") plt.axis('off') # Hide axes plt.show() # Example usage file_path = 'KOREKT\images\sbetmeni.txt' # Replace with the path to your file image_array = read_binary_image(file_path) #display_image(image_array) #---------------------------------------------------------------------------------------------------------- #-------------------------------------------Finding Contours----------------------------------------------- #---------------------------------------------------------------------------------------------------------- contours = measure.find_contours(image_array, level=0.5, positive_orientation='high') fixed_contours = [] for contour in contours: fixed_contour = np.column_stack((contour[:, 1], contour[:, 0])) # Swap (row, column) to (column, row) fixed_contour[:, 1] = image_array.shape[0] - fixed_contour[:, 1] # Invert the y-axis # Normalize coordinates between [0, 1] fixed_contour[:, 0] /= image_array.shape[1] # Normalize x (width) fixed_contour[:, 1] /= image_array.shape[0] # Normalize y (height) fixed_contour[:, 0] *= 250 # Normalize x (width) fixed_contour[:, 1] *= 250 # Normalize y (height) fixed_contours.append(fixed_contour) contours = fixed_contours print(fixed_contours[0]) def visualize_colored_contours(contours, title="Colored Contours"): # Create a plot plt.figure(figsize=(8, 8)) for i, contour in enumerate(contours): # Extract X and Y coordinates x, y = zip(*contour) # Plot the points with a unique color plt.plot(x, y, marker='o', label=f'Contour {i+1}') plt.title(title) plt.xlabel("X") plt.ylabel("Y") plt.legend() plt.grid(True) plt.axis("equal") plt.show() # Visualize the normalized contours visualize_colored_contours(contours)  Now we go to the main part, where we implement the fourier series algorithm. I divide the time interal (t) into the amount of points provided and i make assumtion that all of that points relative to t have same distances between eachother. I use approximation of integral as the sum of the points as provided into the formula. And Here is code implementing it (Fourier_Coefficients.py): import numpy as np def calculate_Fourier(points, num_coefficients): complex_points = [] for point in points: complex_points.append(point[0] + 1j * point[1]) t = np.linspace(0, 1, len(complex_points), endpoint=False) c_k = np.zeros(num_coefficients, dtype=np.complex128) for i in range(num_coefficients): c_k[i] = np.sum(complex_points * np.exp(-2j * np.pi * i * t) * t[1]) return c_k  (NOTE: For this code t1 is basically deltaT, because it equals to 1/len(complex_points) And Now, in the next slide i animate whole process, where i also wrote additional code snippet for creating a gif. If my implementation were correct it shouldn't have anu difficulty creating a batman shape, but we can observe really weird phenomenons throught the gif. this is code snippet for this part import numpy as np import matplotlib.pyplot as plt import imageio from Fourier_Coefficients import calculate_Fourier from Countour_Classifier import contours # List to store file names for GIF creation png_files = [] # Generate plots iteratively for i in range(len(contours[0])): contour_coefficients = [] for contour in contours: contour_coefficients.append(calculate_Fourier(contour, i)) # Fourier coefficients (complex numbers) and frequencies coefficients = contour_coefficients[0] # First contour frequencies = np.arange(len(coefficients)) # Time parameters t = np.linspace(0, 1, len(coefficients)) # One period curve = np.zeros(len(t), dtype=complex) # Use the first (i + 1) coefficients for j in range(len(coefficients)): c, f = coefficients[j], frequencies[j] curve += c * np.exp(1j * 2 * np.pi * f * t) # Plotting plt.figure(figsize=(8, 8)) plt.plot(curve.real, curve.imag, label="Trajectory", color="blue") plt.scatter(0, 0, color="black", label="Origin") plt.axis("equal") plt.title(f"Fourier Series with {i + 1} Coefficients") plt.xlabel("Real Part (X)") plt.ylabel("Imaginary Part (Y)") plt.legend() plt.text(-0.5, -0.5, f"Using {i + 1} coefficients", fontsize=12, color="red") # Save the figure as a PNG file filename = f"fourier_{i + 1}_coefficients.png" plt.savefig(filename) plt.close() # Append the file name to the list png_files.append(filename) # Create a GIF from the PNG files gif_filename = "fourier_series.gif" with imageio.get_writer(gif_filename, mode='I', duration=0.5) as writer: for filename in png_files: image = imageio.imread(filename) writer.append_data(image) print("Plots saved as PNG files and GIF created as 'fourier_series.gif'.")  Now this is the result GIF Observation #1 when coefficients number is 0, 1, 2 or 3 it doesnt draw anything. Observation #2 As coefficients number raises, we get the wobbly circular shape, where the lower part of the image is slightly more identical tot he original imagine, but messes up on its wings Observation #3 As we get closer to the len(complex_numbers), the situacion changes and we get this weird shapes, different from circular Observation #4 When we surpass the len(complex_number), it draws a random gibberish Observation #5 When the number of the divisions inside the t value in animation.py code is altered we get completely different images. EDIT 1 here is actual .txt data provided for further testing. https://pastebin.com/Q51pT09E After all of this information given, can you guys help me out whats wrong with my code
In the definition of the Fourier series, you can see that n goes from negative infinity to positive infinity. The issue in your code is that you forgot to compute the coefficients associated with negative values of n. Here is a simple example that shows how to compute the coefficients (from -50 to 50) associated with an ellipse, and build a curve from them: import numpy as np import matplotlib.pyplot as plt def get_ellipse(): t = np.linspace(0, 1, 100) X = 2 * np.cos(2 * np.pi * t) Y = np.sin(2 * np.pi * t) return (X, Y) def calculate_Fourier(X, Y, N): complex_points = [complex(x, y) for x, y in zip(X, Y)] t = np.linspace(0, 1, len(complex_points), endpoint=False) coefficients = np.zeros(2 * N + 1, dtype=complex) for i in range(len(coefficients)): n = i - N coefficients[i] = np.sum(complex_points * np.exp(-2j * np.pi * n * t) * t[1]) return coefficients def build_curve(coefficients, num_points): N = (len(coefficients) - 1) / 2 t = np.linspace(0, 1, num_points) curve = np.zeros(num_points, dtype=complex) for i in range(len(coefficients)): c = coefficients[i] n = i - N curve += c * np.exp(2j * np.pi * n * t) return curve X, Y = get_ellipse() coefficients = calculate_Fourier(X, Y, 50) curve = build_curve(coefficients, 50) plt.plot(curve.real, curve.imag, color="blue") plt.show()  Result:  Remark: if the number of coefficients is too high, you will get numerical instability.