Fractal_explorer_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use in VS Code\n",
    "Create a python environment. I used 3.12.2\n",
    "activate the kernel for the env- I called mine jupy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 1: Use ! to run shell (wsl/linux I guess?) commands from an IPython notebook cell, windows seems to want %\n",
    "%pip install numpy pandas gradio matplotlib pyarrow ipywidgets \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 2 Import necessary libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import gradio as gr\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Polygon\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import os\n",
    "\n",
    "# Ensure the output directory exists\n",
    "output_dir = 'fractal_outputs'\n",
    "os.makedirs(output_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 3: Fractal Generation Functions\n",
    "def plot_fractal(fractal_type, depth_or_iter, c_real=0.0, c_imag=0.0, filename_prefix=\"fractal\"):\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.set_aspect('equal')\n",
    "    ax.axis('off')\n",
    "\n",
    "\n",
    "def sierpinski_triangle(vertices, depth):\n",
    "    \"\"\"Generate Sierpinski triangle fractal images.\n",
    "\n",
    "    Args:\n",
    "        ax (matplotlib.axes.Axes): Axes to draw the fractal on.\n",
    "        order (int): Order of recursion.\n",
    "        vertices (array): Array of x,y coordinates for triangle vertices.\n",
    "        filename_prefix (str): Prefix for saved image filenames.\n",
    "    \"\"\"\n",
    "\n",
    "    if depth == 0:\n",
    "        return [vertices]\n",
    "    else:\n",
    "        # Find midpoints of the triangle's edges\n",
    "        mid_01 = (vertices[0] + vertices[1]) / 2\n",
    "        mid_12 = (vertices[1] + vertices[2]) / 2\n",
    "        mid_20 = (vertices[2] + vertices[0]) / 2\n",
    "        # Recursively generate smaller triangles\n",
    "        triangle1 = sierpinski_triangle([vertices[0], mid_01, mid_20], depth - 1)\n",
    "        triangle2 = sierpinski_triangle([mid_01, vertices[1], mid_12], depth - 1)\n",
    "        triangle3 = sierpinski_triangle([mid_20, mid_12, vertices[2]], depth - 1)\n",
    "        return triangle1 + triangle2 + triangle3\n",
    "\n",
    "def mandelbrot(c, max_iter):\n",
    "    z = 0\n",
    "    n = 0\n",
    "    while abs(z) <= 2 and n < max_iter:\n",
    "        z = z*z + c\n",
    "        n += 1\n",
    "    return n\n",
    "\n",
    "def julia_set(c, max_iter, x_min, x_max, y_min, y_max, width, height):\n",
    "    julia = np.zeros((height, width))\n",
    "    for x in range(width):\n",
    "        for y in range(height):\n",
    "            zx = x * (x_max - x_min) / (width - 1) + x_min\n",
    "            zy = y * (y_max - y_min) / (height - 1) + y_min\n",
    "            z = complex(zx, zy)\n",
    "            n = 0\n",
    "            while np.abs(z) <= 2 and n < max_iter:\n",
    "                z = z * z + c\n",
    "                n += 1\n",
    "            julia[y, x] = n\n",
    "    return julia\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ipynb Cell 4: Gradio Interface Functions\n",
    "def plot_fractal(fractal_type, depth_or_iter, c_real=0.0, c_imag=0.0):\n",
    "    if fractal_type == \"Sierpinski Triangle\":\n",
    "        # Generate triangle vertices\n",
    "        vertices = np.array([[0, 0], [0.5, np.sqrt(3) / 2], [1, 0]])\n",
    "        # Generate triangles\n",
    "        triangles = sierpinski_triangle(vertices, depth_or_iter)\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.set_aspect('equal')\n",
    "        ax.axis('off')\n",
    "        for triangle in triangles:\n",
    "            ax.fill(*zip(*triangle), \"b\")\n",
    "        filename = os.path.join(output_dir, 'sierpinski_triangle.png')\n",
    "        plt.savefig(filename)\n",
    "        plt.close()\n",
    "        return filename\n",
    "    elif fractal_type == \"Julia Set\":\n",
    "        c = complex(c_real, c_imag)\n",
    "        x_min, x_max, y_min, y_max = -1.5, 1.5, -1.5, 1.5\n",
    "        width, height = 800, 800\n",
    "        julia_image = julia_set(c, depth_or_iter, x_min, x_max, y_min, y_max, width, height)\n",
    "        plt.imshow(julia_image, cmap='hot', extent=(x_min, x_max, y_min, y_max))\n",
    "        plt.colorbar()\n",
    "        plt.axis('off')\n",
    "        filename = os.path.join(output_dir, 'julia_set.png')\n",
    "        plt.savefig(filename)\n",
    "        plt.close()\n",
    "        return filename\n",
    "    elif fractal_type == \"Mandelbrot Set\":\n",
    "        x_min, x_max = -2, 1\n",
    "        y_min, y_max = -1.5, 1.5\n",
    "        width, height = 800, 800\n",
    "        mandelbrot_image = np.zeros((height, width))\n",
    "        for x in range(width):\n",
    "            for y in range(height):\n",
    "                real = x_min + x * (x_max - x_min) / width\n",
    "                imag = y_min + y * (y_max - y_min) / height\n",
    "                color = mandelbrot(complex(real, imag), depth_or_iter)\n",
    "                mandelbrot_image[y, x] = color\n",
    "        plt.imshow(mandelbrot_image, cmap='hot', extent=(x_min, x_max, y_min, y_max))\n",
    "        plt.colorbar()\n",
    "        plt.axis('off')\n",
    "        filename = os.path.join(output_dir, 'mandelbrot_set.png')\n",
    "        plt.savefig(filename)\n",
    "        plt.close()\n",
    "        return filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running on local URL:  http://127.0.0.1:7861\n",
      "\n",
      "To create a public link, set `share=True` in `launch()`.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div><iframe src=\"http://127.0.0.1:7861/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Cell 5: Gradio Interface Setup\n",
    "iface = gr.Interface(\n",
    "    fn=plot_fractal,\n",
    "    inputs=[\n",
    "        gr.Dropdown(choices=[\"Julia Set\", \"Mandelbrot Set\", \"Sierpinski Triangle\"], label=\"Fractal Type\"),\n",
    "        gr.Slider(minimum=1, value=5, maximum=1000, label=\"Iterations: Past 10 on Sierpinski is too much for most PC\"),\n",
    "        gr.Number(label=\"Real part of c\", value=-0.8),\n",
    "        gr.Number(label=\"Imaginary part of c\", value=0.156)\n",
    "    ],\n",
    "    outputs=\"image\",\n",
    "    title=\"Fractal Generator\",\n",
    "    description=\"Select a fractal type and adjust the parameters to generate the fractal.\"\n",
    ")\n",
    "\n",
    "iface.launch()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jupy",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}