examples/itkPolyDataToMeshFilter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# itkPolyDataToMeshFilter\n",
    "\n",
    "This example serves to demonstrate use of `itkMeshToPolyDataFilter` and `itkPolyDataToMeshFilter` for conversion between `itk.Mesh` and `itk.PolyData` data structures. An `itk.Mesh` object stores geometric data as a collection of `CellInterface` objects defined on the IDs of an underlying `itk.PointSet`, while an `itk.PolyData` object stores geometric data as a collection of points and a list of point IDs segmented by cell. `itk.Mesh` supports standard mesh formats and is useful for I/O with `itk.meshread` and `itk.meshwrite`, while `itk.PolyData` is often useful for visualization with `vtk`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from urllib.request import urlretrieve\n",
    "\n",
    "import itk\n",
    "from itkwidgets import view"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Mesh Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "MESH_FILE = \"Input/cow.vtk\"\n",
    "\n",
    "# Download mesh\n",
    "os.makedirs(\"Input\", exist_ok=True)\n",
    "if not os.path.exists(MESH_FILE):\n",
    "    url = \"https://data.kitware.com/api/v1/file/5c43feba8d777f072b0cd3da/download\"\n",
    "    urlretrieve(url, MESH_FILE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mesh (0000026EE123F310)\n",
      "  RTTI typeinfo:   class itk::Mesh<double,3,class itk::DefaultStaticMeshTraits<double,3,3,float,float,double> >\n",
      "  Reference Count: 1\n",
      "  Modified Time: 28464\n",
      "  Debug: Off\n",
      "  Object Name: \n",
      "  Observers: \n",
      "    none\n",
      "  Source: (none)\n",
      "  Source output name: (none)\n",
      "  Release Data: Off\n",
      "  Data Released: False\n",
      "  Global Release Data: Off\n",
      "  PipelineMTime: 19016\n",
      "  UpdateMTime: 28463\n",
      "  RealTimeStamp: 0 seconds \n",
      "  Number Of Points: 2903\n",
      "  Requested Number Of Regions: 1\n",
      "  Requested Region: 0\n",
      "  Buffered Region: 0\n",
      "  Maximum Number Of Regions: 1\n",
      "  Point Data Container pointer: 0000000000000000\n",
      "  Size of Point Data Container: 0\n",
      "  Number Of Points: 2903\n",
      "  Number Of Cell Links: 0\n",
      "  Number Of Cells: 3263\n",
      "  Cell Data Container pointer: 0000000000000000\n",
      "  Size of Cell Data Container: 0\n",
      "  Number of explicit cell boundary assignments: 3\n",
      "  CellsAllocationMethod: itk::MeshEnums::MeshClassCellsAllocationMethod::CellsAllocatedDynamicallyCellByCell\n",
      "\n"
     ]
    }
   ],
   "source": [
    "mesh_input = itk.meshread(MESH_FILE, itk.D)\n",
    "\n",
    "assert type(mesh_input) == itk.Mesh[itk.D, 3]\n",
    "print(mesh_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "itkPointF3 ([3.71636, 2.34339, 0])\n",
      "itkPointF3 ([4.12656, 0.642027, 0])\n",
      "itkPointF3 ([3.45497, 2.16988, 0])\n",
      "itkPointF3 ([3.92925, 0.411689, 0])\n",
      "itkPointF3 ([3.24741, 2.07333, 0])\n"
     ]
    }
   ],
   "source": [
    "# Inspect a few points\n",
    "for i in range(0, 5):\n",
    "    print(mesh_input.GetPoints().GetElement(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dd14dc2d3e1942c48e154f89573a872d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Viewer(geometries=[{'vtkClass': 'vtkPolyData', 'points': {'vtkClass': 'vtkPoints', 'numberOfComponents': 3, 'd…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "view(geometries=[mesh_input])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert to `itk.PolyData`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "poly_data = itk.mesh_to_poly_data_filter(mesh_input)\n",
    "\n",
    "assert type(poly_data) == itk.PolyData[itk.D]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[250, 251, 210, 252]\n",
      "[252, 210, 201, 253]\n",
      "[253, 201, 254]\n",
      "[254, 255, 256, 253]\n",
      "[253, 256, 257, 252]\n",
      "[252, 257, 258, 250]\n",
      "[258, 257, 259, 260]\n",
      "[260, 259, 261, 262]\n",
      "[262, 261, 263]\n",
      "[263, 261, 264, 265]\n",
      "[265, 264, 266]\n",
      "[266, 264, 267]\n",
      "[267, 264, 268, 269]\n",
      "[268, 264, 261, 259]\n",
      "[259, 257, 256, 268]\n",
      "[268, 256, 255, 269]\n",
      "[255, 254, 270]\n",
      "[269, 271, 272]\n",
      "[272, 267, 269]\n",
      "[272, 273, 274, 267]\n",
      "[273, 272, 271]\n",
      "[267, 274, 275]\n",
      "[267, 275, 276, 266]\n",
      "[266, 276, 277, 265]\n",
      "[265, 277, 278]\n",
      "[265, 278, 279, 263]\n",
      "[263, 279, 280, 262]\n",
      "[271, 281, 282, 273]\n",
      "[273, 282, 283, 274]\n",
      "[274, 283, 284, 275]\n",
      "[284, 285, 276]\n",
      "[276, 285, 286, 277]\n",
      "[277, 286, 287, 278]\n",
      "[278, 287, 288, 279]\n",
      "[279, 288, 289, 280]\n",
      "[281, 15, 16, 282]\n",
      "[282, 16, 17, 283]\n",
      "[283, 17, 18, 284]\n",
      "[284, 18, 19, 285]\n",
      "[285, 19, 20, 286]\n",
      "[286, 20, 21, 287]\n",
      "[287, 21, 22, 288]\n",
      "[288, 22, 23, 289]\n",
      "[290, 190, 291]\n",
      "[291, 177, 290]\n",
      "[290, 177, 292]\n",
      "[292, 293, 290]\n",
      "[290, 293, 191]\n",
      "[254, 201, 192]\n",
      "[192, 201, 200]\n",
      "[200, 191, 192]\n",
      "[254, 293, 292, 270]\n",
      "[270, 292, 271]\n",
      "[271, 292, 294]\n",
      "[294, 295, 281, 271]\n",
      "[281, 295, 24, 15]\n",
      "[24, 295, 179, 11]\n",
      "[271, 269, 255]\n",
      "[270, 271, 255]\n",
      "[192, 191, 293]\n",
      "[254, 192, 293]\n",
      "[177, 178, 294, 292]\n",
      "[294, 178, 179, 295]\n",
      "[444, 547, 459]\n",
      "[547, 444, 548]\n",
      "[548, 444, 428]\n",
      "[549, 459, 550]\n",
      "[550, 459, 547, 551]\n",
      "[551, 547, 548, 552]\n",
      "[552, 548, 428, 553]\n",
      "[553, 428, 554]\n",
      "[554, 428, 555]\n",
      "[556, 549, 550, 557]\n",
      "[557, 550, 551, 558]\n",
      "[558, 551, 552, 559]\n",
      "[559, 552, 560, 561]\n",
      "[560, 552, 553]\n",
      "[560, 553, 554, 562]\n",
      "[562, 554, 555, 563]\n",
      "[563, 555, 564]\n",
      "[564, 565, 563]\n",
      "[563, 565, 562]\n",
      "[562, 565, 561, 560]\n",
      "[564, 555, 410, 411]\n",
      "[411, 410, 566, 567]\n",
      "[567, 566, 392]\n",
      "[392, 568, 569, 567]\n",
      "[567, 569, 411]\n",
      "[569, 568, 570, 571]\n",
      "[568, 392, 393]\n",
      "[393, 392, 572]\n",
      "[572, 392, 373, 573]\n",
      "[573, 373, 374]\n",
      "[374, 373, 574]\n",
      "[574, 373, 354, 355]\n",
      "[574, 355, 356, 375]\n",
      "[375, 374, 574]\n",
      "[374, 375, 573]\n",
      "[573, 375, 394, 572]\n",
      "[570, 568, 393]\n",
      "[571, 570, 394, 575]\n",
      "[575, 576, 571]\n",
      "[571, 411, 569]\n",
      "[411, 571, 577]\n",
      "[577, 578, 411]\n",
      "[411, 578, 564]\n",
      "[564, 578, 579]\n",
      "[579, 578, 580]\n",
      "[580, 578, 577, 581]\n",
      "[579, 580, 582]\n",
      "[582, 580, 581, 412]\n",
      "[412, 581, 576]\n",
      "[412, 576, 583]\n",
      "[583, 394, 375, 376]\n",
      "[376, 375, 356, 357]\n",
      "[357, 356, 337, 338]\n",
      "[338, 29, 31, 357]\n",
      "[357, 31, 33, 376]\n",
      "[376, 33, 35, 583]\n",
      "[583, 35, 37, 412]\n",
      "[412, 37, 45, 582]\n",
      "[582, 45, 46, 584]\n",
      "[584, 585, 579, 582]\n",
      "[579, 585, 561]\n",
      "[561, 565, 579]\n",
      "[579, 565, 564]\n",
      "[586, 556, 557, 587]\n",
      "[587, 557, 558, 588]\n",
      "[588, 558, 559, 589]\n",
      "[589, 559, 561, 585]\n",
      "[585, 584, 590, 591]\n",
      "[591, 592, 589, 585]\n",
      "[589, 592, 593, 588]\n",
      "[588, 593, 594, 595]\n",
      "[595, 596, 597, 588]\n",
      "[588, 597, 598, 587]\n",
      "[587, 598, 599, 586]\n",
      "[586, 599, 600, 601]\n",
      "[603, 602, 604, 47]\n",
      "[47, 604, 605, 48]\n",
      "[48, 605, 606, 49]\n",
      "[49, 606, 596, 595]\n",
      "[595, 594, 607, 49]\n",
      "[49, 607, 608, 50]\n",
      "[50, 608, 609, 46]\n",
      "[46, 609, 590, 584]\n",
      "[570, 393, 394]\n",
      "[572, 394, 393]\n",
      "[611, 610, 612, 613]\n",
      "[613, 612, 614, 615]\n",
      "[615, 614, 616, 617]\n",
      "[617, 616, 618, 619]\n",
      "[619, 618, 620, 621]\n",
      "[621, 620, 622, 623]\n",
      "[623, 622, 624, 625]\n",
      "[625, 624, 626, 627]\n",
      "[627, 626, 628, 629]\n",
      "[629, 628, 630]\n",
      "[630, 628, 51, 52]\n",
      "[51, 628, 626, 53]\n",
      "[54, 624, 622, 55]\n",
      "[55, 622, 620, 56]\n",
      "[56, 620, 618, 57]\n",
      "[57, 618, 616, 58]\n",
      "[58, 616, 614, 59]\n",
      "[59, 614, 612, 60]\n",
      "[60, 612, 610, 61]\n",
      "[61, 610, 603, 47]\n",
      "[53, 626, 624, 54]\n",
      "[629, 631, 627]\n",
      "[627, 631, 632, 625]\n",
      "[625, 632, 633, 623]\n",
      "[623, 633, 634, 621]\n",
      "[621, 634, 635, 619]\n",
      "[619, 635, 636, 617]\n",
      "[617, 636, 615]\n",
      "[637, 546, 638]\n",
      "[631, 637, 632]\n",
      "[632, 637, 638, 633]\n",
      "[633, 638, 639, 634]\n",
      "[634, 639, 640, 635]\n",
      "[635, 640, 636]\n",
      "[640, 639, 641]\n",
      "[630, 52, 62, 642]\n",
      "[642, 62, 63, 643]\n",
      "[641, 639, 638, 546]\n",
      "[734, 705, 699, 735]\n",
      "[732, 688, 736, 737]\n",
      "[737, 736, 676, 738]\n",
      "[734, 735, 739]\n",
      "[739, 740, 741]\n",
      "[741, 740, 742]\n",
      "[744, 745, 746, 747]\n",
      "[747, 746, 748, 749]\n",
      "[749, 748, 750, 751]\n",
      "[751, 752, 753, 749]\n",
      "[749, 753, 754, 747]\n",
      "[747, 754, 755, 744]\n",
      "[756, 748, 746, 757]\n",
      "[757, 746, 745, 758]\n",
      "[758, 759, 760, 761]\n",
      "[762, 755, 754, 763]\n",
      "[764, 763, 754, 753]\n",
      "[753, 752, 764]\n",
      "[765, 758, 745]\n",
      "[737, 738, 760, 759]\n",
      "[732, 743, 721, 688]\n",
      "[735, 699, 721, 743]\n",
      "[766, 739, 741, 767]\n",
      "[767, 741, 742, 768]\n",
      "[768, 742, 762, 769]\n",
      "[770, 764, 752, 771]\n",
      "[769, 762, 763, 772]\n",
      "[772, 763, 764, 770]\n",
      "[773, 767, 768, 774]\n"
     ]
    }
   ],
   "source": [
    "# Visualize cells as collections of point IDs\n",
    "\n",
    "i = 0\n",
    "polygons = poly_data.GetPolygons()\n",
    "while i < 1000:\n",
    "    x = list()\n",
    "    for j in range(0, polygons.ElementAt(i)):\n",
    "        x.append(polygons.ElementAt(i + 1 + j))\n",
    "    print(x)\n",
    "    i += polygons.ElementAt(i) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert back to `itk.Mesh`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh_output = itk.poly_data_to_mesh_filter(poly_data)\n",
    "\n",
    "assert type(mesh_output) == itk.Mesh[itk.D, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "assert mesh_output.GetNumberOfPoints() == mesh_input.GetNumberOfPoints()\n",
    "assert mesh_output.GetNumberOfCells() == mesh_input.GetNumberOfCells()\n",
    "for i in range(0, mesh_output.GetNumberOfPoints()):\n",
    "    assert mesh_output.GetPoint(i) == mesh_input.GetPoint(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "71ab9ed224294f46a4ecc1711b479cea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Viewer(geometries=[{'vtkClass': 'vtkPolyData', 'points': {'vtkClass': 'vtkPoints', 'numberOfComponents': 3, 'd…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "view(geometries=[mesh_output])"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}