translate&rotateEndpoints.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Open mesh in ply format\n",
    "def open_ply(filepath):\n",
    "    f=open(filepath,'r');\n",
    "    i=0;\n",
    "    ip=0;\n",
    "    it=0;\n",
    "    np=0;\n",
    "    nt=0;\n",
    "    for str in f:\n",
    "        i+=1;\n",
    "        arr=str.split(\" \");\n",
    "        if(arr[0]==\"element\" and arr[1]==\"vertex\"):\n",
    "            np=int(arr[2]);\n",
    "            p=numpy.zeros((np,3));\n",
    "        elif(arr[0]==\"element\" and arr[1]==\"face\"):\n",
    "            nt=int(arr[2]);\n",
    "            t=numpy.zeros((nt,3));\n",
    "        elif(i>=11 and i<11+np):\n",
    "            p[ip,0]=float(arr[0]);\n",
    "            p[ip,1]=float(arr[1]);\n",
    "            p[ip,2]=float(arr[2]);\n",
    "            ip+=1;\n",
    "        elif(i>=11+np and i<11+np+nt):\n",
    "            t[it,0]=int(arr[1]);\n",
    "            t[it,1]=int(arr[2]);\n",
    "            t[it,2]=int(arr[3]);\n",
    "            it+=1;\n",
    "    mesh={};\n",
    "    mesh[\"np\"]=np;\n",
    "    mesh[\"nt\"]=nt;\n",
    "    mesh[\"p\"]=p;\n",
    "    mesh[\"t\"]=t;\n",
    "    return mesh;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pathDesktop = '/Users/ghfc/Desktop/'\n",
    "\n",
    "# Load a txt file with the list of paired endpoints, such as each line has x y z of endpoint1 and x y z of endpoint2\n",
    "fendpoints = pathDesktop+'P32_F16_endpoints_flipYX.txt'\n",
    "endpoints = numpy.loadtxt(fendpoints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 40.5658,  18.4215,  10.6564])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "endpoints[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rotation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "endpoints[:,0] *= -1\n",
    "endpoints[:,2] *= -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-40.5658,  18.4215, -10.6564])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "endpoints[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('xmin', -52.991100000000003, 'xmax', -24.088100000000001, ' ---- ', 28.903000000000002)\n",
      "('ymin', 12.5162, 'ymax', 34.532299999999999, ' ---- ', 22.016100000000002)\n",
      "('zmin', -24.222200000000001, 'zmax', -9.2386700000000008, ' ---- ', 14.98353)\n"
     ]
    }
   ],
   "source": [
    "print('xmin',endpoints[:,0].min(),'xmax',endpoints[:,0].max(),' ---- ',endpoints[:,0].max()-endpoints[:,0].min())\n",
    "print('ymin',endpoints[:,1].min(),'ymax',endpoints[:,1].max(),' ---- ',endpoints[:,1].max()-endpoints[:,1].min())\n",
    "print('zmin',endpoints[:,2].min(),'zmax',endpoints[:,2].max(),' ---- ',endpoints[:,2].max()-endpoints[:,2].min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fmesh = pathDesktop+'P32-F16_as_F01_402.ply'#'P32-F16_as_F01.ply'\n",
    "mesh = open_ply(fmesh)\n",
    "np=mesh[\"np\"];\n",
    "nt=mesh[\"nt\"];\n",
    "p=mesh[\"p\"];\n",
    "t=mesh[\"t\"];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('xmin', -13.602499999999999, 'xmax', 13.7883, ' ---- ', 27.390799999999999)\n",
      "('ymin', -12.0951, 'ymax', 10.8005, ' ---- ', 22.895600000000002)\n",
      "('zmin', -7.3936999999999999, 'zmax', 8.4204899999999991, ' ---- ', 15.81419)\n"
     ]
    }
   ],
   "source": [
    "print('xmin',p[:,0].min(),'xmax',p[:,0].max(),' ---- ',p[:,0].max()-p[:,0].min())\n",
    "print('ymin',p[:,1].min(),'ymax',p[:,1].max(),' ---- ',p[:,1].max()-p[:,1].min())\n",
    "print('zmin',p[:,2].min(),'zmax',p[:,2].max(),' ---- ',p[:,2].max()-p[:,2].min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.947680171608 1.03994803803 1.05543820448\n"
     ]
    }
   ],
   "source": [
    "xratio = (p[:,0].max()-p[:,0].min())/(endpoints[:,0].max()-endpoints[:,0].min())\n",
    "yratio = (p[:,1].max()-p[:,1].min())/(endpoints[:,1].max()-endpoints[:,1].min())\n",
    "zratio = (p[:,2].max()-p[:,2].min())/(endpoints[:,2].max()-endpoints[:,2].min())\n",
    "print xratio,yratio,zratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Scale down\n",
    "scale = 0.88\n",
    "endpoints[:,2] *= scale\n",
    "endpoints[:,1] *= scale\n",
    "endpoints[:,0] *= scale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Translation to mesh using centers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mzmesh 0.513395\n",
      "mzep 0.513395\n",
      "zstep 17.24383\n"
     ]
    }
   ],
   "source": [
    "# Z centre fitting\n",
    "mzmesh = (p[:,2].max()+p[:,2].min())/2\n",
    "mzep = (endpoints[:,2].max()+endpoints[:,2].min())/2\n",
    "print 'mzmesh',mzmesh\n",
    "print 'mzep',mzmesh\n",
    "zstep = mzmesh - mzep\n",
    "print 'zstep',zstep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.819706\n"
     ]
    }
   ],
   "source": [
    "# Z min fitting\n",
    "zminmesh = p[:,2].min()\n",
    "zminep = endpoints[:,2].min()\n",
    "zstep = zminmesh - zminep\n",
    "print 'zstep',zstep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mymesh -0.6473\n",
      "myep 23.52425\n",
      "ystep -24.17155\n"
     ]
    }
   ],
   "source": [
    "# Y centre fitting\n",
    "mymesh = (p[:,1].max()+p[:,1].min())/2\n",
    "myep = (endpoints[:,1].max()+endpoints[:,1].min())/2\n",
    "print 'mymesh',mymesh\n",
    "print 'myep',myep\n",
    "ystep = mymesh - myep\n",
    "print 'ystep',ystep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-24.712601\n"
     ]
    }
   ],
   "source": [
    "# Y min fitting\n",
    "yminmesh = p[:,1].min()\n",
    "yminep = endpoints[:,1].min()\n",
    "ystep = yminmesh - yminep\n",
    "print 'ystep',ystep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mxmesh -0.109\n",
      "mxep -38.5396\n",
      "xstep 38.4306\n"
     ]
    }
   ],
   "source": [
    "# X centre fitting\n",
    "mxmesh = (p[:,0].max()+p[:,0].min())/2\n",
    "mxep = (endpoints[:,0].max()+endpoints[:,0].min())/2\n",
    "print 'mxmesh',mxmesh\n",
    "print 'mxep',mxep\n",
    "xstep = mxmesh - mxep\n",
    "print 'xstep',xstep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xstep 39.3886\n"
     ]
    }
   ],
   "source": [
    "# X min fitting\n",
    "xminmesh = p[:,0].min()\n",
    "xminep = endpoints[:,0].min()\n",
    "xstep = xminmesh - xminep\n",
    "print 'xstep',xstep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "endpoints[:,2] += zstep\n",
    "endpoints[:,1] += ystep\n",
    "endpoints[:,0] += xstep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Adjustments\n",
    "endpoints[:,0] += 0.8 #0 #petit\n",
    "endpoints[:,1] += 1.5 #1.2\n",
    "endpoints[:,2] += 0.4 #0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from pandas import DataFrame\n",
    "df = DataFrame(endpoints)\n",
    "newfilename = 'P32_F16_endpoints_fit.txt'\n",
    "df.to_csv(pathDesktop+newfilename, index=False, header=False,sep=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('xmin', -14.006261000000002, 'xmax', 14.896739, ' ---- ', 28.903000000000002)\n",
      "('ymin', -11.701791499999997, 'ymax', 10.314308500000003, ' ---- ', 22.016100000000002)\n",
      "('zmin', -6.9339274999999994, 'zmax', 8.0496025000000007, ' ---- ', 14.98353)\n"
     ]
    }
   ],
   "source": [
    "print('xmin',endpoints[:,0].min(),'xmax',endpoints[:,0].max(),' ---- ',endpoints[:,0].max()-endpoints[:,0].min())\n",
    "print('ymin',endpoints[:,1].min(),'ymax',endpoints[:,1].max(),' ---- ',endpoints[:,1].max()-endpoints[:,1].min())\n",
    "print('zmin',endpoints[:,2].min(),'zmax',endpoints[:,2].max(),' ---- ',endpoints[:,2].max()-endpoints[:,2].min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Formatting endpoints file for connectivity matrices script "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "paired_ep = []\n",
    "i = 0\n",
    "while i <len(endpoints):\n",
    "    \n",
    "    paired_ep.append([endpoints[i][0],endpoints[i][1],endpoints[i][2],endpoints[i+1][0],endpoints[i+1][1],endpoints[i+1][2]])\n",
    "    i +=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from pandas import DataFrame\n",
    "dfp = DataFrame(paired_ep)\n",
    "newfilename = 'P32_F16_endpoints_fit_paired.txt'\n",
    "dfp.to_csv(pathDesktop+newfilename, index=False, header=False, sep=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}