{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding Structured Point Clouds (SPCs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Structured Point Clouds (SPC) is a differentiable, GPU-compatible, spatial-data structure which efficiently organizes 3D geometrically sparse information in a very compressed manner.\n",
    "\n",
    "![alt text](../samples/spcTeapot.png \"Structured Point Cloud Hierarchy\")\n",
    "\n",
    "<b> When should you use it? </b>\n",
    "* The SPC data structure is very general, which makes it <mark>a suitable building block for a variety of applications</mark>.\n",
    "* Examples include: \n",
    "    * [Representation & rendering of implicit 3D surfaces](https://nv-tlabs.github.io/nglod/)\n",
    "    * Convolutions on voxels, meshes and point clouds\n",
    "    * and more..\n",
    "\n",
    "SPCs are easily convertible from point clouds and meshes, and can be optimized to represent encoded neural implicit fields.\n",
    "\n",
    "<b> In this tutorial you will learn to: </b>\n",
    "1. Construct a SPC from triangular meshes and point clouds.\n",
    "2. Visualize the SPC using ray-tracing functionality.\n",
    "3. Become familiar with the internals of kaolin's SPC data structure\n",
    "\n",
    "Practitioners are encouraged to view the [documentation](https://kaolin.readthedocs.io/en/latest/modules/kaolin.ops.spc.html?highlight=spc#kaolin-ops-spc) for additional details about the internal workings of this data structure. <br>\n",
    "This tutorial is best run locally to observe the full output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial assumes a minimal version of [kaolin v0.10.0](https://kaolin.readthedocs.io/en/latest/notes/installation.html). <br>\n",
    "In addition, the following libraries are required for this tutorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!pip install -q matplotlib\n",
    "!pip install -q termcolor\n",
    "!pip install -q ipywidgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import ipywidgets as widgets\n",
    "from termcolor import colored\n",
    "\n",
    "import kaolin as kal\n",
    "from spc_formatting import describe_octree, color_by_level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To study the mechanics of the SPC structure, we'll need some auxilary functions (you may skip for now): <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def describe_tensor(torch_tensor, tensor_label, with_content):\n",
    "    print(kal.utils.testing.tensor_info(torch_tensor, name=tensor_label))\n",
    "    if with_content:\n",
    "        print(f'Raw Content: \\n{torch_tensor.cpu().numpy()}')\n",
    "        \n",
    "\n",
    "def convert_texture_to_torch_sample_format(texture):\n",
    "    \"\"\" Convert to (1, C, Tex-H, Tex-W) format \"\"\"\n",
    "    return texture.unsqueeze(0).type(sampled_uvs.dtype).permute(0, 3, 1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preliminaries: Load Mesh and sample as Point Cloud"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Throughout this tutorial we'll be using a triangular mesh as an example. <br>\n",
    "First, we import the mesh using kaolin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Mesh material type <class 'dict'> is not PBRMaterial; no support for device conversions\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SurfaceMesh object with batching strategy Batching.FIXED\n",
      "            vertices: [1, 642, 3] (torch.float32)[cuda:0]  \n",
      "               faces: [1280, 3] (torch.int64)[cuda:0]  \n",
      "                 uvs: [1, 671, 2] (torch.float32)[cuda:0]  \n",
      "        face_uvs_idx: [1, 1280, 3] (torch.int64)[cuda:0]  \n",
      "material_assignments: [1, 1280] (torch.int16)[cuda:0]  \n",
      "           materials: [\n",
      "                      0: list of length 1\n",
      "                      ]\n",
      "       face_vertices: if possible, computed on access from: (faces, vertices)\n",
      "        face_normals: if possible, computed on access from: (normals, face_normals_idx) or (vertex_normals, faces) or (vertices, faces)\n",
      "            face_uvs: if possible, computed on access from: (uvs, face_uvs_idx)\n",
      "      vertex_normals: if possible, computed on access from: (faces, face_normals)\n",
      "     vertex_tangents: if possible, computed on access from: (faces, face_vertices, face_uvs, vertex_normals)\n",
      "       vertex_colors: if possible, computed on access from: (faces, face_colors)\n",
      "     vertex_features: if possible, computed on access from: (faces, face_features)\n",
      "       face_tangents: if possible, computed on access from: (faces, vertex_tangents)\n",
      "         face_colors: if possible, computed on access from: (faces, vertex_colors)\n",
      "       face_features: if possible, computed on access from: (faces, vertex_features)\n"
     ]
    }
   ],
   "source": [
    "# Path to some .obj file with textures\n",
    "mesh_path = \"../samples/colored_sphere.obj\"\n",
    "mesh = kal.io.obj.import_mesh(mesh_path, with_materials=True)\n",
    "\n",
    "# We convert mesh to fixed batching strategy, expected by the sampling function\n",
    "mesh = mesh.to_batched().cuda()\n",
    "print(mesh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll oversample the mesh faces to make sure our SPC structure is densely populated and avoids \"holes\"\n",
    "at the highest resolution level.\n",
    "\n",
    "Note that our mesh face-vertices are mapped to some texture coordinates.\n",
    "Luckily, kaolin has a `sample_points` function that will take care of interpolating these coordinates for us. \n",
    "The sampled vertices will be returned along with the interpolated uv coordinates as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampled 1000000 points over the mesh surface:\n",
      "sampled_verts is a tensor with batch size 1, with 1000000 points of 3D coordinates.\n",
      "sampled_uvs is a tensor with batch size 1, representing the corresponding 1000000 2D UV coordinates.\n"
     ]
    }
   ],
   "source": [
    "# Sample points over the mesh surface, interpolating face uv coordinates\n",
    "num_samples = 1000000\n",
    "sampled_verts, _, sampled_uvs = kal.ops.mesh.trianglemesh.sample_points(mesh.vertices,\n",
    "                                                                        mesh.faces,\n",
    "                                                                        num_samples=num_samples,\n",
    "                                                                        face_features=mesh.face_uvs)\n",
    "\n",
    "print(f'Sampled {sampled_verts.shape[1]} points over the mesh surface:')\n",
    "print(f'sampled_verts is a tensor with batch size {sampled_verts.shape[0]},',\n",
    "      f'with {sampled_verts.shape[1]} points of {sampled_verts.shape[2]}D coordinates.')\n",
    "\n",
    "print(f'sampled_uvs is a tensor with batch size {sampled_uvs.shape[0]},',\n",
    "      f'representing the corresponding {sampled_uvs.shape[1]} {sampled_uvs.shape[2]}D UV coordinates.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To finish our setup, we'll want to use the UV coordinates to perform texture sampling and obtain the RGB color of each point we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vertices: [1000000, 3] (torch.float32)[cuda:0]  \n",
      "vertex_colors: [1000000, 3] (torch.float32)[cuda:0]  \n"
     ]
    }
   ],
   "source": [
    "# Convert texture to sample-compatible format\n",
    "diffuse_color = mesh.materials[0][0]['map_Kd']    # Assumes a shape with a single material\n",
    "texture_maps = convert_texture_to_torch_sample_format(diffuse_color) # (1, C, Th, Tw)\n",
    "texture_maps = texture_maps.cuda()\n",
    "\n",
    "# Sample colors according to uv-coordinates\n",
    "sampled_uvs = kal.render.mesh.utils.texture_mapping(texture_coordinates=sampled_uvs,\n",
    "                                                    texture_maps=texture_maps,\n",
    "                                                    mode='nearest')\n",
    "# Unbatch\n",
    "vertices = sampled_verts.squeeze(0)\n",
    "vertex_colors = sampled_uvs.squeeze(0)\n",
    "\n",
    "# Normalize to [0,1]\n",
    "vertex_colors /= 255\n",
    "\n",
    "describe_tensor(vertices, 'vertices', with_content=False)\n",
    "describe_tensor(vertex_colors, 'vertex_colors', with_content=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Create & Visualize SPC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the SPC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by converting our Point Cloud of continuous 3D coordinates to a Structured Point Cloud. <br>\n",
    "\n",
    "`unbatched_pointcloud_to_spc` will return a `Spc` object, a data class holding all Structured Point Cloud related information. <br>\n",
    "At the core of this object, points are kept in quantized coordinates using a compressed octree. <br>\n",
    "\n",
    "The returned object contains multiple low-level data structures which we'll explore in details in the next section.\n",
    "For now keep in mind that its important fields: `octree`, `features`, `point_hierarchy`, `pyramid` and `prefix`, represent our data structure.\n",
    "\n",
    "When constructing a `Spc` object, the resolution of quantized coordinates can be controlled by the octree `level` arg, such that: $resolution=2^{level}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Our SPC will contain a hierarchy of multiple levels\n",
    "level = 3\n",
    "spc = kal.ops.conversions.pointcloud.unbatched_pointcloud_to_spc(vertices, level, features=vertex_colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set-up the camera"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The SPC data structure can be efficiently visualized using ray-tracing ops. <br>\n",
    "\n",
    "Note that SPC also supports differentiable rendering. In this tutorial we'll limit our demonstration to rendering this data structure efficiently. <br>\n",
    "Differentiable ray-tracing is beyond the scope of this guide, and will be covered in future tutorials."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To begin our ray tracing implementation, we'll first need to set up our camera view and [generate some rays](https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-generating-camera-rays). <br>\n",
    "We'll assume a pinhole camera model, and use the `look_at` function, which sets up a camera view originating at position `camera_from`, looking towards `camera_to`. <br>\n",
    "`width`, `height`, `mode` and `fov` will determine the dimensions of our view."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _normalized_grid(width, height, device='cuda'):\n",
    "    \"\"\"Returns grid[x,y] -> coordinates for a normalized window.\n",
    "    \n",
    "    Args:\n",
    "        width, height (int): grid resolution\n",
    "    \"\"\"\n",
    "\n",
    "    # These are normalized coordinates\n",
    "    # i.e. equivalent to 2.0 * (fragCoord / iResolution.xy) - 1.0\n",
    "    window_x = torch.linspace(-1, 1, steps=width, device=device) * (width / height)\n",
    "    window_y = torch.linspace(1,- 1, steps=height, device=device)\n",
    "\n",
    "    coord = torch.stack(torch.meshgrid(window_x, window_y)).permute(1,2,0)\n",
    "    return coord\n",
    "\n",
    "\n",
    "def look_at(camera_from, camera_to, width, height, mode='persp', fov=90.0, device='cuda'):\n",
    "    \"\"\"Vectorized look-at function, returns an array of ray origins and directions\n",
    "    URL: https://www.scratchapixel.com/lessons/mathematics-physics-for-computer-graphics/lookat-function\n",
    "    \"\"\"\n",
    "\n",
    "    camera_origin = torch.FloatTensor(camera_from).to(device)\n",
    "    camera_view = F.normalize(torch.FloatTensor(camera_to).to(device) - camera_origin, dim=0)\n",
    "    camera_right = F.normalize(torch.cross(camera_view, torch.FloatTensor([0,1,0]).to(device)), dim=0)\n",
    "    camera_up = F.normalize(torch.cross(camera_right, camera_view), dim=0)\n",
    "\n",
    "    coord = _normalized_grid(width, height, device=device)\n",
    "    ray_origin = camera_right * coord[...,0,np.newaxis] * np.tan(np.radians(fov/2)) + \\\n",
    "                 camera_up * coord[...,1,np.newaxis] * np.tan(np.radians(fov/2)) + \\\n",
    "                 camera_origin + camera_view\n",
    "    ray_origin = ray_origin.reshape(-1, 3)\n",
    "    ray_offset = camera_view.unsqueeze(0).repeat(ray_origin.shape[0], 1)\n",
    "    \n",
    "    if mode == 'ortho': # Orthographic camera\n",
    "        ray_dir = F.normalize(ray_offset, dim=-1)\n",
    "    elif mode == 'persp': # Perspective camera\n",
    "        ray_dir = F.normalize(ray_origin - camera_origin, dim=-1)\n",
    "        ray_origin = camera_origin.repeat(ray_dir.shape[0], 1)\n",
    "    else:\n",
    "        raise ValueError('Invalid camera mode!')\n",
    "\n",
    "\n",
    "    return ray_origin, ray_dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now generate some rays using the functions we've just created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total of 1048576 rays generated.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_7821/4264699583.py:24: UserWarning: Using torch.cross without specifying the dim arg is deprecated.\n",
      "Please either pass the dim explicitly or simply use torch.linalg.cross.\n",
      "The default value of dim will change to agree with that of linalg.cross in a future release. (Triggered internally at /opt/conda/conda-bld/pytorch_1720538435607/work/aten/src/ATen/native/Cross.cpp:62.)\n",
      "  camera_right = F.normalize(torch.cross(camera_view, torch.FloatTensor([0,1,0]).to(device)), dim=0)\n",
      "/opt/conda/lib/python3.11/site-packages/torch/functional.py:513: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1720538435607/work/aten/src/ATen/native/TensorShape.cpp:3609.)\n",
      "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
     ]
    }
   ],
   "source": [
    "# ray_o and ray_d ~ torch.Tensor (width x height, 3)\n",
    "# represent rays origin and direction vectors\n",
    "ray_o, ray_d = look_at(camera_from=[-2.5,2.5,-2.5],\n",
    "                       camera_to=[0,0,0],\n",
    "                       width=1024,\n",
    "                       height=1024,\n",
    "                       mode='persp',\n",
    "                       fov=30,\n",
    "                       device='cuda')\n",
    "\n",
    "print(f'Total of {ray_o.shape[0]} rays generated.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Render"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're now ready to perform the actual ray tracing. <br>\n",
    "kaolin will \"shoot\" the rays for us, and perform an efficient intersection test between each ray and cell within the SPC structure. <br>\n",
    "In kaolin terminology, <b>nuggets</b> are \"ray-cell intersections\" (or rather \"ray-point\" intersections).\n",
    "\n",
    "<b>nuggets </b> are of represented by a structure of two tensors: `nugs_ridx` and `nugs_pidx`, <br>which form together pairs of `(index_to_ray, index_to_points)`. <br>\n",
    "Both tensors are 1-dimensional tensors of shape (`#num_intersection`,)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total of 1195190 nuggets were traced.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "octree, features = spc.octrees, spc.features\n",
    "point_hierarchy, pyramid, prefix = spc.point_hierarchies, spc.pyramids[0], spc.exsum\n",
    "nugs_ridx, nugs_pidx, depth = kal.render.spc.unbatched_raytrace(octree, point_hierarchy, pyramid, prefix, ray_o, ray_d, level)\n",
    "print(f'Total of {nugs_ridx.shape[0]} nuggets were traced.\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we're assuming here our surface is opaque, for each ray, we only care about the <b>nugget</b>\n",
    "closest to the camera. <br>\n",
    "Note that per \"ray-pack\", the returned <b>nuggets</b> are already sorted by depth. <br>\n",
    "The method below returns a boolean mask which specifies which <b>nuggets</b> represent a \"first-hit\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "masked_nugs = kal.render.spc.mark_pack_boundaries(nugs_ridx)\n",
    "nugs_ridx = nugs_ridx[masked_nugs]\n",
    "nugs_pidx = nugs_pidx[masked_nugs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, for each ray that hit the surface, a corresponding \"first-hit\" nugget exists. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. We initialize an empty canvas.\n",
    "image = torch.ones_like(ray_o)\n",
    "\n",
    "# 2. We'll query all first-hit nuggets to obtain their corresponding point-id (which cell they hit in the SPC).\n",
    "ridx = nugs_ridx.long()\n",
    "pidx = nugs_pidx.long() - pyramid[1,level]\n",
    "\n",
    "# 3. We'll query the features auxilary structure to obtain the color.\n",
    "# 4. We set each ray value as the corresponding nugget color.\n",
    "image[ridx] = features[pidx]\n",
    "\n",
    "image = image.reshape(1024, 1024, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Putting it all together, we write our complete `render()` function and display the trace using matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def render(level):\n",
    "    \"\"\" Create & render an image \"\"\"\n",
    "    spc = kal.ops.conversions.pointcloud.unbatched_pointcloud_to_spc(vertices, level, vertex_colors)\n",
    "    octree, features, point_hierarchy, pyramid, prefix = spc.octrees, spc.features, spc.point_hierarchies, spc.pyramids[0], spc.exsum\n",
    "    \n",
    "    nugs_ridx, nugs_pidx, depth = kal.render.spc.unbatched_raytrace(octree, point_hierarchy, pyramid, prefix, ray_o, ray_d, level)\n",
    "    masked_nugs = kal.render.spc.mark_pack_boundaries(nugs_ridx)\n",
    "    nugs_ridx = nugs_ridx[masked_nugs]\n",
    "    nugs_pidx = nugs_pidx[masked_nugs]\n",
    "    \n",
    "    ridx = nugs_ridx.long()\n",
    "    pidx = nugs_pidx.long() - pyramid[1,level]\n",
    "    image = torch.ones_like(ray_o)\n",
    "    image[ridx] = features[pidx]\n",
    "    image = image.reshape(1024, 1024, 3)\n",
    "    return image\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(20,10))\n",
    "\n",
    "# Render left image of level 3 SPC\n",
    "image1 = render(level=3)\n",
    "image1 = image1.cpu().numpy().transpose(1,0,2)\n",
    "ax = fig.add_subplot(1, 2, 1)\n",
    "ax.set_title(\"level 3\", fontsize=26)\n",
    "ax.axis('off')\n",
    "plt.imshow(image1)\n",
    "\n",
    "# Render right image of level 5 SPC\n",
    "image2 = render(level=8)\n",
    "image2 = image2.cpu().numpy().transpose(1,0,2)\n",
    "ax = fig.add_subplot(1, 2, 2)\n",
    "ax.set_title(\"level 5\", fontsize=26)\n",
    "ax.axis('off')\n",
    "plt.imshow(image2)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, putting it all together, we may also construct the following interactive demo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e992a88aa66b4e25be819d1aae33df9a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(VBox(children=(IntSlider(value=7, description='<h5>SPC Level:</h5>', layout=Layout(height='100%…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def update_demo(widget_spc_level):\n",
    "    image = render(widget_spc_level)\n",
    "    plt.figure(figsize=(10,10))\n",
    "    plt.axis('off')\n",
    "    plt.imshow(image.cpu().numpy().transpose(1,0,2))\n",
    "    plt.show()\n",
    "\n",
    "def show_interactive_demo(max_level=10):\n",
    "    start_value = min(7, max_level)\n",
    "    widget_spc_level = widgets.IntSlider(value=start_value, min=1, max=max_level, step=1, orientation='vertical',\n",
    "                                     description='<h5>SPC Level:</h5>', disabled=False,\n",
    "                                     layout=widgets.Layout(height='100%',))\n",
    "    \n",
    "    out = widgets.interactive_output(update_demo, {'widget_spc_level': widget_spc_level})\n",
    "    display(widgets.HBox([widgets.VBox([widget_spc_level]), out]))\n",
    "\n",
    "show_interactive_demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. SPC internals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we'll explore the various components that make up the [SPC](https://kaolin.readthedocs.io/en/latest/modules/kaolin.ops.spc.html?highlight=spc#structured-point-clouds) we've just created. <br>\n",
    "We'll learn how data is stored, and how to view stored data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boilerplate code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's rebuild our SPC object with fewer levels, that will make the internals easier to study. <br>\n",
    "You may customize the number of levels and compare how the output changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "level = 3\n",
    "spc = kal.ops.conversions.pointcloud.unbatched_pointcloud_to_spc(vertices, level, features=vertex_colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, let's see what we've got."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### octree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first field we'll look into, `octrees`, keeps the entire geometric structure in a compressed manner. <br>\n",
    "This is a huge advantage, as this structure is now small enough to fit our sparse data, which makes it very efficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "octree = spc.octrees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "octree: [17] (torch.uint8)[cuda:0]  \n",
      "Raw Content: \n",
      "[255 128  64  32  16   8   4   2   1 127 191 223 239 247 251 253 254]\n",
      "\n",
      "\"octrees\" represents a hierarchy of 17 octree nodes.\n",
      "Let's have a look at the binary representation and what it means:\n",
      "\n",
      "Level \u001b[31m#1, \u001b[0mPath\u001b[31m*\u001b[0m,        11111111\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m1\u001b[0m,      10000000\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m2\u001b[0m,      01000000\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m3\u001b[0m,      00100000\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m4\u001b[0m,      00010000\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m5\u001b[0m,      00001000\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m6\u001b[0m,      00000100\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m7\u001b[0m,      00000010\n",
      "Level \u001b[34m#2, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m8\u001b[0m,      00000001\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m1\u001b[0m-\u001b[32m8\u001b[0m,    01111111\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m2\u001b[0m-\u001b[32m7\u001b[0m,    10111111\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m3\u001b[0m-\u001b[32m6\u001b[0m,    11011111\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m4\u001b[0m-\u001b[32m5\u001b[0m,    11101111\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m5\u001b[0m-\u001b[32m4\u001b[0m,    11110111\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m6\u001b[0m-\u001b[32m3\u001b[0m,    11111011\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m7\u001b[0m-\u001b[32m2\u001b[0m,    11111101\n",
      "Level \u001b[32m#3, \u001b[0mPath\u001b[31m*\u001b[0m-\u001b[34m8\u001b[0m-\u001b[32m1\u001b[0m,    11111110\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "293799b3f63a4a2285f4164ecff34987",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(layout=Layout(border_bottom='0.2px dashed black', border_left='0.2px dashed black', bord…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "describe_tensor(torch_tensor=octree, tensor_label='octree', with_content=True)\n",
    "\n",
    "print(f'\\n\"octrees\" represents a hierarchy of {len(octree)} octree nodes.')\n",
    "print(f\"Let's have a look at the binary representation and what it means:\\n\")\n",
    "\n",
    "describe_octree(octree, level)\n",
    "\n",
    "text_out = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "with text_out:\n",
    "    print('How to read the content of octrees?')\n",
    "    print('- Each entry represents a single octree of 8 cells --> 8 bits.')\n",
    "    print('- The bit position determines the cell index, in Morton Order.')\n",
    "    print('- The bit value determines if the cell is occupied or not.')\n",
    "    print(f'- If a cell is occupied, an additional octree may be generated in the next level, up till level {level}.')\n",
    "    print('For example, an entry of 00000001 is a single level octree, where only the bottom-left most cell is occupied.')\n",
    "    \n",
    "display(widgets.HBox([text_out]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Order of octants within partitioned cells\n",
    "![alt text](../samples/octants.png \"Octants\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the field is named in plural.\n",
    "That's because kaolin can batch multiple instances of octrees together within the same object. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(spc.batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pay attention that `octrees` uses [packed representation](https://kaolin.readthedocs.io/en/latest/modules/kaolin.ops.batch.html?highlight=packed#packed), meaning, there is no explicit batch dimension. <br>\n",
    "Instead, we track the length of each octree instance in a separate field:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lengths: [1] (torch.int32)[cpu]  \n",
      "Raw Content: \n",
      "[17]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d97b366364464953b2e5f272c43251a5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(layout=Layout(border_bottom='0.2px dashed black', border_left='0.2px dashed black', bord…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "octrees_lengths = spc.lengths\n",
    "describe_tensor(torch_tensor=octrees_lengths, tensor_label='lengths', with_content=True)\n",
    "\n",
    "text_out = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "with text_out:\n",
    "    print('How to read the content of lengths?')\n",
    "    print(f'- This Spc stores a batch of {len(spc.lengths)} octrees.')\n",
    "    print(f'- The first octree is represented by {spc.lengths[0]} non-leaf cells.')\n",
    "    print(f'- Therefore the information of the first octree is kept in bytes 0-{spc.lengths[0]-1} of the octrees field.')\n",
    "    \n",
    "display(widgets.HBox([text_out]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Advanced users who prefer a non object-oriented lower-level api can also use the following functionality which `kal.ops.conversions.pointcloud.unbatched_pointcloud_to_spc` employs under the hood:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "octrees: [26] (torch.uint8)[cuda:0]  \n",
      "Raw Content: \n",
      "[255 128  64  32  16   8   4   2   1 255 128  64  32  16   8   4   2   1\n",
      " 127 191 223 239 247 251 253 254]\n",
      "\n",
      "lengths: [2] (torch.int32)[cpu]  \n",
      "Raw Content: \n",
      "[ 9 17]\n"
     ]
    }
   ],
   "source": [
    "from kaolin.ops.spc.points import quantize_points, points_to_morton, morton_to_points, unbatched_points_to_octree\n",
    "\n",
    "# Construct a batch of 2 octrees. For brevity, we'll use the same ocuupancy data for both.\n",
    "# 1. Convert continous to quantized coordinates\n",
    "# 2. Build the octrees\n",
    "\n",
    "points1 = quantize_points(vertices.contiguous(), level=2)\n",
    "octree1 = unbatched_points_to_octree(points1, level=2)\n",
    "\n",
    "points2 = quantize_points(vertices.contiguous(), level=3)\n",
    "octree2 = unbatched_points_to_octree(points2, level=3)\n",
    "\n",
    "# Batch 2 octrees together. For packed representations, this is just concatenation.\n",
    "octrees = torch.cat((octree1, octree2), dim=0)\n",
    "lengths = torch.tensor([len(octree1), len(octree2)], dtype=torch.int32)\n",
    "\n",
    "describe_tensor(torch_tensor=octrees, tensor_label='octrees', with_content=True)\n",
    "print('')\n",
    "describe_tensor(torch_tensor=lengths, tensor_label='lengths', with_content=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These structures form the bare minimum required to shift back to high-level api and construct a Spc object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<kaolin.rep.spc.Spc at 0x78f638244890>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kal.rep.spc.Spc(octrees, lengths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we've lookied into how Structured Point Clouds keep track of occupancy. <br>\n",
    "Next we'll study how they keep track of features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `features` field contains features information per cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = spc.features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In this tutorial, cell features are RGB colors:\n",
      "features: [56, 3] (torch.float32)[cuda:0]  \n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAAhCAYAAABeFd2hAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAAkNJREFUeJzt3d9rzXEcx/Hv8WNOY9NYs6WlsdqxrSXhgiTKrVzMhRtX1G5duEIrKddcKUmUOzeKlpK4c0EborYlLiRqicnvnb7+BL7v3rVaj8f1efY5dX58v6/OxamVZVkWAAAAiZYt9hMAAACWHkMDAABIZ2gAAADpDA0AACCdoQEAAKQzNAAAgHSGBgAAkM7QAAAA0q343wee3b4vdEBjbyPUfZndHOqeH1uo3Ky+1hI6q6sjlBUDfe2h7sLhZqjrmJgIdV87T1dueodmQ2cNP3gZ6kbafoe6u7u2hbr6pTWhrnv+ReVmrvdI6KzRPTdD3fTreqhrbe8JdbcW2kLdwea7ys25PztDZ13vfBTqDs0cD3UD+x+Guv4PtVDX7Pse6nbc+VG5aSl+hs5aN7wx1H2euhHqugf7Q910bXeoe7yy+n/mjt77GDqrvjb2er8fiX1WP70aDHVPp2Kfu/ETqyo3kxOxC/mTwblQt2ko9v66P1/93qYoimJmJnaNPNp4U7m5suVU6KyxX2dC3fq3y0Pd1a4Doe5kx2So+3axtXLTU1S/ZyiKorg9tjXUXX4W+27YMH7+n4/xiwYAAJDO0AAAANIZGgAAQDpDAwAASGdoAAAA6QwNAAAgnaEBAACkMzQAAIB0hgYAAJDO0AAAANIZGgAAQDpDAwAASGdoAAAA6WplWZaL/SQAAIClxS8aAABAOkMDAABIZ2gAAADpDA0AACCdoQEAAKQzNAAAgHSGBgAAkM7QAAAA0hkaAABAur8UqFc7zGRMJAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c595bd805a2d43e587d6c12a2f55a8c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(layout=Layout(border_bottom='0.2px dashed black', border_left='0.2px dashed black', bord…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def paint_features(features):\n",
    "    plt.figure(figsize=(10,10))\n",
    "    plt.axis('off')\n",
    "    plt.imshow(features.cpu().numpy()[None])\n",
    "    plt.show()\n",
    "    \n",
    "print('In this tutorial, cell features are RGB colors:')\n",
    "describe_tensor(torch_tensor=features, tensor_label='features', with_content=False)\n",
    "paint_features(features)\n",
    "\n",
    "text_out = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "with text_out:\n",
    "    print('How to read the content of features?')\n",
    "    print(f'- We keep features only for leaf cells, a total of {features.shape[0]}.')\n",
    "    print(f'- The number of leaf cells can be obtained by summarizing the \"1\" bits at level {spc.max_level},\\n' \\\n",
    "    '  the last level of the octree.')\n",
    "    print(f'- The dimensionality of each attribute is {features.shape[1]} (e.g: RGB channels)')\n",
    "    print('\\nReminder - the highest level of occupancy octree is:')\n",
    "    describe_octree(spc.octrees, level, limit_levels=[spc.max_level])\n",
    "    \n",
    "\n",
    "display(widgets.HBox([text_out]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pyramid & exsum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the occupancy information is [compressed](https://kaolin.readthedocs.io/en/latest/modules/kaolin.ops.spc.html?highlight=spc#octree) and [packed](https://kaolin.readthedocs.io/en/latest/modules/kaolin.ops.batch.html?highlight=packed#packed), accessing level-specific information consistently involves\n",
    "cumulative summarization of the number of \"1\" bits. <br>\n",
    "It makes sense to calculate this information once and then cache it. <br>\n",
    "The `pyramid` field does exactly that: it keeps summarizes the number of occupied cells per level, and their cumsum, for fast level-indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A pyramid is kept per octree in the batch.\n",
    "# We'll study the pyramid of the first and only entry in the batch.\n",
    "pyramid = spc.pyramids[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pyramid: [2, 5] (torch.int32)[cpu]  \n",
      "Raw Content: \n",
      "[[ 1  8  8 56  0]\n",
      " [ 0  1  9 17 73]]\n",
      "\n",
      "How to read the content of pyramids?\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9dbf4baa98f540b3840efdfb6642dfc9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(layout=Layout(border_bottom='0.2px dashed black', border_left='0.2px dashed black', bord…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "describe_tensor(torch_tensor=pyramid, tensor_label='pyramid', with_content=True)\n",
    "\n",
    "out_left = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "out_right = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "\n",
    "print('\\nHow to read the content of pyramids?')\n",
    "\n",
    "with out_left:\n",
    "    print('\"pyramid\" summarizes the number of occupied \\ncells per level, and their cumulative sum:\\n')\n",
    "    for i in range(pyramid.shape[-1]):\n",
    "        if i ==0:\n",
    "            print(f'Root node (implicitly defined):')\n",
    "        elif i+1 < pyramid.shape[-1]:\n",
    "            print(f'Level #{i}:')\n",
    "        else:\n",
    "            print(f'Final entry for total cumsum:')\n",
    "        print(f'\\thas {pyramid[0,i]} occupied cells')\n",
    "        print(f'\\tstart idx (cumsum excluding current level): {pyramid[1,i]}')\n",
    "        \n",
    "with out_right:\n",
    "    print(f'\"octrees\" represents a hierarchy of {len(spc.octrees)} octree nodes.')\n",
    "    print(f\"Each bit represents a cell occupancy:\\n\")\n",
    "    describe_octree(octree, level)\n",
    "    \n",
    "    \n",
    "display(widgets.HBox([out_left, out_right]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, kaolin keeps a complementary field, `exsum`, which tracks the cumulative summarization of bits per-octree to fast access parent-child information between levels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "exsum = spc.exsum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exsum: [17] (torch.int32)[cuda:0]  \n",
      "Raw Content: \n",
      "[ 8  9 10 11 12 13 14 15 16 23 30 37 44 51 58 65 72]\n",
      "\n",
      "How to read the content of exsum?\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "47f5a33d7c8a4b9c9660cdccff76ee0e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(layout=Layout(border_bottom='0.2px dashed black', border_left='0.2px dashed black', bord…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "describe_tensor(torch_tensor=exsum, tensor_label='exsum', with_content=True)\n",
    "\n",
    "out_left = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "out_right = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "\n",
    "print('\\nHow to read the content of exsum?')\n",
    "\n",
    "with out_left:\n",
    "    print('\"exsum\" is the inclusive prefix sum of the \"1\"-bit counts\\n(occupied child cells) of the octree bytes:\\n')\n",
    "    print('exsum[i] = total occupied child cells in bytes 0..i (inclusive).')\n",
    "    print('The children of node i therefore span cell indices\\n[exsum[i-1], exsum[i]), starting at 0 for i = 0:\\n')\n",
    "    for i in range(exsum.shape[-1]):\n",
    "        start = 0 if i == 0 else int(exsum[i - 1])\n",
    "        print(f'Node #{i}: child cells {start}..{int(exsum[i]) - 1}')\n",
    "        \n",
    "with out_right:\n",
    "    print(f'\"octrees\" represents a hierarchy of {len(octree)} octree nodes.')\n",
    "    print(f\"Each bit represents a cell occupancy:\\n\")\n",
    "    describe_octree(octree, level)\n",
    "    \n",
    "    \n",
    "display(widgets.HBox([out_left, out_right]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using Spc objects, pyramids are implicitly created the first time they are needed so you don't have to worry about them. <br>\n",
    "For advanced users, the low-level api allows their explicit creation through `scan_octrees`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_level:\n",
      "3\n",
      "\n",
      "pyramid:\n",
      "tensor([[[ 1,  8,  8, 56,  0],\n",
      "         [ 0,  1,  9, 17, 73]]], dtype=torch.int32)\n",
      "\n",
      "exsum:\n",
      "tensor([ 8,  9, 10, 11, 12, 13, 14, 15, 16, 23, 30, 37, 44, 51, 58, 65, 72],\n",
      "       device='cuda:0', dtype=torch.int32)\n"
     ]
    }
   ],
   "source": [
    "lengths = torch.tensor([len(octree)], dtype=torch.int32)\n",
    "max_level, pyramid, exsum = kal.ops.spc.spc.scan_octrees(octree, lengths)\n",
    "\n",
    "print('max_level:')\n",
    "print(max_level)\n",
    "\n",
    "print('\\npyramid:')\n",
    "print(pyramid)\n",
    "\n",
    "print('\\nexsum:')\n",
    "print(exsum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### point_hierarchies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`point_hierarchies` is an auxilary field, which holds the *sparse* coordinates of each point / occupied cell within the octree, for easier access.\n",
    "\n",
    "Sparse coordinates are packed for all cells on all levels combined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "point_hierarchies: [73, 3] (torch.int16)[cuda:0]  \n"
     ]
    }
   ],
   "source": [
    "describe_tensor(torch_tensor=spc.point_hierarchies, tensor_label='point_hierarchies', with_content=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the information stored in the pyramids field to color the coordinates by level:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5cd713358f3a4d44a881727c6efdece4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(layout=Layout(border_bottom='0.2px dashed black', border_left='0.2px dashed black', bord…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "out_left = widgets.Output(layout={'border': '0.2px dashed black'})\n",
    "out_right = widgets.Output(layout={'border': '0.2px dashed black', 'width': '60%'})\n",
    "\n",
    "max_points_to_display = 17  # To avoid clutter\n",
    "\n",
    "with out_left:\n",
    "    level_idx =0\n",
    "    point_idx = 0\n",
    "    remaining_cells_per_level = spc.pyramids[0,0].cpu().numpy().tolist()\n",
    "\n",
    "    for coord in spc.point_hierarchies:\n",
    "        remaining_cells_per_level[level_idx] -= 1\n",
    "\n",
    "        if point_idx == max_points_to_display:\n",
    "            print(colored(f'skipping more..', level_color))\n",
    "        elif point_idx < max_points_to_display:\n",
    "            level_color = color_by_level(level_idx - 1)\n",
    "            print(colored(f'Level #{level_idx}, Point #{point_idx}, ' \\\n",
    "                          f'Coords: {coord.cpu().numpy().tolist()}', level_color))\n",
    "\n",
    "        if not remaining_cells_per_level[level_idx]:\n",
    "            level_idx += 1\n",
    "            point_idx = 0\n",
    "        else:\n",
    "            point_idx += 1\n",
    "\n",
    "with out_right:\n",
    "    print('How to read the content of point_hierarchies?')\n",
    "    print(f'- Each cell / point is represented by {spc.point_hierarchies.shape[-1]} indices (xyz).')\n",
    "    print('- Sparse coordinates are absolute: \\n  they are defined relative to the octree origin.')    \n",
    "    print('- Compare the point coordinates with the demo below.\\n\\n  Remember: unoccupied cells are not displayed!')\n",
    "    show_interactive_demo(max_level=spc.max_level)\n",
    "\n",
    "display(widgets.HBox([out_left, out_right]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where to go from here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Structured Point Clouds support other useful operators which were not covered by this tutorial:\n",
    "\n",
    "1. [Convolutions](https://kaolin.readthedocs.io/en/latest/modules/kaolin.ops.spc.html?highlight=SPC#kaolin.ops.spc.Conv3d)\n",
    "2. [Querying points by location](https://kaolin.readthedocs.io/en/latest/modules/kaolin.ops.spc.html?highlight=SPC#kaolin.ops.spc.unbatched_query)\n",
    "3. [Differential ray-tracing ops](https://kaolin.readthedocs.io/en/latest/modules/kaolin.render.spc.html#kaolin-render-spc)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "kaolin (devcontainer)",
   "language": "python",
   "name": "kaolin"
  },
  "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}