improved

.gitignore

@@ -0,0 +1 @@
+__pycache__

README.md

@@ -1,6 +1,6 @@
 ---
 title: Fractal Generator
-emoji: 💩
+emoji: 😀
 colorFrom: indigo
 colorTo: pink
 sdk: gradio

app.py

@@ -0,0 +1,55 @@
+import gradio as gr
+from numpy import *
+
+from fractal_generator import FractalGenerator
+
+TITLE = "Fractal Generator"
+DESCRIPTION = "<center>Create your own fractal art!</center>"
+EXAMPLES = [
+    ["Julia", "sin(z**4 + 1.41)"],
+    ["Julia", "sin(z**4 + 1.41)*exp(2.4*1J)"],
+    ["Julia", "sin(z**4 + 3.41)*exp(2.5*1J)"],
+]
+ARTICLE = r"""<center>
+              This application uses Julia and Mandelbrot fractal algorithms.
+              These plots show the convergence plot for infinitely composed complex functions <br>
+              These functions are based on artist-defined generating functions $f(z)$ with $z /in /mathbb{C}$ as follows<br>
+              $$ F(z) = /prod^{/inf} f(z)  $$<br>
+              Done by dr. Gabriel Lopez<br> 
+              For more please visit: <a href='https://sites.google.com/view/dr-gabriel-lopez/home'>My Page</a><br>
+              </center>"""
+
+# interactive function
+def plot_fractal(fractal_type: str, python_function: str):
+    frac = FractalGenerator(n=500, max_iter=10)
+    if fractal_type == "Julia":
+        frac.create_julia(lambda z: eval(python_function))
+    elif fractal_type == "Mandelbrot":
+        frac.create_mandelbrot()
+    else:
+        print("Current wrong option: ", fractal_type)
+    return frac.plot()
+
+
+# gradio frontend elements
+in_dropdown = gr.Dropdown(
+    choices=["Julia", "Mandelbrot"], label="Select a type of fractal:", value="Julia"
+)
+in_text = gr.Textbox(
+    value="sin(z**4 + 1.41)",
+    label="Enter function using $z$ as complex-variable. You can use all numpy functions. 1J = /sqrt{-1}",
+    placeholder="your own z function",
+    lines=4,
+)
+out_plot = gr.Plot(label="Fractal plot")
+
+# gradio interface
+gr.Interface(
+    inputs=[in_dropdown, in_text],
+    outputs=out_plot,
+    fn=plot_fractal,
+    examples=EXAMPLES,
+    title=TITLE,
+    description=DESCRIPTION,
+    article=ARTICLE,
+).launch()

fractal_generator.py

@@ -1,9 +1,7 @@
-from pathlib import Path
+from enum import Enum
 
-import matplotlib.pyplot as plt
 import numpy as np
-import os
-from enum import Enum
+import plotly.express as px
 
 
 class FractalType(Enum):
@@ -12,17 +10,17 @@ class FractalType(Enum):
 
 
 class FractalGenerator:
-    """ Creates a single fractal object and either returns it as as a numpy array, plot it or persists it as an pgn
-            image. The output of this class is used by FractalTrainingValidationSet to generate training/val sets
-            Args:
-                complex_function -- complex function to make a Julia fractal
-                n -- fractal size will ne n*n
-                xlim,ylim -- tuples with the plotting region on the complex plane
-                thr -- once a function grows larger that this number is considered to be divergent to infinity
-                max_iter -- number of compositions of the complex function with itself
-                type_ -- fractal type
-                fractal -- numpy array with the fractal
-        """
+    """Creates a single fractal object and either returns it as as a numpy array, plot it or persists it as an pgn
+    image. The output of this class is used by FractalTrainingValidationSet to generate training/val sets
+    Args:
+        complex_function -- complex function to make a Julia fractal
+        n -- fractal size will ne n*n
+        xlim,ylim -- tuples with the plotting region on the complex plane
+        thr -- once a function grows larger that this number is considered to be divergent to infinity
+        max_iter -- number of compositions of the complex function with itself
+        type_ -- fractal type
+        fractal -- numpy array with the fractal
+    """
 
     def __init__(self, n=256, xlim=(-2, 2), ylim=(-2, 2), thr=2, max_iter=10):
         self.type_ = None
@@ -34,49 +32,46 @@ class FractalGenerator:
         self.max_iter = max_iter
 
     def create_julia(self, complex_function=lambda z: np.sin(z ** 4 + 1.41)):
-        """ Creates a fractal of the Julia family, the fractal is stored inside self.fractal """
-        fractal = np.zeros((self.n, self.n), dtype='complex')
+        """Creates a fractal of the Julia family, the fractal is stored inside self.fractal"""
+        fractal = np.zeros((self.n, self.n), dtype="complex")
         x_space = np.linspace(self.xlim[0], self.xlim[1], self.n)
         y_space = np.linspace(self.ylim[0], self.ylim[1], self.n)
         for ix, x in enumerate(x_space):
             for iy, y in enumerate(y_space):
                 for i in range(self.max_iter):
-                    if i == 0: z = complex(x, y)
+                    if i == 0:
+                        z = complex(x, y)
                     z = complex_function(z)
-                    if np.abs(z) >= self.thr: z = self.thr; break
+                    if np.abs(z) >= self.thr:
+                        z = self.thr
+                        break
                 fractal[ix, iy] = z
         self.fractal = np.abs(fractal)
         self.type_ = FractalType.Julia
         return self
 
     def create_mandelbrot(self):
-        """ Creates a fractal of the Mandelbrot family, the fractal is stored inside self.fractal """
-        fractal = np.zeros((self.n, self.n), dtype='complex')
+        """Creates a fractal of the Mandelbrot family, the fractal is stored inside self.fractal"""
+        fractal = np.zeros((self.n, self.n), dtype="complex")
         x_space = np.linspace(self.xlim[0], self.xlim[1], self.n)
         y_space = np.linspace(self.ylim[0], self.ylim[1], self.n)
         for ix, x in enumerate(x_space):
             for iy, y in enumerate(y_space):
                 for i in range(self.max_iter):
-                    if i == 0: z = 0
+                    if i == 0:
+                        z = 0
                     z = z ** 2 + complex(x, y)
-                    if np.abs(z) >= self.thr: z = self.thr; break
+                    if np.abs(z) >= self.thr:
+                        z = self.thr
+                        break
                 fractal[ix, iy] = z
         self.fractal = np.abs(fractal.transpose())
         self.type_ = FractalType.Mandelbrot
         return self
 
-    def plot(self, clim=None, **kwargs):
+    def plot(self, **kwargs):
         if self.fractal is None:
-            print('Nothing to plot. Generate a fractal first.')
+            print("Nothing to plot. Generate a fractal first.")
             return None
-        plt.matshow(self.fractal, **kwargs)
-        plt.gca().axes.get_xaxis().set_visible(False)
-        plt.gca().axes.get_yaxis().set_visible(False)
-        plt.clim(clim)
-        return plt.gcf()
-
-    def persist_plot(self, filename, container, clim=None, **kwargs):
-        if not os.path.isdir(container): os.mkdir(container)
-        self.plot(clim=clim, **kwargs)
-        plt.savefig(str(Path(container) / filename), png='png', dpi=None)
-        plt.close(plt.gcf())
+        fig = px.imshow(img=self.fractal, color_continuous_scale="orrd", **kwargs)
+        return fig

requirements.txt

@@ -1,3 +1,2 @@
-matplotlib==3.3.3
-numba==0.52.0
-numpy==1.19.5
+numpy==1.19.5
+plotly==5.11.0