Numeric_Simulation_of_Material_Behavior.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "focal-signature",
   "metadata": {},
   "source": [
    "# Development of Numeric Simulation Predicting Material Behavior\n",
    "\n",
    "Kuanlin Chen, PhD student of the schulman lab<br>\n",
    "Advisor: Rebecca Schulman, PhD<br>\n",
    "Johns Hopkins University\n",
    "\n",
    "**Keywords: Numeric Simulation**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "registered-textbook",
   "metadata": {},
   "source": [
    "***\n",
    "#### Summary:\n",
    "\n",
    "Using data from the swelling characterization of bilayer DNA-co-polymerized hydrogel, we developed numeric simulation that accurately predicts the geometric outputs of the strip automata. \n",
    "\n",
    "We characterized the radius of curvature of bilayer gels upon different actuation combination along with the change in contour length. The values are stored in callable RoC tables and contour length tables that are used to retrieve values during geometric output simulation. \n",
    "\n",
    "We assumed the stack of bilayer gels do not interfere with each other upon actuation given the orthogonal operating actuators and also ignoring the minimal shear stress during swelling. \n",
    "\n",
    "We start with taking a 1d array `segment_lengths` and a 2d array `identities` as inputs, and generate an strip automata object. The `segment_lengths` array encodes the information of the **length** in each segment. The `identities` encodes the information of the **actuator pattern** in each segment. We then simulate the 16 possible states given our 4 switchable actuator system ($2^{4}=16$), thus every automata object contains 16 output images in the end. Upon simulation, we first retrieve the values for radius of curvature and delta contour length with the callable RoC tables and contour length tables, and obtain a 1d array `rocs` for the radius of curvature of each segments and a 1d array `ctls` for the delta contour length of each segments. We next use these values and integrate over the length and angle to derive the final shape. Starting at (x, y) = (0, 0) and $\\theta = 0$, we use `delta = 20um` as a mesh size and an iterator object to generate the next (x, y) point. Points are generated with the following rules:\n",
    "\n",
    "$\\Delta \\theta = \\frac{delta}{radius-of-curvature}$\n",
    "\n",
    "$\\theta = \\theta + \\Delta \\theta$\n",
    "\n",
    "$\\Delta x = delta \\cdot sin(\\theta)$\n",
    "\n",
    "$\\Delta y = delta \\cdot cos(\\theta)$\n",
    "\n",
    "$x = \\theta + \\Delta x$\n",
    "\n",
    "$y = \\theta + \\Delta y$\n",
    "\n",
    "The iterator generates new point until reaching segment length limit $(segment\\_length \\cdot (1 + \\Delta contour\\_length))$ and goes on generating new points for next segments until all segments are generated. We next compile a 28 x 28 pixel images using the shape of the x, y points and apply Gaussian filters to the final generated images representing the actuator geometric outputs, so the images emulate the shape of MNIST digits prior to training and classification.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "primary-stretch",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4.3\n",
      "2.2.0\n"
     ]
    }
   ],
   "source": [
    "# Package Importing\n",
    "import csv, math, os, time, copy, matplotlib, datetime, keras\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from keras.datasets import mnist\n",
    "from keras.models import Sequential, load_model\n",
    "from keras.layers import Dense, Dropout, Flatten\n",
    "from keras.layers.convolutional import Conv2D, MaxPooling2D\n",
    "from keras.utils import np_utils\n",
    "\n",
    "from scipy import io as spio\n",
    "from scipy.ndimage import gaussian_filter\n",
    "from scipy.stats import bernoulli\n",
    "\n",
    "from math import log10, floor\n",
    "\n",
    "from skimage import transform, exposure\n",
    "\n",
    "print(keras.__version__) # 2.4.3\n",
    "print(tf.__version__) # 2.2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moved-cyprus",
   "metadata": {},
   "source": [
    "## Material Behavior Characterization\n",
    "\n",
    "We characterize the radius of curvature and change in contour length of the bilayer gels upon different actuator combination and created the following table.\n",
    "\n",
    "**RoC Matrix**\n",
    "\n",
    "*Definition*\n",
    "\n",
    "- RoC bending downward is positive, bending upward (ex. shape U) negative. \n",
    "- **nc**: for no curvature = 1e5, **-**: for no value, but still put in 1e8 to avoid confusing the table.\n",
    "- Lacking most data for pos_pos matrix, for systems sharing similar swelling behavior (sys 1, 2, 4) when both swollen, assume RoC = nc; for system 3, that swells a lot, assume slight bending caused and value = 3500um.\n",
    "\n",
    "|top neg, bot neg|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|nc  |5e3|5e3|5e3|5e3|\n",
    "|1|-5e3|nc |nc |nc |nc |\n",
    "|2|-5e3|nc |nc |nc |nc |\n",
    "|3|-5e3|nc |nc |nc |nc |\n",
    "|4|-5e3|nc |nc |nc |nc |\n",
    "\n",
    "|top pos, bot pos|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|-|-|-|-|-|\n",
    "|1|-|nc|nc|3500|nc|\n",
    "|2|-|nc|nc|3500|nc|\n",
    "|3|-|-3500|-3500|nc|-3500|\n",
    "|4|-|nc|nc|3500|nc|\n",
    "\n",
    "|top pos, bot neg|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|-|730|740|770|630|\n",
    "|1|-|-  |820|570|500|\n",
    "|2|-|770|-  |667|667|\n",
    "|3|-|725|650|-  |670|\n",
    "|4|-|690|695|830|-  |\n",
    "\n",
    "|top neg, bot pos|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|-   |-   |-   |-   |-   |\n",
    "|1|-730|-   |-770|-725|-690|\n",
    "|2|-740|-820|-   |-650|-695|\n",
    "|3|-770|-570|-667|-   |-830|\n",
    "|4|-630|-500|-667|-670|-   |\n",
    "\n",
    "**Contour Matrix**\n",
    "\n",
    "- for pos_pos, use the value from monolayer for diagonals, and slightly uptune/downtune for paired systems.\n",
    "- for pos_neg, downtune .2 for connection with no-DNAs.\n",
    "\n",
    "|top neg, bot neg|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|1|1|1|1|1\n",
    "|1|1|1|1|1|1\n",
    "|2|1|1|1|1|1\n",
    "|3|1|1|1|1|1\n",
    "|4|1|1|1|1|1\n",
    "\n",
    "|top pos, bot pos|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|-|-|-|-|-|\n",
    "|1|-|1.45|1.4|1.55|1.42|\n",
    "|2|-|1.4|1.4|1.5|1.4|\n",
    "|3|-|1.55|1.5|1.75|1.55|\n",
    "|4|-|1.42|1.4|1.55|1.45|\n",
    "\n",
    "|top pos, bot neg|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|-|1.22|1.14|1.3|1.33|\n",
    "|1|-|   -|1.16|1.32|1.25|\n",
    "|2|-|1.24|-   |1.59|1.50|\n",
    "|3|-|1.18|1.20|-   |1.35|\n",
    "|4|-|1.19|1.23|1.32|-   |\n",
    "\n",
    "|top neg, bot pos|0|1|2|3|4|\n",
    "|---|---|---|---|---|---|\n",
    "|0|-          |   -|   -|   -|   -|\n",
    "|1|1.22| -  |1.24|1.18|1.19|\n",
    "|2|1.14|1.16|-   |1.20|1.23|\n",
    "|3|1.30|1.32|1.59|-   |1.32|\n",
    "|4|1.33|1.25|1.50|1.35|-   |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "relative-screw",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up the RoC matrix\n",
    "actuator_types = 4; nc = 1e5; na = 1e8\n",
    "neg_neg_rocs = [[nc, 5e3, 5e3, 5e3, 5e3],[-5e3, nc, nc, nc, nc],[-5e3, nc, nc, nc, nc],[-5e3, nc, nc, nc, nc],[-5e3, nc, nc, nc, nc]]\n",
    "pos_pos_rocs = [[na, na, na, na, na],[na, nc, nc, 3500, nc],[na, nc, nc, 3500, nc],[na, -3500, -3500, nc, -3500],[na, nc, nc, 3500, nc]]\n",
    "pos_neg_rocs = [[na, 730, 740, 770, 630],[na, na, 820, 570, 500],[na, 770, na, 667, 667],[na, 725, 650, nc, 670],[na, 690, 695, 830, na]]\n",
    "neg_pos_rocs = [[na, na, na, na, na],[-730, na, -770, -725, -690],[-740, -820, na, -650, -695],[-770, -570, -667, na, -830],[-630, -500, -667, -670, na]]\n",
    "four_t_rocs = [[neg_neg_rocs, neg_pos_rocs],[pos_neg_rocs, pos_pos_rocs]]\n",
    "\n",
    "# Set up the ContourLength matrix\n",
    "na = 1\n",
    "neg_neg_ctls = [[1, 1, 1, 1, 1],[1, 1, 1, 1, 1],[1, 1, 1, 1, 1],[1, 1, 1, 1, 1],[1, 1, 1, 1, 1]]\n",
    "pos_pos_ctls = [[na, na, na, na, na],[na, 1.45, 1.4, 1.55, 1.42],[na, 1.4, 1.4, 1.5, 1.4],[na, 1.55, 1.5, 1.75, 1.55],[na, 1.42, 1.4, 1.55, 1.45]]\n",
    "pos_neg_ctls = [[na, 1.22, 1.14, 1.3, 1.33],[na, na, 1.16, 1.32, 1.25],[na, 1.24, na, 1.59, 1.50],[na, 1.18, 1.20, nc, 1.35],[na, 1.19, 1.23, 1.32, na]]\n",
    "neg_pos_ctls = [[na, na, na, na, na],[1.22, na, 1.24, 1.18, 1.19],[1.14, 1.16, na, 1.20, 1.23],[1.3, 1.32, 1.59, na, 1.32],[1.33, 1.25, 1.50, 1.35, na]]\n",
    "four_t_ctls = [[neg_neg_ctls, neg_pos_ctls],[pos_neg_ctls, pos_pos_ctls]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "retired-angel",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegmentedCurve:\n",
    "    \"\"\"\n",
    "    Object that defines a curve. A curve is defined with following properties:\n",
    "\n",
    "        1. segment lengths *list*\n",
    "            - list of numbers specifying the length of each segments making up the curve.\n",
    "            - unit: um\n",
    "        2. rocs *list*\n",
    "            - list of numbers specifying the radius of curvature of each segment.\n",
    "            - set it to a high number such as 1e5 for flat line.\n",
    "        3. ctls *list*\n",
    "            - list of the contour length change for each segments.\n",
    "\n",
    "    Functions:\n",
    "\n",
    "        1. set_points\n",
    "            - generate the curve as a list of points.\n",
    "        2. rotate\n",
    "            - rotate the curve.\n",
    "        3. translate\n",
    "            - translate the curve.\n",
    "        4. generate_image\n",
    "            - generate the image of the curve from the points.\n",
    "        5. plot\n",
    "            - plot the curve.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, segment_lengths, rocs = [], ctls = []):\n",
    "        \"\"\"\n",
    "        By default this curve starts at (0, 0) and tangent angle 0. Deafault ROC is 999999.\n",
    "        \"\"\"\n",
    "        \n",
    "        self.segment_lengths = segment_lengths\n",
    "        if not rocs:\n",
    "            self.rocs = np.ones_like(segment_lengths) * 999999\n",
    "        else:\n",
    "            self.rocs = rocs\n",
    "        if not ctls:\n",
    "            self.segment_lengths = np.array(segment_lengths) \n",
    "        else:\n",
    "            self.segment_lengths = np.array(segment_lengths) * ctls\n",
    "         \n",
    "        self.initial_point = [0, 0]\n",
    "        self.initial_tangent_angle = 0\n",
    "        self.set_points()\n",
    "        \n",
    "    def set_points(self):\n",
    "        \"\"\"\n",
    "        Start generating the rest of the segment points from the origin and based one the segment length and ROC.\n",
    "        \"\"\"\n",
    "        s_iter = SegmentedCurveIterator(self)\n",
    "        self.x_points = []; self.y_points = []\n",
    "        self.tangent_angles = []\n",
    "        while True:\n",
    "            try:\n",
    "                element = next(s_iter)\n",
    "                self.x_points.append(element[0])\n",
    "                self.y_points.append(element[1])\n",
    "                self.tangent_angles.append(s_iter.tangent_angle)\n",
    "            except StopIteration:\n",
    "                break    \n",
    "    \n",
    "    def rotate(self, angle):\n",
    "        \"\"\"\n",
    "        Rotate the curve by adding an angle, and regrowing the rest of the curve.\n",
    "        \"\"\"\n",
    "        self.initial_tangent_angle += angle\n",
    "        self.set_points()\n",
    "        \n",
    "    def translate(self, coords):\n",
    "        \"\"\"\n",
    "        Translate the curve by shifting its origin, and regrowing the rest of the curve.\n",
    "        \"\"\"\n",
    "        self.initial_point += coords\n",
    "        self.set_points()\n",
    "        \n",
    "    def generate_image(self, width = 28, height = 28, padding = 0, filter = None, filter_sigma = 1):\n",
    "        \"\"\"\n",
    "        Generates the image of the curve.\n",
    "        **Parameters**\n",
    "            width *int*\n",
    "                the width of the image in pixel.\n",
    "            height *int*\n",
    "                the height of the image in pixel.\n",
    "                As the trained images are 28 x 28 pixels images, we return an image of the same size.\n",
    "            padding *int*\n",
    "                - provide additional space if needed.\n",
    "                - not sure working or not...\n",
    "            filter *string*\n",
    "                Can choose None or \"Gaussian\", used to blur the image so it resembles the digits more.\n",
    "            filter_sigma *int or float*\n",
    "                Sigma for the Gaussian filter.\n",
    "        \"\"\"\n",
    "        contour_length = np.sum(self.segment_lengths)\n",
    "        half_dimension = 1.5 * contour_length / (2 * math.sqrt(2))\n",
    "        #print(\"Old half dimension was  \"+ str(half_dimension))\n",
    "        x_span = np.amax(self.x_points) - np.amin(self.x_points)\n",
    "        y_span = np.amax(self.y_points) - np.amin(self.y_points)\n",
    "        half_dimension = max([x_span, y_span])\n",
    "        #print(\"Half dimension is \" + str(half_dimension))\n",
    "        x_center = np.median(self.x_points)\n",
    "        y_center = np.median(self.y_points)\n",
    "        new_x = np.array(self.x_points) - x_center\n",
    "        new_y = np.array(self.y_points) - y_center\n",
    "        new_x = new_x * (width / 2 + padding) // half_dimension\n",
    "        new_y = new_y * (height / 2 + padding) // half_dimension\n",
    "        image_pixels = np.zeros(shape = (height + 2 * padding, width + 2 * padding))\n",
    "        for i in range(len(new_x)):\n",
    "            image_pixels[math.floor(new_y[i]) + math.floor(height / 2) + padding][math.floor(new_x[i]) + math.floor(width / 2) + padding] += 1\n",
    "        p50, p98 = np.percentile(image_pixels, (50, 98))\n",
    "        if p98 == 0 and p50 == 0:\n",
    "            p50, p98 = np.percentile(image_pixels, (50, 99))\n",
    "        image_pixels = exposure.rescale_intensity(image_pixels, in_range = (p50, p98))\n",
    "        image_pixels = image_pixels / np.amax(image_pixels, axis=(0, 1))\n",
    "        image_pixels = transform.resize(image_pixels, (width + padding, height + padding))\n",
    "        if filter is \"Gaussian\":\n",
    "            image_pixels = gaussian_filter(image_pixels, sigma = filter_sigma)\n",
    "        p50, p98 = np.percentile(image_pixels, (50, 98))\n",
    "        if p98 == 0 and p50 == 0:\n",
    "            p50, p98 = np.percentile(image_pixels, (50, 99))\n",
    "        image_pixels = exposure.rescale_intensity(image_pixels, in_range = (p50, p98))\n",
    "        return image_pixels\n",
    "    \n",
    "    def generate_image_v2(self, width = 28, height = 28, padding = 0, filter = \"Gaussian\",\\\n",
    "                          filter_sigma = .8, half_dimension = 5000):\n",
    "        \"\"\"\n",
    "        Generates the image of the curve.\n",
    "        **Parameters**\n",
    "            width *int*\n",
    "                the width of the image in pixel.\n",
    "            height *int*\n",
    "                the height of the image in pixel.\n",
    "                As the trained images are 28 x 28 pixels images, we return an image of the same size.\n",
    "            padding *int*\n",
    "                - provide additional space if needed.\n",
    "                - not sure working or not...\n",
    "            filter *string*\n",
    "                Can choose None or \"Gaussian\", used to blur the image so it resembles the digits more.\n",
    "            filter_sigma *int or float*\n",
    "                Sigma for the Gaussian filter.\n",
    "        \"\"\"\n",
    "        \n",
    "        #print(\"Half dimension is \" + str(half_dimension))\n",
    "        x_center = np.median(self.x_points)\n",
    "        y_center = np.median(self.y_points)\n",
    "        new_x = np.array(self.x_points) - x_center\n",
    "        new_y = np.array(self.y_points) - y_center\n",
    "        new_x = new_x * (width / 2 + padding) // half_dimension\n",
    "        new_y = new_y * (height / 2 + padding) // half_dimension\n",
    "        image_pixels = np.zeros(shape = (height + 2 * padding, width + 2 * padding))\n",
    "        for i in range(len(new_x)):\n",
    "            image_pixels[math.floor(new_y[i]) + math.floor(height / 2) + padding][math.floor(new_x[i]) + math.floor(width / 2) + padding] += 1\n",
    "        p50, p98 = np.percentile(image_pixels, (50, 98))\n",
    "        if p98 == 0 and p50 == 0:\n",
    "            p50, p98 = np.percentile(image_pixels, (50, 99))\n",
    "        image_pixels = exposure.rescale_intensity(image_pixels, in_range = (p50, p98))\n",
    "        image_pixels = image_pixels / np.amax(image_pixels, axis=(0, 1))\n",
    "        image_pixels = transform.resize(image_pixels, (width + padding, height + padding))\n",
    "        if filter is \"Gaussian\":\n",
    "            image_pixels = gaussian_filter(image_pixels, sigma = filter_sigma)\n",
    "        p50, p98 = np.percentile(image_pixels, (50, 98))\n",
    "        if p98 == 0 and p50 == 0:\n",
    "            p50, p98 = np.percentile(image_pixels, (50, 99))\n",
    "        image_pixels = exposure.rescale_intensity(image_pixels, in_range = (p50, p98))\n",
    "        return image_pixels\n",
    "        \n",
    "    def plot(self):\n",
    "        \"\"\"\n",
    "        Plot and show the curve.\n",
    "        \"\"\"\n",
    "        fig, ax = plt.subplots(1, 1, figsize = (5, 5))\n",
    "        ax.plot(self.x_points, self.y_points, linewidth = 15)\n",
    "        plt.show()\n",
    "\n",
    "class SegmentedCurveIterator:\n",
    "    \"\"\"\n",
    "    This class is mainly used as the generator for the SegmentedCurve class.\n",
    "    \"\"\"\n",
    "    def __init__(self, segmented_curve):\n",
    "        self.rocs = segmented_curve.rocs\n",
    "        self.segment_starts = np.cumsum(segmented_curve.segment_lengths) - segmented_curve.segment_lengths\n",
    "        self.curve_end = np.sum(segmented_curve.segment_lengths)\n",
    "        self.segment_starts = np.append(self.segment_starts,[self.curve_end])\n",
    "        self.last_point = segmented_curve.initial_point\n",
    "        self.tangent_angle = segmented_curve.initial_tangent_angle\n",
    "        self.current_length = 0; self.current_segment = 0\n",
    "        # delta can be considered as the MESH SIZE for segments.\n",
    "        self.delta = 20\n",
    "        \n",
    "    def __next__(self):\n",
    "        self.current_length += self.delta\n",
    "        if self.current_length > self.curve_end:\n",
    "            raise StopIteration()\n",
    "        if self.current_length > self.segment_starts[self.current_segment + 1]:\n",
    "            self.current_segment += 1\n",
    "        angle_change = self.delta / self.rocs[self.current_segment]\n",
    "        self.tangent_angle += angle_change\n",
    "        pos_change = [self.delta*math.sin(self.tangent_angle), \\\n",
    "                      self.delta*math.cos(self.tangent_angle)]\n",
    "        self.last_point = np.add(self.last_point,pos_change)\n",
    "        return self.last_point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "usual-baking",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_curvature(rocs, states, top_type, bottom_type):\n",
    "    \"\"\"\n",
    "    Table reading function for retrieving the curvature and contour length change.\n",
    "    \"\"\"\n",
    "    return rocs[int(states[int(top_type)])][int(states[int(bottom_type)])][int(top_type)][int(bottom_type)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "every-monitoring",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActuatorStrip:\n",
    "    \"\"\"\n",
    "    Object that defines a bilayer hydrogel actuator. An actuator strip is defined with following properties:\n",
    "\n",
    "        1. lengths *list*\n",
    "            - list of numbers specifying the length of each segments making up the curve.\n",
    "            - unit: um\n",
    "        2. identities *list*\n",
    "            - the actuator system that each segment is patterned with.\n",
    "        3. rocs *list*\n",
    "            - radius of curvature table for bilayer \n",
    "            - set it to a high number such as 1e5 for flat line.\n",
    "        4. ctls *list(\n",
    "            - contour length table for bilayer\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, lengths, identities, rocs, ctls):\n",
    "        self.segment_lengths = lengths\n",
    "        self.identities = identities\n",
    "        self.rocs = rocs\n",
    "        self.ctls = ctls\n",
    "        self.actuator_types = len(rocs[0][0]) - 1\n",
    "        self.self_intersecting = []      \n",
    "        self.output_info = {}\n",
    "        self.selected = {}\n",
    "\n",
    "    def generate_curves(self):\n",
    "        \"\"\"\n",
    "        Generates the points for all possible strips formed.\n",
    "        \"\"\"\n",
    "        self.curves = []\n",
    "        for i in range(pow(2, self.actuator_types)):\n",
    "            # i is an integer -- the qth bit of i in binary encodes whether the qth actuator type is on. \n",
    "            curvatures = []; ctlengths = []; states = [0]\n",
    "            for k in range(self.actuator_types):\n",
    "                # << bitwise shift operators\n",
    "                if i & (1 << k):\n",
    "                    states.append(1)\n",
    "                else:\n",
    "                    states.append(0)\n",
    "#             print(states) # see how each image states is made\n",
    "            for j in range(len(self.segment_lengths)):\n",
    "                curvatures.append(get_curvature(self.rocs, states, self.identities[0][j], self.identities[1][j]))\n",
    "                ctlengths.append(get_curvature(self.ctls, states, self.identities[0][j], self.identities[1][j]))\n",
    "            s = SegmentedCurve(self.segment_lengths, curvatures, ctlengths)\n",
    "            self.curves.append(s)\n",
    "  \n",
    "    def determine_self_intersection(self):\n",
    "        \"\"\"\n",
    "        NEED A FASTER self intersecting check, currently not in use.\n",
    "        \"\"\"\n",
    "        state_count = pow(2, self.actuator_types)\n",
    "        for j in range(state_count):\n",
    "            #print(\"Looking at self intersection \" + str(j))\n",
    "            #self.self_intersecting.append(self.curves[j].is_self_intersecting())\n",
    "            self.self_intersecting.append(0)\n",
    "            #print(\"Self intersecting is now \" + str(self.self_intersecting))\n",
    "            \n",
    "    def plot_input_design(self, save = False, cm = plt.cm.get_cmap('tab20')):\n",
    "        fig , ax = plt.subplots(1, figsize = (5, 5))\n",
    "        fig_width = int(np.sum(self.segment_lengths) * 1.2); strip_width = int(fig_width/21); shift = int(fig_width*.6)\n",
    "        ax.imshow(np.ones(shape=(fig_width, fig_width)), cmap = \"tab20b\")\n",
    "        for i in range(len(self.segment_lengths)):\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2-strip_width,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = cm.colors[self.identities[0][i]]))\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = cm.colors[self.identities[1][i]]))\n",
    "\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width,  shift), strip_width*3, strip_width, color = cm.colors[0]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*1.5+shift), strip_width*3, strip_width, color = cm.colors[1]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*3+shift), strip_width*3, strip_width, color = cm.colors[2]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*4.5+shift), strip_width*3, strip_width, color = cm.colors[3]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*6+shift), strip_width*3, strip_width, color = cm.colors[4]))\n",
    "\n",
    "        ax.text(shift/2.8, strip_width*1+shift, \"Sys0\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*2.5+shift, \"Sys1\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*4+shift, \"Sys2\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*5.5+shift, \"Sys3\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*7+shift, \"Sys4\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "\n",
    "        for i in range(len(self.segment_lengths)):\n",
    "            ax.annotate(\"%dum\"%(self.segment_lengths[i]), xy=(fig_width/2+strip_width,strip_width*1.5+np.sum(self.segment_lengths[0:i])), xytext=(fig_width-strip_width*5, strip_width*1.5+np.sum(self.segment_lengths[0:i])),\\\n",
    "                        arrowprops = dict(arrowstyle=\"-|>\", color=\"white\"), fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "#         plt.title(\"Input Design\", fontsize = 15, family = \"serif\", weight = \"bold\")\n",
    "        plt.axis(False)\n",
    "        if save: plt.savefig(datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_input.png\", dpi = 600)\n",
    "        plt.show()\n",
    "        \n",
    "    def analysis(self, rotation = 20):\n",
    "        \n",
    "        self.generate_curves()\n",
    "        bestImgs = np.zeros(shape = (16, 28, 28)); bctr = 0; HAS9 = 0; HAS6 = 0\n",
    "        state_name = [\"ALL OFF\", \"S1 ON\", \"S2 ON\", \"S1 & S2\",\n",
    "                      \"S3 ON\", \"S1 & S3\", \"S2 & S3\", \"S1 & S2 & S3\",\n",
    "                      \"S4 ON\", \"S1 & S4\", \"S2 & S4\", \"S1 & S2 & S4\",\n",
    "                      \"S3 & S4\", \"S1 & S3 & S4\", \"S2 & S3 & S4\", \"ALL ON\"]\n",
    "        rotations = []\n",
    "        \n",
    "        for curve in self.curves:\n",
    "            possibility = np.zeros(shape = (rotation, 28, 28)); ctr = 0\n",
    "            \n",
    "            for _ in range(rotation):\n",
    "                curve.rotate(2*math.pi / rotation)\n",
    "                img = curve.generate_image(filter = 'Gaussian')\n",
    "                possibility[ctr]=img;ctr+=1\n",
    "            score = cnn_digit_model.predict(possibility.reshape(possibility.shape[0], 28, 28, 1))\n",
    "            info = [(i, np.argmax(score[i]), score[i][np.argmax(score[i])]) for i in range(len(score)) if np.argmax(score[i]) < 10]\n",
    "\n",
    "            if info:\n",
    "                best = np.argmax([info[i][2] for i in range(len(info))])\n",
    "                if info[best][1] == 9:\n",
    "                    if not HAS9:\n",
    "                        HAS9 = True\n",
    "                        bestImgs[bctr] = possibility[info[best][0]]\n",
    "                    elif not HAS6:\n",
    "                        try: \n",
    "                            best = [info[i][1] for i in range(len(info))].index(6)\n",
    "                            bestImgs[bctr] = possibility[info[best][0]]\n",
    "                        except:\n",
    "                            bestImgs[bctr] = possibility[info[best][0]]\n",
    "                    else:\n",
    "                        bestImgs[bctr] = possibility[info[best][0]]\n",
    "                elif info[best][1] == 6:\n",
    "                    if not HAS6:\n",
    "                        HAS6 = True\n",
    "                        bestImgs[bctr] = possibility[info[best][0]]\n",
    "                    elif not HAS9:\n",
    "                        try: \n",
    "                            best = [info[i][1] for i in range(len(info))].index(9)\n",
    "                            bestImgs[bctr] = possibility[info[best][0]]\n",
    "                        except:\n",
    "                            bestImgs[bctr] = possibility[info[best][0]]\n",
    "                    else:\n",
    "                        bestImgs[bctr] = possibility[info[best][0]]\n",
    "                else:\n",
    "                    bestImgs[bctr] = possibility[info[best][0]]\n",
    "            else:\n",
    "                bestImgs[bctr] = possibility[-2]\n",
    "            rotations.append((best+1)*2*math.pi / rotation)\n",
    "            bctr += 1\n",
    "        score = cnn_digit_model.predict(bestImgs.reshape(16, 28, 28, 1))\n",
    "        info = [(np.argmax(score[i]), score[i][np.argmax(score[i])]) for i in range(len(score))]\n",
    "        \n",
    "        \n",
    "        self.output_info = {i:{\"img\":bestImgs[i], \"dig\":info[i][0], \"score\":info[i][1], \"state\":state_name[i],\\\n",
    "                               \"rotations\":rotations[i]} for i in range(16)}\n",
    "\n",
    "        contest = [[] for i in range(11)];\n",
    "        [contest[self.output_info[i][\"dig\"]].append((self.output_info[i][\"score\"], i)) for i in self.output_info]\n",
    "        for i in range(11):\n",
    "            if contest[i] and i!=10:\n",
    "                self.selected[i] = {\"img\":self.output_info[sorted(contest[i])[-1][1]][\"img\"],\\\n",
    "                                    \"score\":sorted(contest[i])[-1][0],\\\n",
    "                                    \"num\":sorted(contest[i])[-1][1],\\\n",
    "                                    \"state\":self.output_info[sorted(contest[i])[-1][1]][\"state\"]}\n",
    "                \n",
    "    def generate_unscaled_imgs(self, filter_sigma = .8, half_dimension = 5000):\n",
    "        \n",
    "        self.generate_curves(); self.unscaled_imgs = np.zeros(shape = (16, 28, 28))\n",
    "\n",
    "        for i in range(16):\n",
    "            curve = self.curves[i]; curve.rotate(self.output_info[i][\"rotations\"])\n",
    "            img = curve.generate_image_v2(filter_sigma = filter_sigma, half_dimension = half_dimension)\n",
    "            self.unscaled_imgs[i] = img\n",
    "                \n",
    "    def plot_output_map(self, score = True, save = False):\n",
    "        \n",
    "        state_count = pow(2, self.actuator_types)\n",
    "        if state_count != 16:\n",
    "            raise WrongDesignType()\n",
    "            \n",
    "        title_name = [\"ALL OFF\", \"S1 ON\", \"S2 ON\", \"S1 & S2\",\n",
    "              \"S3 ON\", \"S1 & S3\", \"S2 & S3\", \"S1 & S2 & S3\",\n",
    "              \"S4 ON\", \"S1 & S4\", \"S2 & S4\", \"S1 & S2 & S4\",\n",
    "              \"S3 & S4\", \"S1 & S3 & S4\", \"S2 & S3 & S4\", \"ALL ON\"]\n",
    "        fig = plt.figure(figsize = (6,6)); ctr = 0\n",
    "        \n",
    "        self.generate_curves()\n",
    "        for i in range(state_count):\n",
    "            plt.subplot(4, 4, ctr+1)\n",
    "            curve = self.curves[i]; img = curve.generate_image(filter = 'Gaussian')\n",
    "            plt.imshow(img)\n",
    "            plt.title(title_name[i], fontsize = 10, family = \"serif\", weight = \"bold\", y = .95)\n",
    "            if score:\n",
    "                scores = cnn_digit_model.predict(img.reshape(1,28,28,1))[0]\n",
    "                plt.text(img.shape[1]*.05, img.shape[1]*.9, \"{}:  {:.3f}\".format(np.argmax(scores), np.max(scores)), fontsize = 12, family = \"serif\", weight = \"bold\", color = \"white\")\n",
    "            plt.axis(False); ctr += 1\n",
    "        fig.suptitle(\"Output Map\", fontsize = 12, family = \"serif\", weight = \"bold\", y = .95)\n",
    "        if save: plt.savefig(datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_output.png\", dpi = 600)\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_advanced_output_map(self, rotation = 20, save = False):\n",
    "        \"\"\"\n",
    "        - Enables rotation and mirroring to search larger space\n",
    "        - Enables simultaneous presense of 6 and 9\n",
    "        \"\"\"\n",
    "\n",
    "        if not self.output_info or rotation != 20:\n",
    "            self.analysis(rotation = rotation)\n",
    "        \n",
    "        fig = plt.figure(figsize = (6,6)); ctr = 0\n",
    "        \n",
    "        for i in range(pow(2, self.actuator_types)):\n",
    "            plt.subplot(4, 4, ctr+1)\n",
    "            img = self.output_info[ctr][\"img\"]\n",
    "            plt.imshow(img)\n",
    "            plt.title(self.output_info[ctr][\"state\"], fontsize = 10, family = \"serif\", weight = \"bold\", y = .95)\n",
    "            plt.text(img.shape[1]*.05, img.shape[1]*.9, \"{}:  {:.3f}\".format(self.output_info[ctr][\"dig\"], self.output_info[ctr][\"score\"]), fontsize = 12, family = \"serif\", weight = \"bold\", color = \"white\")\n",
    "            plt.axis(False); ctr += 1\n",
    "        fig.suptitle(\"Output Map\", fontsize = 12, family = \"serif\", weight = \"bold\", y = .95)\n",
    "        if save: plt.savefig(datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_advancedoutput.png\", dpi = 600)\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_selected_output_map(self, rotation = 20, save = False):\n",
    "\n",
    "        if not self.selected or rotation != 20:\n",
    "            self.analysis(rotation = rotation)\n",
    "        \n",
    "        fig = plt.figure(figsize = (10, 4))\n",
    "        \n",
    "        for i in range(10):\n",
    "            plt.subplot(2, 5, i+1)\n",
    "            if i in self.selected.keys():\n",
    "                img = self.selected[i]['img']\n",
    "                plt.imshow(img)\n",
    "                plt.text(img.shape[1]*.05, img.shape[1]*.9, \"Score: {:.3f}\".format(self.selected[i]['score']), fontsize = 12, family = \"serif\", weight = \"bold\", color = \"white\")\n",
    "                plt.title(\"{} ({})\".format(i, self.selected[i]['state']), fontsize = 10, family = \"serif\", weight = \"bold\", y = .98)\n",
    "            else:\n",
    "                plt.imshow(np.zeros(shape = (28, 28)))\n",
    "                plt.title(\"{} (n.a.)\".format(i), fontsize = 10, family = \"serif\", weight = \"bold\", y = .98)\n",
    "            plt.axis(False)\n",
    "        fig.suptitle(\"Optimized Output Map\", fontsize = 15, family = \"serif\", weight = \"bold\", y = .98)\n",
    "        if save: plt.savefig(datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_selectedoutput.png\", dpi = 600)\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_input_and_all(self, rotation = 20, save = False):\n",
    "        \n",
    "        if not self.selected or rotation != 20:\n",
    "            self.analysis(rotation = rotation)\n",
    "            \n",
    "        fig = plt.figure(figsize=(12,6))\n",
    "        \n",
    "        ax = plt.subplot(1,2,1)\n",
    "        fig_width = int(np.sum(self.segment_lengths) * 1.2); strip_width = int(fig_width/21); shift = int(fig_width*.6)\n",
    "        cm = plt.cm.get_cmap('tab20')\n",
    "        ax.imshow(np.ones(shape=(fig_width, fig_width)), cmap = \"tab20b\")\n",
    "        for i in range(len(self.segment_lengths)):\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2-strip_width,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = cm.colors[self.identities[0][i]]))\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = cm.colors[self.identities[1][i]]))\n",
    "\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width,  shift), strip_width*3, strip_width, color = cm.colors[0]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*1.5+shift), strip_width*3, strip_width, color = cm.colors[1]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*3+shift), strip_width*3, strip_width, color = cm.colors[2]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*4.5+shift), strip_width*3, strip_width, color = cm.colors[3]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*6+shift), strip_width*3, strip_width, color = cm.colors[4]))\n",
    "\n",
    "        ax.text(shift/2.8, strip_width*1+shift, \"Sys0\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*2.5+shift, \"Sys1\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*4+shift, \"Sys2\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*5.5+shift, \"Sys3\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*7+shift, \"Sys4\", fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "\n",
    "        for i in range(len(self.segment_lengths)):\n",
    "            ax.annotate(\"%dum\"%(self.segment_lengths[i]), xy=(fig_width/2+strip_width,strip_width*1.5+np.sum(self.segment_lengths[0:i])), xytext=(fig_width-strip_width*5, strip_width*1.5+np.sum(self.segment_lengths[0:i])),\\\n",
    "                        arrowprops = dict(arrowstyle=\"-|>\", color=\"white\"), fontsize = 12, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        plt.title(\"Input Design\", fontsize = 15, family = \"serif\", weight = \"bold\")\n",
    "        plt.axis(False)\n",
    "             \n",
    "        ctr = 0; shiftlist = [5,5,5,5,9,9,9,9,13,13,13,13,17,17,17,17]\n",
    "        for i in range(pow(2, self.actuator_types)):\n",
    "            plt.subplot(4, 8, ctr + shiftlist[ctr])\n",
    "            img = self.output_info[ctr][\"img\"]\n",
    "            plt.imshow(img)\n",
    "            plt.title(self.output_info[ctr][\"state\"], fontsize = 10, family = \"serif\", weight = \"bold\", y = .95)\n",
    "            plt.text(img.shape[1]*.05, img.shape[1]*.9, \"{}:  {:.3f}\".format(self.output_info[ctr][\"dig\"], self.output_info[ctr][\"score\"]), fontsize = 12, family = \"serif\", weight = \"bold\", color = \"white\")\n",
    "            plt.axis(False); ctr += 1\n",
    "            \n",
    "        fig.suptitle(\"Design Input and Output Map\", fontsize = 15, family = \"serif\", weight = \"bold\", y = .95)\n",
    "        if save: plt.savefig(datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_inandoutput.png\", dpi = 600)\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_input_and_all_adobe(self, rotation = 20, save = False):\n",
    "        \n",
    "        if not self.selected or rotation != 20:\n",
    "            self.analysis(rotation = rotation)\n",
    "            \n",
    "        fig = plt.figure(figsize=(12,6))\n",
    "        \n",
    "        ax = plt.subplot(1,2,1)\n",
    "        fig_width = int(np.sum(self.segment_lengths) * 1.2); strip_width = int(fig_width/21); shift = int(fig_width*.6)\n",
    "        cm = plt.cm.get_cmap('tab20')\n",
    "#         colors = [\"#808080\", \"#FFB3AB\", \"#FFC658\", \"#1D57A5\", \"#A86F5F\"]\n",
    "        colors = [\"#808080\", \"#0072BD\", \"#D95319\", \"#EDB120\", \"#7E2F8E\"]\n",
    "        ax.imshow(np.ones(shape=(fig_width, fig_width)), cmap = \"tab20b\")\n",
    "        for i in range(len(self.segment_lengths)):\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2-strip_width,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = colors[self.identities[0][i]]))\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = colors[self.identities[1][i]]))\n",
    "\n",
    "        plt.axis(False)\n",
    "             \n",
    "        ctr = 0; shiftlist = [5,5,5,5,9,9,9,9,13,13,13,13,17,17,17,17]\n",
    "        for i in range(pow(2, self.actuator_types)):\n",
    "            plt.subplot(4, 8, ctr + shiftlist[ctr])\n",
    "            img = self.output_info[ctr][\"img\"]\n",
    "            plt.imshow(img, cmap = \"binary\")\n",
    "#             plt.title(self.output_info[ctr][\"state\"], fontsize = 10, family = \"serif\", weight = \"bold\", y = .95)\n",
    "#             plt.text(img.shape[1]*.05, img.shape[1]*.9, \"{}:  {:.3f}\".format(self.output_info[ctr][\"dig\"], self.output_info[ctr][\"score\"]), fontsize = 12, family = \"serif\", weight = \"bold\", color = \"white\")\n",
    "            plt.axis(False); ctr += 1\n",
    "            \n",
    "#         fig.suptitle(\"Design Input and Output Map\", fontsize = 15, family = \"serif\", weight = \"bold\", y = .95)\n",
    "        if save: plt.savefig(datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_inandoutput.svg\", dpi = 80)\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_input_and_selected(self, rotation = 20, save = False):\n",
    "        \n",
    "        if not self.selected or rotation != 20:\n",
    "            self.analysis(rotation = rotation)\n",
    "            \n",
    "        fig = plt.figure(figsize=(16,4))\n",
    "        \n",
    "        ax = plt.subplot(1,4,1)\n",
    "        fig_width = int(np.sum(self.segment_lengths) * 1.2); strip_width = int(fig_width/21); shift = int(fig_width*.6)\n",
    "        cm = plt.cm.get_cmap('tab20')\n",
    "        ax.imshow(np.ones(shape=(fig_width, fig_width)), cmap = \"tab20b\")\n",
    "        for i in range(len(self.segment_lengths)):\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2-strip_width,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = cm.colors[self.identities[0][i]]))\n",
    "            ax.add_patch(matplotlib.patches.Rectangle((fig_width/2,strip_width+np.sum(self.segment_lengths[0:i])),strip_width,self.segment_lengths[i], color = cm.colors[self.identities[1][i]]))\n",
    "\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width,  shift), strip_width*3, strip_width, color = cm.colors[0]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*1.5+shift), strip_width*3, strip_width, color = cm.colors[1]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*3+shift), strip_width*3, strip_width, color = cm.colors[2]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*4.5+shift), strip_width*3, strip_width, color = cm.colors[3]))\n",
    "        ax.add_patch(matplotlib.patches.Rectangle((strip_width, strip_width*6+shift), strip_width*3, strip_width, color = cm.colors[4]))\n",
    "\n",
    "        ax.text(shift/2.8, strip_width*1+shift, \"Sys0\", fontsize = 11, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*2.5+shift, \"Sys1\", fontsize = 11, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*4+shift, \"Sys2\", fontsize = 11, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*5.5+shift, \"Sys3\", fontsize = 11, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        ax.text(shift/2.8, strip_width*7+shift, \"Sys4\", fontsize = 11, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "\n",
    "        for i in range(len(self.segment_lengths)):\n",
    "            ax.annotate(\"%dum\"%(self.segment_lengths[i]), xy=(fig_width/2+strip_width,strip_width*1.5+np.sum(self.segment_lengths[0:i])), xytext=(fig_width-strip_width*5, strip_width*1.5+np.sum(self.segment_lengths[0:i])),\\\n",
    "                        arrowprops = dict(arrowstyle=\"-|>\", color=\"white\"), fontsize = 11, color = \"white\", family = \"serif\", weight = \"bold\")\n",
    "        plt.title(\"Input Design\", fontsize = 15, family = \"serif\", weight = \"bold\")\n",
    "        plt.axis(False)\n",
    "        plt.subplots_adjust(wspace = 0.01, hspace = .2)\n",
    "        \n",
    "        shiftlist = list(range(3,8))+list(range(10,15))\n",
    "        for i in range(10):\n",
    "            plt.subplot(2, 7, shiftlist[i])\n",
    "            if i in self.selected.keys():\n",
    "                img = self.selected[i]['img']\n",
    "                plt.imshow(img)\n",
    "                plt.text(img.shape[1]*.05, img.shape[1]*.9, \"Score: {:.3f}\".format(self.selected[i]['score']), fontsize = 12, family = \"serif\", weight = \"bold\", color = \"white\")\n",
    "                plt.title(\"{} ({})\".format(i, self.selected[i]['state']), fontsize = 12, family = \"serif\", weight = \"bold\", y = .98)\n",
    "            else:\n",
    "                plt.imshow(np.zeros(shape = (28, 28)))\n",
    "                plt.title(\"{} (n.a.)\".format(i), fontsize = 12, family = \"serif\", weight = \"bold\", y = .98)\n",
    "            plt.axis(False)\n",
    "        fig.suptitle(\"Design Input and Optimized Output Map\", fontsize = 16, family = \"serif\", weight = \"bold\", y = 1.05)\n",
    "        plt.subplots_adjust(wspace = 0.01, hspace = .2)\n",
    "        if save: plt.savefig(datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_selectedoutput.png\", dpi = 600)\n",
    "        plt.show()\n",
    "        \n",
    "    def save_imgs(self, rotation = 20, path = os.getcwd()):\n",
    "        \n",
    "        if not self.output_info or rotation != 20:\n",
    "            self.analysis(rotation = rotation)\n",
    "            \n",
    "        for i in range(16):\n",
    "            try:\n",
    "                objt = self.output_info; foldername = \"d{}\".format(objt[i][\"dig\"]); filename = datetime.datetime.now().strftime(\"%Y%m%d_%H_%M_%S_%f\") + \"_output.png\";\n",
    "                plt.imsave(\"/\".join((path, foldername, filename)), objt[i][\"img\"], cmap = \"gray\")\n",
    "            except:\n",
    "                continue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "communist-sellers",
   "metadata": {},
   "source": [
    "#### Plotting a Sample Design"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "rising-equality",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "idts = [[2,3,4,0,3,2],[0,1,3,0,2,2]]\n",
    "sl = [1330, 1780, 1520, 1090, 1450, 1020]\n",
    "cnn_digit_model = load_model(\"Deep_Learning_Classifier_v3.h5\")\n",
    "teststrip = ActuatorStrip(sl, idts, four_t_rocs, four_t_ctls)\n",
    "# teststrip.generate_curves()\n",
    "teststrip.plot_input_design()\n",
    "teststrip.plot_output_map(score=False)\n",
    "# teststrip.plot_input_and_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "positive-reality",
   "metadata": {},
   "source": [
    "# Supplemetary Info\n",
    "\n",
    "## **SI Table 1. Radius of Curvature**\n",
    "\n",
    "|S1.2 RoC [um]|1 OFF Second round|1 ON/ OTHER OFF|\n",
    "|---|---|---|\n",
    "|S1.2|nc  |-  |\n",
    "|S2.2|1430|670+100=770|\n",
    "|S5  |1430|625+100=725|\n",
    "|S6.2|1430|590+100=690|\n",
    "|No DNA|assume 5e3|assume 630+100=730|\n",
    "\n",
    "|S2.2 RoC [um]|BOTH OFF|2 ON/ OTHER OFF|\n",
    "|---|---|---|\n",
    "|S1.2|1540|670+150=820|\n",
    "|S2.2|nc|-|\n",
    "|S5  |1250|500+150=650|\n",
    "|S6.2|1430|545+150=695|\n",
    "|No DNA|assume 5e3|assume 590+150=740|\n",
    "\n",
    "|S5 RoC [um]|BOTH OFF|3 ON/ OTHER OFF|\n",
    "|---|---|---|\n",
    "|S1.2|1200|570|\n",
    "|S2.2|1550|667|\n",
    "|S5  |nc|-|\n",
    "|S6.2|1250|830|\n",
    "|No DNA|assume 5e3|assume 770|\n",
    "\n",
    "|S6.2 RoC [um]|BOTH OFF|4 ON/ OTHER OFF|\n",
    "|---|---|---|\n",
    "|S1.2|1060|500|\n",
    "|S2.2|1250|667|\n",
    "|S5  |2000|670|\n",
    "|S6.2|nc|-|\n",
    "|No DNA|assume 5e3|assume 630|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "expired-daughter",
   "metadata": {},
   "source": [
    "## SI Table 2. **Delta Contour Lengths**\n",
    "\n",
    "||S1.2 Contour Length|\n",
    "|--- |---|\n",
    "|S1.2|from monolayer (second round), 0.45|\n",
    "|S2.2|0.24|\n",
    "|S5  |0.18|\n",
    "|S6.2|0.19|\n",
    "\n",
    "||S2.2 Contour Length|\n",
    "|--- |---|\n",
    "|S1.2|0.16|\n",
    "|S2.2|from monolayer (second round), (0.45)|\n",
    "|S5  |0.2|\n",
    "|S6.2|0.23|\n",
    "\n",
    "||S5 Contour Length|\n",
    "|--- |---|\n",
    "|S1.2|0.32|\n",
    "|S2.2|0.59|\n",
    "|S5  |from monolayer (second round), 0.7|\n",
    "|S6.2|0.32|\n",
    "\n",
    "||S6.2 Contour Length|\n",
    "|--- |---|\n",
    "|S1.2|0.25|\n",
    "|S2.2|0.5|\n",
    "|S5  |0.35|\n",
    "|S6.2|from monolayer (second round), 0.4|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dried-death",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}