{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loadLibrary\n",
      "remoteSourcesURL https://git0.fmf.uni-lj.si/studen/nixSuite/raw/master/remoteResources/resources.json\n",
      "{'labkeyInterface': {'url': 'https://git0.fmf.uni-lj.si/studen/labkeyInterface/archive/master.zip', 'branch': 'master', 'modules': []}, 'irAEMM': {'url': 'https://git0.fmf.uni-lj.si/studen/iraemm/archive/master.zip', 'branch': 'master', 'modules': ['iraemmBrowser']}, 'SlicerLabkeyExtension': {'url': 'https://git0.fmf.uni-lj.si/studen/SlicerLabkeyExtension/archive/SlicerExtensionIndex.zip', 'branch': 'SlicerExtensionIndex', 'modules': ['labkeyBrowser']}, 'limfomiPET': {'url': 'https://git0.fmf.uni-lj.si/studen/limfomiPET/archive/master.zip', 'branch': 'master', 'modules': ['imageBrowser', 'segmentationBrowser']}, 'parseConfig': {'url': 'https://git0.fmf.uni-lj.si/studen/parseConfig/archive/master.zip', 'branch': 'master', 'modules': []}, 'orthancInterface': {'url': 'https://git0.fmf.uni-lj.si/studen/orthancInterface/archive/master.zip', 'branch': 'master', 'modules': []}}\n",
      "{'url': 'https://git0.fmf.uni-lj.si/studen/labkeyInterface/archive/master.zip', 'branch': 'master', 'modules': []}\n",
      "File  /home/studen/temp/labkeyInterface.zip: True\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "os.path.expanduser('~')\n",
    "sys.path.append(os.path.join(os.path.expanduser('~'),'software','src','nixSuite','wrapper'))\n",
    "import nixWrapper\n",
    "nixWrapper.loadLibrary('labkeyInterface')\n",
    "import labkeyInterface\n",
    "import labkeyDatabaseBrowser\n",
    "import labkeyFileBrowser\n",
    "#local files\n",
    "import downloadPatient\n",
    "\n",
    "def connect(server,f):\n",
    "    net=labkeyInterface.labkeyInterface()\n",
    "    fconfig=os.path.join(os.path.expanduser('~'),'.labkey','{}.json'.format(server))\n",
    "    net.init(fconfig)\n",
    "    net.getCSRF()\n",
    "    return f(net)\n",
    "\n",
    "def connectDB(server):\n",
    "    return connect(server,labkeyDatabaseBrowser.labkeyDB)\n",
    "\n",
    "def connectFB(server):\n",
    "    return connect(server,labkeyFileBrowser.labkeyFileBrowser)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User: andrej studen CSRF: 46851818c35cf1d4b585917ae2c6f635\n",
      "User: andrej studen CSRF: b7db61cfb531e7ccc9b334d169e7de4c\n",
      "['10KFMIR', '10KFOBR', '11ZMMIR', '11ZMOBR', '2SBMIR', '2SMobr', '3ZFMIR', '3ZFOBR', '5MIMIR', '5MIOBR', '7TMMIR', '7TMOBR', '8JSMIR', '8JSOBR']\n"
     ]
    }
   ],
   "source": [
    "fb=connectFB('merlin')\n",
    "db=connectDB('merlin')\n",
    "project='dinamic_spect/Patients'\n",
    "ds=db.selectRows(project,'study','Imaging',[])\n",
    "patients=[row['aliasID'] for row in ds['rows']]\n",
    "print(patients)\n",
    "\n",
    "\n",
    "locDir=os.path.join(os.path.expanduser('~'),'temp','dynamicSPECT')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#download files\n",
    "import labkeyDatabaseBrowser\n",
    "db=labkeyDatabaseBrowser.labkeyDB(net)\n",
    "ds=db.selectRows(project,'study','Imaging',[])\n",
    "patients=[row['aliasID'] for row in ds['rows']]\n",
    "patients1=['7TMOBR']\n",
    "for p in patients1:\n",
    "    pass\n",
    "\n",
    "    #patientId='7TMMIR'\n",
    "    #files=downloadPatient.readPatient(fb,locDir,project,p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import SimpleITK\n",
    "import matplotlib.pyplot\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getPatientNIM(id):\n",
    "    f=os.path.join(locDir,id,id+'Volume19.nrrd')\n",
    "    im=SimpleITK.ReadImage(f)\n",
    "    nim=SimpleITK.GetArrayFromImage(im)\n",
    "    return nim\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 888,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2SBMIR: [28]:160521.0 0.3870876729488373\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "patients1=[patients[4]]\n",
    "for p in patients1:\n",
    "    if p.find('8')==0:\n",
    "        continue\n",
    "    f=os.path.join(locDir,p,p+'Volume19.nrrd')\n",
    "    im=SimpleITK.ReadImage(f)\n",
    "    nim=SimpleITK.GetArrayFromImage(im)\n",
    "    pz=list(numpy.sum(numpy.sum(nim,0),1))\n",
    "    pz1=[pz[i-1]+pz[i+1]-2*pz[i] for i in numpy.arange(1,len(pz)-1)]\n",
    "    imin=pz1.index(min(pz1))\n",
    "    imax=pz.index(max(pz))\n",
    "    imin-=9\n",
    "    print('{}: [{}]:{} {}'.format(p,imin,pz[imin],pz[imin]/pz[imax]))\n",
    "    matplotlib.pyplot.plot(pz)\n",
    "    matplotlib.pyplot.scatter(imin,pz[imin])\n",
    "    \n",
    "matplotlib.pyplot.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "matplotlib.pyplot.imshow(nim[:,31,:])\n",
    "matplotlib.pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getSegment(nim,tip,base,w1,w2):\n",
    "    ctr=base+1/3.*(tip-base)\n",
    "    kap=base+2/3.*(tip-base)\n",
    "    n=(tip-base)/numpy.sqrt(numpy.dot(tip-base,tip-base))\n",
    "    sphCtr=tip-w2*n;\n",
    "    print(n)\n",
    "    x,y,z=numpy.meshgrid(numpy.arange(nim.shape[0])+0.5,numpy.arange(nim.shape[1])+0.5,numpy.arange(nim.shape[2])+0.5,indexing='xy')\n",
    "    #because of xy ordering, columns 2 and 1 are swapped, but that seems to fit well with reshape\n",
    "    #location coded as (r)\n",
    "    fr=numpy.array([x,y,z])\n",
    "    fr1=fr.transpose()\n",
    "    fr2=fr1.reshape(nim.size,-1)\n",
    "    print(fr2.shape)\n",
    "    #require r to lie above the r*n plane\n",
    "    fw=numpy.dot(fr2,n)\n",
    "    fw=fw.reshape(x.shape)\n",
    "    print(fw.shape)\n",
    "    fwkap=numpy.dot(kap,n)\n",
    "    fwctr=numpy.dot(ctr,n)\n",
    "    fwbase=numpy.dot(base,n)\n",
    "    \n",
    "    fcSph=numpy.array([sphCtr[0]*numpy.ones(x.shape),sphCtr[1]*numpy.ones(x.shape),sphCtr[2]*numpy.ones(x.shape)])\n",
    "    fcSph1=fcSph.transpose()\n",
    "    fcSph2=fcSph1.reshape((nim.size,-1))\n",
    "    vcSph=numpy.array([numpy.dot(v1-v2,v1-v2) for (v1,v2) in zip(fcSph2,fr2)])\n",
    "    vcSph2=vcSph.reshape(x.shape)\n",
    "    \n",
    "    fc=numpy.array([ctr[0]*numpy.ones(x.shape),ctr[1]*numpy.ones(x.shape),ctr[2]*numpy.ones(x.shape)])\n",
    "    fc1=fc.transpose()\n",
    "    fc2=fc1.reshape((nim.size,-1))\n",
    "    vc=numpy.array([numpy.dot(v1-v2,v1-v2) for (v1,v2) in zip(fc2,fr2)])\n",
    "    print('vc shape {}'.format(vc.shape))\n",
    "    vc2=vc.reshape(x.shape)\n",
    "    vcrho2=numpy.array([numpy.dot(v1-v2,n)*numpy.dot(v1-v2,n) for (v1,v2) in zip(fc2,fr2)])\n",
    "    vcrho2Flat=vc-vcrho2\n",
    "    print(len(vcrho2Flat[vcrho2Flat<0]))\n",
    "    vcrho2=vcrho2.reshape(x.shape)\n",
    "    vcrho2=vc2-vcrho2\n",
    "\n",
    "    vcsqrt=numpy.sqrt(vcrho2Flat)\n",
    "    print(len(vcsqrt[vcsqrt==0]))\n",
    "    tgphi2=numpy.array([(v1[2]-v2[2]) for (v1,v2) in zip(fr2,fc2)])\n",
    "    tgphi2[vcsqrt>0]/=vcsqrt[vcsqrt>0]\n",
    "    tgphi2=tgphi2.reshape(x.shape)\n",
    "    tgphi1=numpy.array([(v1[1]-v2[1]) for (v1,v2) in zip(fr2,fc2)])\n",
    "    tgphi1[vcsqrt>0]/=vcsqrt[vcsqrt>0]\n",
    "    tgphi1=tgphi1.reshape(x.shape)\n",
    "    print('Shape (tgphi):{}'.format(tgphi1.shape))\n",
    "    \n",
    "    cap=9*numpy.ones(x.shape)\n",
    "    cap[vcSph2<w1*w1]=0\n",
    "    cap[vcSph2>w2*w2]=0\n",
    "    cap[fw<fwkap]=0\n",
    "    \n",
    "    bar1=numpy.ones(x.shape)\n",
    "    bar1[vcrho2>w2*w2]=0\n",
    "    bar1[vcrho2<w1*w1]=0\n",
    "    bar1[fw<fwctr]=0\n",
    "    bar1[fw>fwkap]=0\n",
    "    bar1[tgphi2>numpy.sqrt(2)/2]*=4\n",
    "    bar1[tgphi2<-numpy.sqrt(2)/2]*=2\n",
    "    bar1[tgphi1>numpy.sqrt(2)/2]*=3\n",
    "    bar1[tgphi1<-numpy.sqrt(2)/2]*=1\n",
    "    bar1[bar1>0]+=4\n",
    "\n",
    "    bar2=numpy.ones(x.shape)\n",
    "    bar2[vcrho2>w2*w2]=0\n",
    "    bar2[vcrho2<w1*w1]=0\n",
    "    bar2[fw>fwctr]=0\n",
    "    bar2[fw<fwbase]=0\n",
    "    bar2[tgphi2>numpy.sqrt(2)/2]*=4\n",
    "    bar2[tgphi2<-numpy.sqrt(2)/2]*=2\n",
    "    bar2[tgphi1>numpy.sqrt(2)/2]*=3\n",
    "    bar2[tgphi1<-numpy.sqrt(2)/2]*=1\n",
    "\n",
    "    segm=bar1\\\n",
    "        +cap\\\n",
    "        +bar2\\\n",
    "    #transpose back to nim space (equivalent to ij indexing order)\n",
    "    vc2=numpy.transpose(vc2,axes=[1,0,2])\n",
    "    segm=numpy.transpose(segm,axes=[1,0,2])\n",
    "    return segm\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 987,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.  0.  0.]\n",
      "(114688, 3)\n",
      "(64, 28, 64)\n",
      "vc shape (114688,)\n",
      "0\n",
      "0\n",
      "Shape (tgphi):(64, 28, 64)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3/dist-packages/urllib3/connection.py:391: SubjectAltNameWarning: Certificate for merlin.fmf.uni-lj.si has no `subjectAltName`, falling back to check for a `commonName` for now. This feature is being removed by major browsers and deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 for details.)\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User: andrej studen CSRF: 7cefbfa156cf7df98b848d539c3da76e\n",
      "User: andrej studen CSRF: 5d36f73137830665383bdf7cfd5f49b1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "b'{\\n  \"rowsAffected\" : 1,\\n  \"queryName\" : \"Imaging\",\\n  \"schemaName\" : \"study\",\\n  \"containerPath\" : \"/dinamic_spect/Patients\",\\n  \"rows\" : [ {\\n    \"date\" : null,\\n    \"dsrowid\" : 112,\\n    \"CreatedBy\" : 1090,\\n    \"sliceView\" : \"5MIMIR_sliceView.png\",\\n    \"tipY\" : 32.0,\\n    \"tipZ\" : 32.5,\\n    \"ctData\" : \"2\",\\n    \"QCState\" : null,\\n    \"tipX\" : 6.0,\\n    \"SequenceNum\" : 1.0000,\\n    \"Created\" : \"2019/07/11 12:02:39\",\\n    \"lsid\" : \"urn:lsid:ijs.si:Study.Data-113:5001.5MI.1.0000\",\\n    \"CT\" : \"5MIMIRCT.nrrd\",\\n    \"baseX\" : 18.0,\\n    \"aliasID\" : \"5MIMIR\",\\n    \"sourcelsid\" : null,\\n    \"nmCorrData\" : \"9\",\\n    \"PatientId\" : \"5MI\",\\n    \"segmentation\" : \"5MIMIR_Segm.nrrd\",\\n    \"baseY\" : 32.0,\\n    \"w1\" : 2.0,\\n    \"nmMaster\" : \"4\",\\n    \"w2\" : 6.0,\\n    \"baseZ\" : 32.5\\n  } ],\\n  \"command\" : \"update\"\\n}'"
      ]
     },
     "execution_count": 987,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pId='5MIMIR'\n",
    "idFilter={'variable':'aliasID','value':pId,'oper':'eq'}\n",
    "ds=db.selectRows(project,'study','Imaging',[idFilter])\n",
    "rows=ds['rows']\n",
    "outrows=[]\n",
    "for r in rows:\n",
    "    p=r['aliasID']\n",
    "    if p.find('8')==0:\n",
    "        continue\n",
    "    f=os.path.join(locDir,p,p+'Volume19.nrrd')\n",
    "    im=SimpleITK.ReadImage(f)\n",
    "    nim=SimpleITK.GetArrayFromImage(im)\n",
    "    tip=numpy.array([float(r[x]) for x in ['tipX','tipY','tipZ']])\n",
    "    base=numpy.array([float(r[x]) for x in ['baseX','baseY','baseZ']])\n",
    "    segm=getSegment(nim,tip,base,float(r['w1']),float(r['w2']))\n",
    "    #adjust file name\n",
    "    outDir=os.path.join(locDir,p)\n",
    "    if not os.path.isdir(outDir):\n",
    "        os.makedirs(outDir)\n",
    "    segmImage=SimpleITK.GetImageFromArray(segm)\n",
    "    segmImage.SetOrigin(im.GetOrigin())\n",
    "    segmImage.SetDirection(im.GetDirection())\n",
    "    segmImage.SetSpacing(im.GetSpacing())\n",
    "    fname=p+'_Segm.nrrd'\n",
    "    SimpleITK.WriteImage(segmImage,os.path.join(locDir,p,fname))\n",
    "    r['segmentation']=fname\n",
    "    r['CT']=p+'CT.nrrd'\n",
    "    outrows.append(r)\n",
    "    remoteSegmentation=fb.buildPathURL(project,[p])\n",
    "    remoteSegmentation+='/'+fname\n",
    "    fb.writeFileToFile(os.path.join(locDir,p,fname),remoteSegmentation)\n",
    "db.modifyRows('update',project,'study','Imaging',outrows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3/dist-packages/urllib3/connection.py:391: SubjectAltNameWarning: Certificate for merlin.fmf.uni-lj.si has no `subjectAltName`, falling back to check for a `commonName` for now. This feature is being removed by major browsers and deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 for details.)\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'getSegment' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-a3a104143944>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mtip\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'tipX'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'tipY'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'tipZ'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'baseX'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'baseY'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'baseZ'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0msegm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgetSegment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnim\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtip\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbase\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'w1'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'w2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0mslc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m32\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msegm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mslc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'getSegment' is not defined"
     ]
    }
   ],
   "source": [
    "#test a segmentation\n",
    "pId='5MIMIR'\n",
    "nim=getPatientNIM(pId)\n",
    "idFilter={'variable':'aliasID','value':pId,'oper':'eq'}\n",
    "ds=db.selectRows(project,'study','Imaging',[idFilter])\n",
    "r=[row for row in ds['rows'] if row['aliasID']==pId][0]\n",
    "tip=numpy.array([float(r[x]) for x in ['tipX','tipY','tipZ']])\n",
    "base=numpy.array([float(r[x]) for x in ['baseX','baseY','baseZ']])\n",
    "segm=getSegment(nim,tip,base,float(r['w1']),float(r['w2']))\n",
    "slc=32\n",
    "matplotlib.pyplot.imshow(segm[:,slc,:])\n",
    "matplotlib.pyplot.show()\n",
    "matplotlib.pyplot.imshow(segm[:,slc,:])\n",
    "matplotlib.pyplot.show()\n",
    "matplotlib.pyplot.imshow(nim[:,slc,:])\n",
    "matplotlib.pyplot.show()\n",
    "matplotlib.pyplot.imshow(nim[:,slc,:])\n",
    "matplotlib.pyplot.imshow(segm[:,slc,:],alpha=0.2)\n",
    "matplotlib.pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3/dist-packages/urllib3/connection.py:391: SubjectAltNameWarning: Certificate for merlin.fmf.uni-lj.si has no `subjectAltName`, falling back to check for a `commonName` for now. This feature is being removed by major browsers and deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 for details.)\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "User: andrej studen CSRF: b2c5deaab50bbf312e803a4cb3ef654e\n",
      "User: andrej studen CSRF: 257a1acd17787f893ba19e2cf7e4dece\n",
      "User: andrej studen CSRF: cfa94419791e6d319f39db3b13dce0e8\n",
      "User: andrej studen CSRF: 9d1d2f1e76553c26eebf4a9a7e899894\n",
      "User: andrej studen CSRF: e7120ad92526021212ce0b35a7d8cc5d\n",
      "User: andrej studen CSRF: ba551108b45a9b4265a90ea84293ddb8\n",
      "User: andrej studen CSRF: ad3ce0403b63f901b140bf6b0e0170bd\n",
      "User: andrej studen CSRF: 1aaa66797a94a9d2e367ecb246c380db\n",
      "User: andrej studen CSRF: 8f9253891755ab14c876b8410f359da7\n",
      "User: andrej studen CSRF: 5507dd1a79c30bb4d0c658cffdac8b4a\n",
      "User: andrej studen CSRF: d9a4fa48be3393f3e6af67b74c0cfe1a\n",
      "User: andrej studen CSRF: 94c79b240b55d4d4241de6c63af139e5\n",
      "User: andrej studen CSRF: 631565d37ef0465a614d56c1566fa652\n",
      "User: andrej studen CSRF: 364c4c95011879d23cba730802820615\n",
      "User: andrej studen CSRF: be4a3a5941458ae25a28213cb92cdf53\n",
      "User: andrej studen CSRF: c564a5e90bb291a3f4559426b636eaa0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x864 with 27 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#manipulate segmentations\n",
    "pId='7TMOBR'\n",
    "save=True\n",
    "nim=getPatientNIM(pId)\n",
    "idFilter={'variable':'aliasID','value':pId,'oper':'eq'}\n",
    "ds=db.selectRows(project,'study','Imaging',[idFilter])\n",
    "r=[row for row in ds['rows'] if row['aliasID']==pId][0]\n",
    "tip=numpy.array([float(r[x]) for x in ['tipX','tipY','tipZ']])\n",
    "base=numpy.array([float(r[x]) for x in ['baseX','baseY','baseZ']])\n",
    "#segm=getSegment(nim,tip,base,float(r['w1']),float(r['w2']))\n",
    "\n",
    "fp=[]\n",
    "for i in numpy.arange(16):\n",
    "    sNum=r['SequenceNum']+0.0100*i\n",
    "    seqFilter={'variable':'SequenceNum','value':'{:.2f}'.format(sNum),'oper':'eq'}\n",
    "    ds=db.selectRows(project,'study','Segmentation',[idFilter,seqFilter])\n",
    "    \n",
    "    if len(ds['rows'])==0:\n",
    "        print('Not found for s={}'.format(sNum))\n",
    "        sx=12\n",
    "        sy=28\n",
    "        sz=32\n",
    "        rz=4\n",
    "        oz=0\n",
    "\n",
    "        slc=[sx,sy,sz]\n",
    "        p1=[sx,sy,sz]\n",
    "\n",
    "        #tip\n",
    "        p2=[7,sy,32]\n",
    "        p3=[10,sy,sz-rz]\n",
    "        p5=[15,sy,sz-rz]\n",
    "        p4=[10,sy,sz+rz-1]\n",
    "        p6=[15,sy,sz+rz]\n",
    "        \n",
    "        p7=[11,sy-rz,sz]\n",
    "        p8=[11,sy+rz-1,sz]\n",
    "        p9=[15,sy-rz,sz]\n",
    "        p10=[15,sy+rz,sz]\n",
    "\n",
    "        p11=[sx,sy+rz+oz,sz]\n",
    "        p12=[sx,sy+0.3*rz+oz,sz-rz]\n",
    "        p13=[sx,sy-0.3*rz+oz,sz-rz]\n",
    "        p14=[sx,sy-rz+oz,sz]\n",
    "        p15=[sx,sy-0.3*rz+oz,sz+rz]\n",
    "        p16=[sx,sy+0.3*rz+oz,sz+rz]\n",
    "        break\n",
    "    else:\n",
    "        frow=ds['rows'][0]\n",
    "        fp.append([float(x) for x in [frow['x'],frow['y'],frow['z']]])\n",
    "        fpp=fp[-1]\n",
    "        if i==0:\n",
    "            sx=int(fpp[0])\n",
    "            sy=int(fpp[1])\n",
    "            sz=int(fpp[2])\n",
    "\n",
    "if len(fp)>0:\n",
    "    print(len(fp))\n",
    "    p1=fp[0]\n",
    "    p2=fp[1]\n",
    "    p3=fp[2]\n",
    "    p4=fp[3]\n",
    "    p5=fp[4]\n",
    "    p6=fp[5]\n",
    "    p7=fp[6]\n",
    "    p8=fp[7]\n",
    "    p9=fp[8]\n",
    "    p10=fp[9]\n",
    "    p11=fp[10]\n",
    "    p12=fp[11]\n",
    "    p13=fp[12]\n",
    "    p14=fp[13]\n",
    "    p15=fp[14]\n",
    "    p16=fp[15]\n",
    "\n",
    "oz=0\n",
    "\n",
    "#sy+=2\n",
    "#sx+=1\n",
    "#sz+=2\n",
    "#rz=4\n",
    "\n",
    "slc=[sx,sy,sz]\n",
    "p1=[sx,sy,sz]\n",
    "\n",
    "p11=[sx,sy+rz+oz,sz]\n",
    "p12=[sx,sy+0.3*rz+oz,sz-rz]\n",
    "p13=[sx,sy-0.3*rz+oz,sz-rz]\n",
    "p14=[sx,sy-rz+oz,sz]\n",
    "p15=[sx,sy-0.3*rz+oz,sz+rz]\n",
    "p16=[sx,sy+0.3*rz+oz,sz+rz]  \n",
    "    \n",
    "#p8[1]-=1\n",
    "#p10[1]-=2\n",
    "#p8[0]+=1\n",
    "    \n",
    "cut0=20\n",
    "w0=20\n",
    "cut1=20\n",
    "w1=20\n",
    "cut2=5\n",
    "w2=20\n",
    "vmax=1000\n",
    "vmin=100\n",
    "fig,ax=matplotlib.pyplot.subplots(3,9,figsize=(20,12))\n",
    "for i in numpy.arange(0,9):\n",
    "    ax[0,i].imshow(nim[:,slc[1]-4+i,cut0:cut0+w0],cmap='gray_r',vmax=vmax,vmin=vmin)\n",
    "    ax[1,i].imshow(nim[cut2:cut2+w2,cut0:cut0+w0,slc[2]-4+i].T,cmap='gray_r',vmax=vmax,vmin=vmin)\n",
    "    ax[2,i].imshow(nim[slc[0]-4+i,cut1:cut1+w1,cut1:cut1+w1],cmap='gray_r',vmax=vmax,vmin=vmin)\n",
    "    if i==4:\n",
    "        pt=[p1,p2,p3,p4,p5,p6]\n",
    "        ax[0,i].scatter([x[2]-cut0 for x in pt],[x[0] for x in pt])\n",
    "        pt=[p1,p2,p7,p8,p9,p10]\n",
    "        ax[1,i].scatter([x[0]-cut2 for x in pt],[x[1]-cut0 for x in pt])\n",
    "        pt=[p1,p11,p12,p13,p14,p15,p16]\n",
    "        ax[2,i].scatter([x[2]-cut1 for x in pt],[x[1]-cut1 for x in pt])\n",
    "        \n",
    "    if i==0:\n",
    "        ax[0,i].text(2,2,pId,fontsize='large')\n",
    "        \n",
    "if save:\n",
    "    of=os.path.join(locDir,pId,'{}_segments.png'.format(pId))\n",
    "    matplotlib.pyplot.savefig(of)\n",
    "    \n",
    "    ds=db.selectRows(project,'study','Segmentation',[idFilter])\n",
    "    pts=[p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,p16]\n",
    "    for i in numpy.arange(len(pts)):\n",
    "        seqFilter={'variable':'SequenceNum','value':str(r['SequenceNum']+0.01*i),'oper':'eq'}\n",
    "        ds=db.selectRows(project,'study','Segmentation',[idFilter,seqFilter])\n",
    "        if len(ds['rows'])>0:\n",
    "            qrow=ds['rows'][0]\n",
    "            mode='update'\n",
    "        else:\n",
    "            qrow={}\n",
    "            qrow['PatientId']=r['PatientId']\n",
    "            qrow['SequenceNum']=0.01*i+r['SequenceNum']\n",
    "            qrow['aliasID']=pId\n",
    "            mode='insert'\n",
    "        qrow['regionId']=int(i)\n",
    "        qrow['x']=pts[i][0]\n",
    "        qrow['y']=pts[i][1]\n",
    "        qrow['z']=pts[i][2]\n",
    "        db.modifyRows(mode,project,'study','Segmentation',[qrow])\n",
    "    \n",
    "            \n",
    "matplotlib.pyplot.show()\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=numpy.zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [],
   "source": [
    "n[1,1]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f6198cabdf0>"
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "matplotlib.pyplot.imshow(n)\n",
    "matplotlib.pyplot.scatter([1],[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}