Updated with plot_positions, plot_3d_meshgrid_contour methods, optimize function leveraging the functionality spawning from the methods, and created the gr.components.Image functionality fostering the visualizations populating

app.py

@@ -485,6 +485,108 @@ class GWO:
         #plt.close()  # Close the figure to free up memory
         #return Image.open(buf)
 
+    def plot_positions(self, iterations=[0, 3, 7, 11]):
+        """Plot the positions of the particles over the specified iterations"""
+        # Load the all_positions data from the .npy file
+        all_positions = np.load('all_positions.npy', allow_pickle=True)
+        
+        # Create a figure with the correct number of subplots
+        num_iterations = len(iterations)
+        fig, axs = plt.subplots(num_iterations, figsize=(6, 4 * num_iterations))
+        
+        # If there is only one subplot, make it an array to simplify the loop
+        if num_iterations == 1:
+            axs = [axs]
+        
+        # Iterate over the subplots and the specified iterations to plot
+        for i, ax in enumerate(axs):
+            # Plot the particles' positions at the specified iteration
+            iteration = iterations[i]
+            if iteration < len(all_positions):
+                positions = all_positions[iteration]
+                ax.scatter(positions[:, 0], positions[:, 1], c='r', alpha=0.5)
+
+                # Set plot title and labels
+                ax.set_title(f'Iteration {iteration}')
+                ax.set_xlabel('X')
+                ax.set_ylabel('Y')
+            else:
+                ax.axis('off')  # Hide the subplot if the iteration is out of range
+
+        plt.tight_layout()
+
+        # Save the plot to a BytesIO object
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        image = Image.open(buf)
+        plt.close()
+
+        return image
+
+    def plot_3d_meshgrid_contour(self, obj):
+        """Plot the 3D meshgrid with a 2D contour on the base"""
+        # Define the range for the x and y axis
+        x_range = np.linspace(self.bounds.Lower()[0], self.bounds.Upper()[0], 100)
+        y_range = np.linspace(self.bounds.Lower()[1], self.bounds.Upper()[1], 100)
+
+        # Create a grid of points
+     
+          X, Y = np.meshgrid(x_range, y_range)
+        Z = np.zeros_like(X)
+
+        # Evaluate the objective function on the grid
+        for i in range(X.shape[0]):
+            for j in range(X.shape[1]):
+                Z[i, j] = obj.Evaluate(np.array([X[i, j], Y[i, j]]))
+
+        # Create a 3D plot with subplots for each rotation
+        fig, axs = plt.subplots(2, 2, figsize=(14, 10), subplot_kw={'projection': '3d'})
+        plt.subplots_adjust(wspace=0.1, hspace=0.1)
+
+        # Define the rotations for each subplot
+        rotations = [(30, 45), (30, 135), (30, -45), (30, -135)]
+
+        for i, ax in enumerate(axs.flatten()):
+            # Plot the meshgrid
+            ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.5)
+
+            # Plot the contour
+            ax.contour(X, Y, Z, levels=20, colors='k', alpha=0.5)
+
+            # Plot the best positions found by the algorithm
+            best_positions = np.array(self.gpos)
+            ax.plot(best_positions[:, 0], best_positions[:, 1], self.gbest, 'g*', markersize=4)
+
+            # Set labels and title
+            ax.set_xlabel('X Position')
+            ax.set_ylabel('Y Position')
+            ax.set_zlabel('Z Position')
+            ax.set_title(f'GWO Optimization Process in 3D - Rotation {i+1}')
+
+            # Set the limits of the plot to match the bounds
+            ax.set_xlim(self.bounds.Lower()[0], self.bounds.Upper()[0])
+            ax.set_ylim(self.bounds.Lower()[1], self.bounds.Upper()[1])
+            ax.set_zlim(np.min(Z), np.max(Z))
+
+            # Change the background color to light blue
+            ax.set_facecolor('lightblue')
+
+            # Apply the rotation
+            ax.view_init(*rotations[i])
+
+        # Show the plot
+        plt.show()
+
+        # Save the plot to a BytesIO object
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        image = Image.open(buf)
+        plt.close()
+
+        return image
+
 
 
 def optimize(npart, ndim, max_iter):
@@ -513,12 +615,18 @@ def optimize(npart, ndim, max_iter):
     # Plot the dispersion heatmap
     dispersion_heatmap_plot = gwo.plot_dispersion_heatmap(x_range=(-6,6), y_range=(-6,6))
 
+    # Plot the plot_positions 
+    plot_positions = gwo.plot_positions(iterations=[0,2,9,11])
+
+    # Plot the plot_3d_meshgrid_contour
+    plot_3d_meshgrid_contour = gwo.plot_3d_meshgrid_contour(obj=obj)
+
     # Format the output strings
     best_fitness_text = f"Best Fitness: {best_fitness_npy}"
     best_positions_text = f"Best Positions: {best_positions_npy}"
 
     # Return the images and text
-    return plot_contour_and_wolves, dispersion_plot, dispersion_heatmap_plot, best_fitness_text, best_positions_text, best_fitness_npy, best_positions_npy, dispersion_text
+    return plot_contour_and_wolves, dispersion_plot, dispersion_heatmap_plot, plot_positions, plot_3d_meshgrid_contour, best_fitness_text, best_positions_text, best_fitness_npy, best_positions_npy, dispersion_text
 
 
 
@@ -535,6 +643,8 @@ iface = gr.Interface(
         gr.components.Image(type="pil", label="Contour Map of Wolves Oscillating Over Search Space"),
         gr.components.Image(type="pil", label="Dispersion Plot"),
         gr.components.Image(type="pil", label="Dispersion Heatmap Plot"),
+        gr.components.Image(type="pil", label="Best Positions Plot"),
+        gr.components.Image(type="pil", label="Plot 3D Meshgrid Contour"),
         gr.components.Textbox(label="Dispersion Values"),
         gr.components.Textbox(label="Best Positions"),
         gr.components.Textbox(label="Best Fitness")