avxDesign.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 style=\"display:inline-block\">ActiveVoxel Design</h1><br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ezRSPKUC7CER"
   },
   "source": [
    "The purpose is to develop a framework to generate 3D solids to 3D printing or other manufacture process.<br/>\n",
    "<br/>\n",
    "The idea behind the ActiveVoxel name is to start with a voxel (a cube) and apply operations on it to transform it in any possible shape needed.<br/>\n",
    "<br/>\n",
    "As a proof-of-concept the ideia is to start with the voxel seed, subdivide its faces and operate the vertices to position them all at the same distance to the center of mass of the voxel, following the same vector center->vx, to generate a representation of a solid sphere.<br/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# http://mybinder.org/v2/gh/casson-projects-2020/active-bolt/master?filepath=avxDesign.ipynb\n",
    "\n",
    "# vertex data representation\n",
    "\n",
    "# cube_vxs = [[ rx ry rz invp id demi? selidx ] ...]\n",
    "\n",
    "# invp is the level of division of the unitary space\n",
    "#  (the inverse of the line parameter in parametric form l = point.p + c)\n",
    "# r in rx, ry, rz is a multiplier 0 <= r <= invp\n",
    "\n",
    "# we use this form to keep integer coordinates, to prevent problems with precision\n",
    "# and prevent ranges of tolerance to use the equality operator \n",
    "\n",
    "# a demi vx is one that is not considered a real one (a real vxs must be shared by a minimun\n",
    "# of 3 tris, 3 edges but can be shared to more tris/edges - up to 6 I believe [? more?])\n",
    "\n",
    "# selidx is used by the selection algorithm: an index is set to all selected geometry\n",
    "# and the matrix is sorted to make all the selected items appear as the first lines\n",
    "# of the matrix, so we can extract this part of the matrix to forward it to the Tensor\n",
    "# pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 1 0 1 0 1]\n",
      " [0 0 0 0 1 1 1 1]\n",
      " [0 0 1 1 1 1 0 0]\n",
      " [1 1 1 1 1 1 1 1]\n",
      " [0 1 2 3 4 5 6 7]\n",
      " [0 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "vxs_py = [[ 1, 0, 0, 1, 0, 0, 0 ], [ 0, 0, 0, 1, 1, 0, 0 ], [ 0, 0, 1, 1, 2, 0, 0 ], [ 1, 0, 1, 1, 3, 0, 0 ], \n",
    "          [ 0, 1, 1, 1, 4, 0, 0 ], [ 1, 1, 1, 1, 5, 0, 0 ], [ 0, 1, 0, 1, 6, 0, 0 ], [ 1, 1, 0, 1, 7, 0, 0 ]]\n",
    "\n",
    "vxs = np.array( vxs_py )\n",
    "\n",
    "print( vxs.transpose())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4: (1, 1, 0, 0, 1), 0: (1, 0, 0, 0, 1), 1: (1, 0, 0, 1, 1), 5: (1, 1, 0, 1, 1), 3: (1, 0, 1, 1, 1), 7: (1, 1, 1, 1, 1), 2: (1, 0, 1, 0, 1), 6: (1, 1, 1, 0, 1)}\n"
     ]
    }
   ],
   "source": [
    "# TODO: useful?\n",
    "\n",
    "# deriving vxs unique ids from their positions\n",
    "# pmax is the max( invp ) \n",
    "pmax = 1\n",
    "\n",
    "vx_names = {( pmax + 1 ) * ( pmax + 1 ) * vx[ 0 ] + ( pmax + 1 ) * vx[ 1 ] + vx[ 2 ]: \n",
    "            ( vx[ 3 ], vx[ 0 ], vx[ 1 ], vx[ 2 ], pmax ) for vx in vxs_py }\n",
    "\n",
    "print( vx_names )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "11\n",
      "[[ 0  1  2  3  2  4  5  4  6  7  6  0]\n",
      " [ 1  2  3  0  4  5  3  6  7  5  1  7]\n",
      " [ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]\n",
      " [ 0  0  1  1  2  3  3  4  5  5  6  7]\n",
      " [ 1  1  1  1  1  1  1  1  1  1  1  1]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]\n",
      " [ 7 11  2  8 11  4  9 10  6  9 10  8]\n",
      " [ 1  1  1  1  1  1  1  1  1  1  1  1]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]]\n"
     ]
    }
   ],
   "source": [
    "# edges divided in metadata and data to allow us to perform calculations with the smallest tensor possible\n",
    "\n",
    "# vx1 vx2 id parent demi? selidx\n",
    "# tri1_id divs1 chdiv1 tri2_id div2 chdiv2\n",
    "\n",
    "# TODO: nao entendi muito bem pq eu criei esse chdiv\n",
    "\n",
    "# tri[n]_id id of the tri[n]. An edge can be shared between a max of 2 tris\n",
    "# divs[n] = how many times this edge is divided in relation to tri n\n",
    "# chdiv[n] = children related to tri n were created dividing this edge chdiv[n] times\n",
    "\n",
    "# we keep subdivided edges in an hierarchy. Edges can only be subdivided if we subdivide the faces they define.\n",
    "# Two connected faces always share an edge. If we subdiv one of this faces, but not the other, the child edges \n",
    "# will be considered demi-edges (they exist in only one face).\n",
    "\n",
    "# The same happens if we subdiv a face in n slices and the other face in m slices, if m is not a multiple of n.\n",
    "# both sets of child edges will be kept and will be demi-edges, each set belonging to just one face.\n",
    "\n",
    "# If we divide a face in n slices and the other face in n or kn (a multiple of n), the edges will be promoted\n",
    "# to real edges. Their parent structures can be deleted or demoted to demi-geometries and kept for selection\n",
    "# purposes (they can never be promoted to real geometry again). The default behavior is to delete.\n",
    "\n",
    "edgm_seed = [[ 0, 1, 0,  7 ], [ 1, 2, 0, 11 ], [ 2, 3, 1,  2 ], [ 3, 0, 1,  8 ], \n",
    "             [ 2, 4, 2, 11 ], [ 4, 5, 3,  4 ], [ 5, 3, 3,  9 ], [ 4, 6, 4, 10 ], \n",
    "             [ 6, 7, 5,  6 ], [ 7, 5, 5,  9 ], [ 6, 1, 6, 10 ], [ 0, 7, 7,  8 ]]\n",
    "\n",
    "edges_meta_py = [ [ edgm_seed[ idx ][ 0 ], # vx 1\n",
    "                    edgm_seed[ idx ][ 1 ], # vx 2\n",
    "                    idx, 0, 0, 0, \n",
    "                    edgm_seed[ idx ][ 2 ], # tri 1\n",
    "                    1, 0, \n",
    "                    edgm_seed[ idx ][ 3 ], # tri 2\n",
    "                    1, 0 ] for idx in range( len( edgm_seed )) ]\n",
    "    \n",
    "edges_meta = np.array( edges_meta_py )\n",
    "\n",
    "max_edge = np.max( edges_meta, 0 )[ 2 ]\n",
    "\n",
    "print( max_edge )\n",
    "\n",
    "print( edges_meta.transpose())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1, 0, 0, 0], [0, 0, 1, 1], [1, 0, 0, 2], [0, 0, -1, 3], [0, 1, 0, 4], [1, 0, 0, 5], [0, -1, 0, 6], [0, 0, -1, 7], [1, 0, 0, 8], [0, 0, 1, 9], [0, -1, 0, 10], [0, 1, 0, 11]]\n",
      "\n",
      "[[-1  0  1  0  0  1  0  0  1  0  0  0]\n",
      " [ 0  0  0  0  1  0 -1  0  0  0 -1  1]\n",
      " [ 0  1  0 -1  0  0  0 -1  0  1  0  0]\n",
      " [ 0  1  2  3  4  5  6  7  8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "# dx dy dz id\n",
    "# ( dx, dy, dz ) = direction vector = vx2 - vx1\n",
    "\n",
    "# TODO: garantir qdo fizer a conta do dx, dy e dz q elas estejam no mesmo nivel de divisao\n",
    "\n",
    "# we keep v2 - v1 in the edges to allow us to make calculations to the edges directly without \n",
    "# use the vertices (this implies that if we change the vertices edges must be updated).\n",
    "\n",
    "# in this data structure we keep the divisions of children edges, demi or real\n",
    "\n",
    "# there is no selidx in this matrix but the matrix is always sorted in the same way as the metadata \n",
    "\n",
    "edt_py = [[ vxs_py[ item[ 1 ]][ 0 ], \n",
    "            vxs_py[ item[ 1 ]][ 1 ], \n",
    "            vxs_py[ item[ 1 ]][ 2 ], item[ 2 ]] for item in edges_meta_py ]\n",
    "\n",
    "edges_data = np.array( edt_py )\n",
    "\n",
    "# since this matrix will be subtracted from the the above to calculate dx, dy, dx,\n",
    "# set all fields (just the id in this case) to zero to avoid subtract constant fields\n",
    "edt_py2 = [[ vxs_py[ item[ 0 ]][ 0 ], \n",
    "             vxs_py[ item[ 0 ]][ 1 ], \n",
    "             vxs_py[ item[ 0 ]][ 2 ], 0 ] for item in edges_meta_py ]\n",
    "\n",
    "ed2 = np.array( edt_py2 )\n",
    "\n",
    "# subtracting vx2 - vx1 to generate dx, dy, dz\n",
    "edges_data -= ed2\n",
    "edt_py = edges_data.tolist()\n",
    "\n",
    "print( edt_py )\n",
    "print()\n",
    "print( edges_data.transpose())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  2  2  5  5  8  8  0 11  6 10  4]\n",
      " [ 1  3  4  6  7  9 10 11  3  9  7  1]\n",
      " [ 0  0  1  0  1  0  1  1  1  1  1  1]\n",
      " [ 0  0  0  0  0  0  0  0  1  1  1  1]\n",
      " [ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]\n",
      " [ 0  0  0  0  0  0  0  0  0  0  0  0]]\n"
     ]
    }
   ],
   "source": [
    "# edge1 edge2 rev1 rev2 id demi? parent selidx\n",
    "# id < 0 = reversed edge\n",
    "\n",
    "# two edges will be used to define tris. Just like edges tris, after subdivs,\n",
    "# will be deleted and replaced by their children by default, but they can be kept as demi-tris for\n",
    "# selection purposes\n",
    "\n",
    "# rev[n] indicates if edge[n] should be considered reversed (2o vx -> 1o vx instead of 1o -> 2o)\n",
    "\n",
    "tris_py = [[ 0,  1, 0, 0, 0, 0, 0, 0 ], [  2,  3, 0, 0,  1, 0, 0, 0 ], [  2, 4, 1, 0,  2, 0, 0, 0 ], \n",
    "           [ 5,  6, 0, 0, 3, 0, 0, 0 ], [  5,  7, 1, 0,  4, 0, 0, 0 ], [  8, 9, 0, 0,  5, 0, 0, 0 ], \n",
    "           [ 8, 10, 1, 0, 6, 0, 0, 0 ], [  0, 11, 1, 0,  7, 0, 0, 0 ], [ 11, 3, 1, 1,  8, 0, 0, 0 ], \n",
    "           [ 6,  9, 1, 1, 9, 0, 0, 0 ], [ 10,  7, 1, 1, 10, 0, 0, 0 ], [  4, 1, 1, 1, 11, 0, 0, 0 ]]\n",
    "\n",
    "tris = np.array( tris_py )\n",
    "max_tri = np.max( tris, 0 )[ 2 ]\n",
    "\n",
    "print( tris.transpose())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subdiv edges algorithm\n",
    "\n",
    "# if the edge is real and do not have any children\n",
    "# TODO:\n",
    "def subdiv_edges( divs ):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# selection works assigning an index to elements and the sort the element matrix\n",
    "# to make every line with this index appear as first lines on the matrix. This way\n",
    "# we can extract this first lines to pass them to the tensor pipeline\n",
    "\n",
    "_selidx = 1;\n",
    "selection = { \"type\": \"none\", \"idx\": 0 }\n",
    "\n",
    "\n",
    "def geom_type( geom_name ):\n",
    "    if ( \"|\" + geom_name.lower() + \"|\" ) in \"|vertex|vertice|vertices|vertexes|vx|vc|vxs|\":\n",
    "        return 1\n",
    "\n",
    "    if ( \"|\" + geom_name.lower() + \"|\" ) in \"|tri|tris|triangle|triangles|faces|face|\":\n",
    "        return 3\n",
    "\n",
    "    # error\n",
    "    return 0\n",
    "    \n",
    "\n",
    "# TODO: a dialect to select must be created. I'm thinking about a matrix operation\n",
    "# to be performed in one of the geometry matrices, but it will be enough? and which operation?\n",
    "def select( _geom_type, rule ):\n",
    "    global _selidx, selection, tris\n",
    "    \n",
    "    # selecting vertices\n",
    "    # TODO:\n",
    "    if geom_type( _geom_type ) == 1:\n",
    "        # nothing is selected\n",
    "        selection[ \"type\" ] = \"none\"\n",
    "        selection[ \"idx\" ] = -1\n",
    "        selection[ \"msg\" ] = \"vertices: nothing is selected (no match)\"\n",
    "        selection[ \"rows\" ] = 0\n",
    "        return False\n",
    "\n",
    "    # TODO: select edges\n",
    "    \n",
    "    # selecting tris\n",
    "    # TODO: how to select tris? returning all for now\n",
    "    # for instance, if we like to select all tris with normals facing us, (pointing to -y)\n",
    "    # we will have to calculate or maintain a normal matrix\n",
    "    if geom_type( _geom_type ) == 3:\n",
    "        # change the selidx in the tri matrix to the current one\n",
    "        # TODO: rows matrix have to be generated somehow, to contain only pertinent rows\n",
    "        # (each row is a tri)\n",
    "        ntris = len( tris )\n",
    "        rows = np.arange( ntris )\n",
    "        \n",
    "        # 7 = selidx\n",
    "        tris[ rows, [ 7 ]] = _selidx\n",
    "        \n",
    "        # sort the tri matrix, with one exception: if we select the whole matrix\n",
    "        # (note that the row selecting matrix can never contain the same row twice)\n",
    "        selection[ \"rows\" ] = len( rows )\n",
    "        \n",
    "        if selection[ \"rows\" ] < ntris:\n",
    "            tris.view( 'i32,i32,i8,i8,i32,i8,i32,i32').sort( order=[ 'f7'], axis=0 )\n",
    "            \n",
    "        selection[ \"type\" ] = _geom_type\n",
    "        selection[ \"idx\" ] = _selidx\n",
    "        selection[ \"msg\" ] = \"tris: \" + str( len( rows )) + \" tri(s) selected\"\n",
    "        \n",
    "        _selidx += 1\n",
    "\n",
    "        return True\n",
    "\n",
    "    # error, nothing is selected\n",
    "    selection[ \"type\" ] = \"error\"\n",
    "    selection[ \"idx\" ] = -1\n",
    "    selection[ \"msg\" ] = \"There is no geometry type \" + str( _geom_type )\n",
    "    return False\n",
    "    \n",
    "# subdiv tris algorithm\n",
    "\n",
    "# (vxs algorithms are all abstracted in the promote and demote algorithms here)\n",
    "\n",
    "# subdiv in n parts (n = 2 will result in n^2 = 4 tris )\n",
    "\n",
    "# based on the tris selected (remove all demi-tris) we locate all edges \n",
    "# from all edges we select two groups: \n",
    "\t# 1 - the ones that do not have n demi-edges as children\n",
    "\t# 2 - the ones that do have n demi-edges as children\n",
    "\n",
    "# all in group 1 (no-demis) should be divided in n demi-edges, using # subdiv edges algorithm\n",
    "# all children demi-edges in 2 (have-demis) should be promoted to real edges, using #promote to real edges\n",
    "\n",
    "# select again all edges children of the original one, in two groups, one for each original edge\n",
    "\t# of each tri (so all the children of the first original edge of all tris in a group, and \n",
    "\t# all children of the second original edge off all tris in the other )\n",
    "\n",
    "\t# the first group will be called \"original row\" and the second \"original column\"\n",
    "\n",
    "# generate n - 1 rows of real edges corresponding to the tri subdiv, based on the original row, and add original row to it\n",
    "# generate n - 1 cols of real edges corresponding to the tri subdiv, based on the original col, and add original col to it\n",
    "\n",
    "# generate a cross of all rows x all cols based on shared vxs and angle of 90o degrees following\n",
    "\t# the space base (clockwise)\n",
    "# add a cross of r x c based on shared vxs when edges point to the shared vx (invert cols)\n",
    "# add a cross of r x c based on shared vxs when edges point away from it (invert rows)\n",
    "# add a cross of r x c based on shared vxs based on angle of 90o degrees against the space base\n",
    "\t# (counter clockwise, invert rows and cols )\n",
    "\n",
    "# generate tris \n",
    "\n",
    "# if the behaviour is preserve parent, demote old tris to demi-tris and link new tris,\n",
    "\t# using # demote tris\n",
    "# or else delete old tris\n",
    "\n",
    "# select all original edges that have real children and no demi-children\n",
    "# demote all them to demi-edges, using # demote edges\n",
    "\n",
    "\n",
    "# TODO: criar links para manter infos de parent em tris\n",
    "# TODO: criar estrutura vx -> edge pra poder fazer o cross edges row x edges col\n",
    "\n",
    "status = { \"edges\": \"in id order\" }\n",
    "\n",
    "def subdivide( divs ):\n",
    "    global selection\n",
    "    \n",
    "    if geom_type( selection[ \"type\" ]) == geom_type( \"tris\" ):\n",
    "        return subdivide_tris( divs )\n",
    "\n",
    "    return False\n",
    "\n",
    "    \n",
    "def subdivide_tris( divs ):\n",
    "    global tris, status, _selidx\n",
    "    \n",
    "    # based on the tris selected (remove all demi-tris) we locate all edges \n",
    "    # TODO: I will assume that the selection algorithm uses demi-tris to\n",
    "    # select their children and correctly never sends demi-tris to the operations\n",
    "    \n",
    "    # recover the first n lines of the tri matrix (that correspond to the current selection)\n",
    "    ntris = selection[ \"rows\" ] \n",
    "    rows = np.arange( ntris )\n",
    "    stris = tris[ rows ]\n",
    "    \n",
    "    # to locate edges, do a internal selection (invisible to the user)\n",
    "    # and select (sort the matrix) the corresponding edges \n",
    "    # 1st generate row-selecting matrix\n",
    "        # edges must be in id order\n",
    "    if status[ \"edges\" ] != \"in id order\":\n",
    "        \n",
    "        # vx1 vx2 id parent demi? selidx\n",
    "        # tri1_id divs1 chdiv1 tri2_id div2 chdiv2\n",
    "\n",
    "        edges_meta.view( 'i32,i32,i32,i32,i8,i32,i32,i32,i32,i32,i32,i32' ).sort( order=[ 'f2' ], axis=0 )\n",
    "        edges_data.view( 'i32,i32,i32,i32' ).sort( order=[ 'f3' ], axis=0 )\n",
    "    \n",
    "        # dx dy dz id\n",
    "\n",
    "    # TODO: ? we will probably change this order in the algorithm\n",
    "    #status[ \"edges\" ] = \"no order\"\n",
    "\n",
    "    insel = _selidx\n",
    "    _selidx += 1\n",
    "    \n",
    "    edges_meta[ stris[:, [ 0 ]], 5 ] = insel\n",
    "    edges_meta[ stris[:, [ 1 ]], 5 ] = insel\n",
    "    \n",
    "    # generate boolean matrix to repeat the selection in the edge_data\n",
    "    sedges = ( edges_meta[:, 5 ] == insel )\n",
    "    \n",
    "    \n",
    "    # from all edges we select two groups: \n",
    "        # 1 - the ones that do not have n demi-edges as children\n",
    "        # 2 - the ones that do have n demi-edges as children\n",
    "\n",
    "    # TODO: rev precisa ser adicionada a matriz de edges? A ordem dos vxs é\n",
    "    # importante? o algoritmo precisa considerar os vcs na direcao natural\n",
    "    # da edge?\n",
    "    \n",
    "#    nnewf = divs * divs\n",
    "#    nnewt = nnewf * 2\n",
    "    \n",
    "#    newf_py = [ id for id in range( max_tri + 1, max_tri + nnewt + 1 )]\n",
    "#    newf = np.array( newf_py )\n",
    "#    newf = np.reshape( newf, ( nnewf, 2 ))\n",
    "#    max_tri = max_tri + nnewt\n",
    "\n",
    "#    ids_py = [ id for id in range( max_face + 1, max_face + nnewf + 1 )]\n",
    "#    ids = np.array( ids_py )\n",
    "    \n",
    "#    newf = np.c_[ newf, ids ]\n",
    "#    max_face = max_face + nnewf\n",
    "\n",
    "#    faces = np.vstack(( faces, newf ))\n",
    "    \n",
    "#    _tris = [[ faces[ tri ][ 0 ], faces[ tri ][ 1 ]]  for tri in _faces ]\n",
    "#    _tris = [ item for sublist in _tris for item in sublist ]\n",
    "    \n",
    "    # TODO: pra criar os tris novos, tem q determinar as edges deles. Como as edges\n",
    "    # ja podem existir, possivelmente é melhor continuar o algoritmo e gerar as \n",
    "    # novas edges primeiro\n",
    "    \n",
    "#    _edges = [[ tris[ edge ][ 0 ], tris[ edge ][ 1 ]] for edge in _tris ]\n",
    "#    _edges = [ item for sublist in _edges for item in sublist ]\n",
    "#    print( _edges )\n",
    "\n",
    "\n",
    "# select all tris\n",
    "select( \"tris\", None )\n",
    "subdivide( 3 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div id=\"glowscript\" class=\"glowscript\"></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== \"undefined\") { window.__context = { glowscript_container: $(\"#glowscript\").removeAttr(\"id\")};}else{ element.textContent = ' ';}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== \"undefined\") {require.undef(\"nbextensions/vpython_libraries/glow.min\");}else{element.textContent = ' ';}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== \"undefined\") {require.undef(\"nbextensions/vpython_libraries/glowcomm\");}else{element.textContent = ' ';}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== \"undefined\") {require.undef(\"nbextensions/vpython_libraries/jquery-ui.custom.min\");}else{element.textContent = ' ';}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== \"undefined\") {require([\"nbextensions/vpython_libraries/glow.min\"], function(){console.log(\"GLOW LOADED\");});}else{element.textContent = ' ';}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== \"undefined\") {require([\"nbextensions/vpython_libraries/glowcomm\"], function(){console.log(\"GLOWCOMM LOADED\");});}else{element.textContent = ' ';}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== \"undefined\") {require([\"nbextensions/vpython_libraries/jquery-ui.custom.min\"], function(){console.log(\"JQUERY LOADED\");});}else{element.textContent = ' ';}"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# translate to the viewer technology\n",
    "\n",
    "# we will use vpython here, but the algorithm is probably the same or similar for all technologies\n",
    "\n",
    "# generate vertex data\n",
    "# generate tris data\n",
    "# generate vertex normal data\n",
    "# generate object data\n",
    "# pass object to be rendered\n",
    "\n",
    "from vpython import *\n",
    "\n",
    "     \n",
    "# generate vertex data - use TF to generate [ rx * 1/invp, ry * 1/invp, rz * 1/invp ] from vx tensor\n",
    "#  first sort the vx tensor since the order of the index will change during operations\n",
    "vxs = vxs[ vxs[ :, 4 ].argsort()]\n",
    "\n",
    "vdata = 1.0 / vxs[:, 3 ]\n",
    "vdata = np.multiply( vxs[:, [0, 1, 2]], vdata[:, None])\n",
    "\n",
    "#print( vdata )\n",
    "\n",
    "# generate tris data\n",
    "# use edges do index vxs\n",
    "    # TODO: edges precisa ser ordenada? Vao existir operacoes q tiram as edges de ordem? provavelmente sim\n",
    "    \n",
    "# vxs of 1st edge\n",
    "egdata = edges_meta[ tris[:, 0 ], 0:2 ]\n",
    "\n",
    "    # reversed edges ( rev1 )\n",
    "rev = tris[:, 2 ]\n",
    "m = rev > 0\n",
    "swap = egdata[ m, 0 ]\n",
    "\n",
    "egdata[ m, 0 ] = egdata[ m, 1 ]\n",
    "egdata[ m, 1 ] = swap\n",
    "\n",
    "# vxs of 2nd edge\n",
    "egdata2 = edges_meta[ tris[:, 1 ], 0:2 ]\n",
    "\n",
    "    # reversed edges ( rev2 )\n",
    "rev = tris[:, 3 ]\n",
    "m = rev > 0\n",
    "swap = egdata2[ m, 0 ]\n",
    "\n",
    "egdata2[ m, 0 ] = egdata2[ m, 1 ]\n",
    "egdata2[ m, 1 ] = swap\n",
    "\n",
    "tdata = np.c_[ egdata, egdata2[ :, 1 ]]\n",
    "# generate vxs in the view technology\n",
    "# using vpython\n",
    "\n",
    "vpvecs = [ vec( vdata[ k, 0 ], vdata[ k, 1 ], vdata[ k, 2 ]) for k in range( vdata.shape[ 0 ])]\n",
    "\n",
    "vpvxs = [ vertex( pos=vpvecs[ k ], color=vec( float(( k & 4 ) / 4 ), float(( k & 2 ) / 2 ), float( k & 1 ))) \n",
    "             for k in range( vdata.shape[ 0 ])]\n",
    "\n",
    "# generate tris\n",
    "vptris = [ triangle( vs=[ vpvxs[ tdata[ k, 0 ]], vpvxs[ tdata[ k, 1 ]], vpvxs[ tdata[ k, 2 ]]]) \n",
    "                       for k in range( tdata.shape[ 0 ])]\n",
    "\n",
    "# generate solid\n",
    "vpobj = compound( vptris )\n",
    "vpobj.visible = True\n",
    "\n",
    "# generating edges ( just to visualize them in vpython, this step is not necessary in all viewing technologies)\n",
    "vpedges1 = [ curve( pos=[ vpvecs[ tdata[ k, 0 ]], vpvecs[ tdata[ k, 1 ]]], \n",
    "                   color=vec( 0.5,0.5,0.5 )) for k in range( tdata.shape[ 0 ])]\n",
    "\n",
    "vpedges2 = [ curve( pos=[ vpvecs[ tdata[ k, 1 ]], vpvecs[ tdata[ k, 2 ]]], \n",
    "                   color=vec( 0.5,0.5,0.5 )) for k in range( tdata.shape[ 0 ])]\n",
    "\n",
    "vpedges3 = [ curve( pos=[ vpvecs[ tdata[ k, 2 ]], vpvecs[ tdata[ k, 0 ]]], \n",
    "                   color=vec( 0.5,0.5,0.5 )) for k in range( tdata.shape[ 0 ])]\n",
    "\n",
    "# init vpython and show the solid\n",
    "#scene = canvas() # for jupyter notebooks\n",
    "#scene.forward = vec( 0, -1, 0 )\n",
    "\n",
    "#c = curve(vector(-1,-1,0), vector(1,-1,0))\n",
    "\n",
    "while True:\n",
    "    rate( 60 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0.0, 0.0, 0.0), (0.0, 0.0, 1.0), (0.0, 1.0, 0.0), (0.0, 1.0, 1.0), (1.0, 0.0, 0.0), (1.0, 0.0, 1.0), (1.0, 1.0, 0.0), (1.0, 1.0, 1.0)]\n"
     ]
    }
   ],
   "source": [
    "test = [ ( float(( k & 4 ) / 4 ), float(( k & 2 ) / 2 ), float( k & 1 )) for k in range( vdata.shape[ 0 ])]\n",
    "print( test )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyPkDsVvRybOrUcBPPzrJJoK",
   "name": "vpython-test.ipynb",
   "provenance": []
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}