Example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SurfaceNets in python Demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we load some dependencies. Most probably not all are needed, but we get them anyhow ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.6/importlib/_bootstrap.py:219: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "from collections import defaultdict\n",
    "from importlib import reload\n",
    "import ipyvolume as ipv\n",
    "from stl import mesh\n",
    "from pythreejs import *\n",
    "\n",
    "\n",
    "import SurfaceNet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we import this python project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "SurfaceNet = reload(SurfaceNet)\n",
    "\n",
    "sn = SurfaceNet.SurfaceNets()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Volume 2 STL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create volume consisting of some ball, boxes, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim = [0] * 3\n",
    "\n",
    "dim[0]=100;\n",
    "dim[1]=100;\n",
    "dim[2]=100;\n",
    "\n",
    "vol = np.zeros(dim)\n",
    "\n",
    "for i in range(0, dim[0]):\n",
    "    for j in range(0, dim[1]):\n",
    "        for k in range(0, dim[2]):\n",
    "            \n",
    "            # ball\n",
    "            if(pow(i-dim[0]/2,2)+pow(j-dim[1]/2,2)+pow(k-dim[2]/2,2)<15*15):\n",
    "                vol[i,j,k]=100\n",
    "            \n",
    "            \n",
    "            # boxes\n",
    "            if 10 < i < 30 and 10 < j < 30 and 10 < k < 30:\n",
    "                vol[i,j,k] = 100\n",
    "                \n",
    "                \n",
    "            if 70 < i < 90 and 70 < j < 90 and 10 < k < 50:\n",
    "                vol[i,j,k] = 100\n",
    "                \n",
    "            if 60 < i < 90 and 60 < j < 90 and 10 < k < 30:\n",
    "                vol[i,j,k] = 100\n",
    "                \n",
    "            if 50 < i < 80 and 50 < j < 80 and 50 < k < 80:\n",
    "                vol[i,j,k] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at this geometry (static image version for GitHub):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/ipyvolume/serialize.py:81: RuntimeWarning: invalid value encountered in true_divide\n",
      "  gradient = gradient / np.sqrt(gradient[0]**2 + gradient[1]**2 + gradient[2]**2)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5601efbab64842a5a537cc09d5576f57",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(VBox(children=(HBox(children=(Label(value='levels:'), FloatSlider(value=0.25, max=1.0, step=0.0…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ipv.quickvolshow(vol, level=[0.25, 0.75], opacity=0.03, level_width=0.1, data_min=0, data_max=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Scene Volume](img/scene_volume.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now apply the surface net algorithm to this volume with a solid-threshold of 50 ( all values > 50 are assumed to be solid)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 100, 100)\n",
      "[99, 99, 0]\n",
      "[99, 99, 10]\n",
      "[99, 99, 20]\n",
      "[99, 99, 30]\n",
      "[99, 99, 40]\n",
      "[99, 99, 50]\n",
      "[99, 99, 60]\n",
      "[99, 99, 70]\n",
      "[99, 99, 80]\n",
      "[99, 99, 90]\n",
      "visIdx 970299 1000000\n",
      "15846 31680\n"
     ]
    }
   ],
   "source": [
    "vertices,faces = sn.surface_net(vol, 50)\n",
    "\n",
    "print(len(vertices), len(faces))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we got vertices and faces, we want to write these into an STL file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 10.5 89.5\n",
      "1 10.5 89.5\n",
      "2 10.5 89.5\n"
     ]
    }
   ],
   "source": [
    "cube = mesh.Mesh(np.zeros(len(faces), dtype=mesh.Mesh.dtype))\n",
    "for i, f in enumerate(faces):\n",
    "    \n",
    "    for j in range(3):\n",
    "        \n",
    "        cube.vectors[i][j] = vertices[f[j]]\n",
    "\n",
    "posElem = defaultdict(list)\n",
    "\n",
    "for i in range(3):\n",
    "    for vert in cube.vectors:\n",
    "        posElem[i].append(vert[i])\n",
    "\n",
    "#this prints the min/max value per dimension\n",
    "for posidx in posElem:\n",
    "    print(posidx, np.min(posElem[posidx]), np.max(posElem[posidx]))\n",
    "    \n",
    "cube.save('cube.stl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's have a look at our 3D model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "39cb4dbf59ce426ba2333c7d80454255",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Preview(child=BufferGeometry(attributes={'position': <BufferAttribute shape=(31680, 3, 3), dtype=float32>}), s…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load the STL files and add the vectors to the plot\n",
    "your_mesh = mesh.Mesh.from_file('cube.stl')\n",
    "\n",
    "vertices = BufferAttribute(array=your_mesh.vectors, normalized=True)\n",
    "\n",
    "geometry = BufferGeometry( attributes={'position': vertices}, )\n",
    "geometry "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Scene Volume](img/scene_stl.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}