ChaoticIFSFractal3D.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3D Plot Fractals\n",
    "- This is essentially an improved and optimized version of my chaotic IFS fractal generator except for 3D\n",
    "- Code by Michael Sherif Naguib 7/30/19 @Tulsa University\n",
    "### Get the imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Get the imports\n",
    "import tqdm\n",
    "import pptk\n",
    "import numpy as np\n",
    "import random\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predefine colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Colors for transforms\n",
    "color_a =[1,0,0]#Red\n",
    "color_b= [0,1,0]#Green\n",
    "color_c = [0,0,1]#Blue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make a system For generating IFS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculates the Iterated Function System for a certain IFS Function, Scale and point Quantity\n",
    "def IFS(func,quantity= 1000000,scale= 100000,start_point=None):\n",
    "    #Store the Point Data: start with the initial start point\n",
    "    pointData = [np.array([1,1,1]) if not str(type(start_point))==\"<class 'numpy.ndarray'>\" else start_point]#starting point\n",
    "    #Build the Point Data\n",
    "    for i in tqdm.tqdm(range(0,quantity)):\n",
    "        #get the next point \n",
    "        pointData.append(func(pointData[i]))\n",
    "    #Convert to a np Matrix and Scale\n",
    "    pointData = scale*np.array(pointData)\n",
    "    return pointData\n",
    "\n",
    "#Takes a matrix of point data and plots it\n",
    "def view(pointData):\n",
    "    v = pptk.viewer(pointData) \n",
    "    v.set(point_size=1)\n",
    "\n",
    "#Takes a list of transformation functions that each take a vector as an input and returns a curried function\n",
    "# that will select at random one of the transformation functions when called based upon the specified weighted\n",
    "#probabilities... if no weights are passed it is assumed to be uniform random\n",
    "def makeIFSFunc(ruleSet,probs=False):\n",
    "    if not bool(probs):#uniform random\n",
    "        return lambda inputVec: ruleSet[random.randint(0,len(ruleSet)-1)](inputVec)\n",
    "    else:#Else select from the weighted probabilities!\n",
    "        return lambda inputVec: ruleSet[(np.random.choice(len(probs), 1, p=probs))[0]](inputVec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define a LOT of constants for various fractals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#METHODOLOGY\n",
    "# use this area to predefine constants\n",
    "# build a list of functions that preform the desired vector operations on the input vector\n",
    "# (optional) build another list that holds the probabilities for that transformation\n",
    "# finally  in the dictionary convert the list and or probs to a single IFS function.... \n",
    "\n",
    "#For Convenience of Coding\n",
    "m = np.matmul\n",
    "I = np.identity(3)\n",
    "s=sin= math.sin\n",
    "c=cos= math.cos\n",
    "sqrt = math.sqrt\n",
    "pi = math.pi\n",
    "rr = random.random\n",
    "na = np.array\n",
    "def Rx(t):# Euler Angle Rotation Matricies\n",
    "    return np.array([[1,0,0],[0,c(t),0-s(t)],[0,s(t),c(t)]])\n",
    "def Ry(t):\n",
    "    return np.array([[c(t),0,s(t)],[0,1,0],[0-s(t),0,c(t)]])\n",
    "def Rz(t):\n",
    "    return np.array([[c(t),0-s(t),0],[s(t),c(t),0],[0,0,1]])\n",
    "    \n",
    "#Define a ruleset for Hedgehog fractal\n",
    "hedgeHog=[]#Credit for the values of the constants goes to Paul Bourke http://paulbourke.net/fractals/ifs/\n",
    "a = (1 + 1/3)/2\n",
    "b = (1 - 1/3)/2\n",
    "hedgeHog.append(lambda v: m((1/3)*I,v))#Oddly this resembles a binary bit string (which values of a are negative)\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([a,a,a]))\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([a,a,0-a]))\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([a,0-a,a]))\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([a,0-a,0-a]))\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([0-a,a,a]))\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([0-a,a,0-a]))\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([0-a,0-a,a]))\n",
    "hedgeHog.append(lambda v: m((b*I),v ) + np.array([0-a,0-a,0-a]))\n",
    "\n",
    "#Define a ruleset for Serinpenski fractal\n",
    "serinpenski = []\n",
    "serinpenski.append(lambda v: m((1/2)*I,v)+np.array([0,0,0.6]))\n",
    "serinpenski.append(lambda v: m((1/2)*I,v)+np.array([0,0.6,0]))\n",
    "serinpenski.append(lambda v: m((1/2)*I,v)+np.array([0.6,0,0]))\n",
    "serinpenski.append(lambda v: m((1/2)*I,v))\n",
    "\n",
    "#Define a ruleset for a Dragon fractal\n",
    "hyper_constant = 1.8\n",
    "d = sqrt(3)/3\n",
    "e = hyper_constant*sqrt(2)/4\n",
    "rot_a = m(Ry(pi/6),Rx(pi/6))\n",
    "rot_b = m(Ry(pi/3),Rx(pi/3))\n",
    "dragon=[]\n",
    "dragon.append(lambda v:m(rot_a,(e*v)))\n",
    "dragon.append(lambda v:m(rot_b,(e*v)) + np.array([1,0,d]))\n",
    "dragon.append(lambda v:m(rot_b,(e*v)) + np.array([d,0,1]))\n",
    "\n",
    "#Define a ruleset for a ORB Like fractal: Best result use 10^5 points or less\n",
    "orb= []\n",
    "orb.append(lambda v: m(Rx(pi/6),v) + np.array([-v[i]*20/abs(v[i]) for i in range(0,3)]))\n",
    "orb.append(lambda v: m(Ry(pi/180),v))\n",
    "\n",
    "#Define a ruleset for a Serinpenski Variant Like fractal: Best result use 10^5 points or less\n",
    "serinpenski2=[]\n",
    "serinpenski2.append(lambda v: m(0.5*I,v))\n",
    "serinpenski2.append(lambda v: m(0.5*I,v) + na([0,0,0.5]))\n",
    "serinpenski2.append(lambda v: m(0.5*I,v) + na([0.5,0,0.5]))\n",
    "serinpenski2.append(lambda v: m(0.5*I,v)+ na([0,0,0.5]))\n",
    "serinpenski2.append(lambda v: m(0.5*I,v)+ na([0.25,0.5,0.25]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a list of IFS Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create the chaotic version of the function given a list of transform functions (random uniform)\n",
    "allIFS = {\n",
    "    \"hedgehog\": makeIFSFunc(hedgeHog),\n",
    "    \"triangle\": makeIFSFunc(serinpenski),\n",
    "    \"dragon\":   makeIFSFunc(dragon),\n",
    "    \"orb\":      makeIFSFunc(orb),\n",
    "    \"triangle2\":makeIFSFunc(serinpenski2)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run a calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████| 1000000/1000000 [00:07<00:00, 142294.16it/s]\n"
     ]
    }
   ],
   "source": [
    "#Calculate the data based off the function ... (uses default scaling and quantity)\n",
    "data = IFS(allIFS[\"triangle\"],quantity=int(math.pow(10,6)),start_point=np.array([1,1,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### View the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "view(data)\n",
    "# Axis Colors & Index: \n",
    "#Green: x    0\n",
    "#Blue:  y    1\n",
    "#Red:   z    2 "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}