{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Object pose estimation" ] }, { "cell_type": "markdown", "metadata": { "jp-MarkdownHeadingCollapsed": true, "tags": [] }, "source": [ "## Overview\n", "\n", "In this tutorial, we will show how to optimize the pose of an object while correctly accounting for the visibility discontinuities. We are going to optimize several latent variables that control the translation and rotation of the object.\n", "\n", "In differentiable rendering, we aim to evaluate the derivative of a pixel intensity integral with respect to a scene parameter $\\pi$ as follows:\n", "\n", "\\begin{equation}\n", "\\partial_\\pi I(\\pi) = \\partial_\\pi \\int_P f(\\textbf{x}, \\pi) ~ d\\textbf{x}\n", "\\end{equation}\n", "\n", "where $\\textbf{x}$ is a light path in the path space $P$.\n", "\n", "When the function $f(\\cdot)$ is continuous w.r.t. $\\pi$, we can move the derivative into the integral and then apply Monte Carlo integration. Under this assumption, differentiating the rendering process via automatic differentiation, as in the previous tutorials, is correct.\n", "\n", "However, if $f(\\cdot)$ has discontinuities w.r.t. $\\pi$, direct application of automatic differentiation is not correct anymore, as it omits an integral term given by the [Reynolds transport theorem](https://en.wikipedia.org/wiki/Reynolds_transport_theorem). This needs to be considered when differentiating shape-related parameters (e.g., position), as the discontinuities in the visiblity function (the silhouette of the object) are then dependent on the differentiated parameter.\n", "\n", "In the last years, several works tried to address this issue (e.g., Li et al. (2018), Zhang et al. (2020), Loubet et al. (2019), Bangaru et al. (2020), ...). Mitsuba provides dedicated integrators implementing the *reparameterization*-based approach (Loubet et al. (2019), Bangaru et al. (2020), Zeltner et al. (2021)):\n", "\n", "- [prb_reparam][1]: reparameterized Path Replay Backpropagation (PRB) integrator\n", "- [direct_reparam][2]: reparameterized direct illumination integrator\n", "\n", "\n", "In this tutorial, we will optimize the position and rotation of a mesh in order to match a target rendering. To keep things simple, we will use the `direct_reparam` integrator.\n", "\n", "\n", "
\n", "\n", "🚀 **You will learn how to:**\n", " \n", "\n", " \n", "
\n", "\n", "[1]: https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_integrators.html#reparameterized-path-replay-backpropagation-integrator-prb-reparam\n", "[2]: https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_integrators.html#reparameterized-direct-integrator-direct-reparam" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup\n", "\n", "As always, let's import `drjit` and `mitsuba` and set a differentiation-aware variant." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import drjit as dr\n", "import mitsuba as mi\n", "\n", "mi.set_variant('llvm_ad_rgb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `direct_reparam` and scene construction\n", "\n", "We will rely on the `direct_reparam` integrator for this tutorial to properly handle the visibility discontinuities in our differentiable simulation. In primal rendering, this integrator is identical to the `direct` integrator." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "integrator = {\n", " 'type': 'direct_reparam',\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We create a simple scene with a bunny placed in front of a gray wall, illuminated by a spherical light." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from mitsuba.scalar_rgb import Transform4f as T\n", "\n", "scene = mi.load_dict({\n", " 'type': 'scene',\n", " 'integrator': integrator,\n", " 'sensor': {\n", " 'type': 'perspective',\n", " 'to_world': T.look_at(\n", " origin=(0, 0, 2),\n", " target=(0, 0, 0),\n", " up=(0, 1, 0)\n", " ),\n", " 'fov': 60,\n", " 'film': {\n", " 'type': 'hdrfilm',\n", " 'width': 64,\n", " 'height': 64,\n", " 'rfilter': { 'type': 'gaussian' },\n", " 'sample_border': True\n", " },\n", " },\n", " 'wall': {\n", " 'type': 'obj',\n", " 'filename': '../scenes/meshes/rectangle.obj',\n", " 'to_world': T.translate([0, 0, -2]).scale(2.0),\n", " 'face_normals': True,\n", " 'bsdf': {\n", " 'type': 'diffuse',\n", " 'reflectance': { 'type': 'rgb', 'value': (0.5, 0.5, 0.5) },\n", " }\n", " },\n", " 'bunny': {\n", " 'type': 'ply',\n", " 'filename': '../scenes/meshes/bunny.ply',\n", " 'to_world': T.scale(6.5),\n", " 'bsdf': {\n", " 'type': 'diffuse',\n", " 'reflectance': { 'type': 'rgb', 'value': (0.3, 0.3, 0.75) },\n", " },\n", " },\n", " 'light': {\n", " 'type': 'obj',\n", " 'filename': '../scenes/meshes/sphere.obj',\n", " 'emitter': {\n", " 'type': 'area',\n", " 'radiance': {'type': 'rgb', 'value': [1e3, 1e3, 1e3]}\n", " },\n", " 'to_world': T.translate([2.5, 2.5, 7.0]).scale(0.25)\n", " }\n", "})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reference image\n", "\n", "Next we generate the target rendering. We will later modify the bunny's position and rotation to set the initial optimization state." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "Bitmap[\n", " pixel_format = rgb,\n", " component_format = uint8,\n", " size = [64, 64],\n", " srgb_gamma = 1,\n", " struct = Struct<3>[\n", " uint8 R; // @0, normalized, gamma, premultiplied alpha\n", " uint8 G; // @1, normalized, gamma, premultiplied alpha\n", " uint8 B; // @2, normalized, gamma, premultiplied alpha\n", " ],\n", " data = [ 12 KiB of image data ]\n", "]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "img_ref = mi.render(scene, seed=0, spp=1024)\n", "\n", "mi.util.convert_to_bitmap(img_ref)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimizer and latent variables\n", "\n", "As done in previous tutorial, we access the scene parameters using the `traverse()` mechanism. We then store a copy of the initial vertex positions. Those will be used later to compute the new vertex positions at every iteration, always applying a different transformation on the same base shape. \n", "\n", "Since the vertex positions in `Mesh` are stored in a linear buffer (e.g., `x_1, y_1, z_1, x_2, y_2, z_2, ...`), we use the `dr.unravel()` routine to unflatten that array into a `Point3f` array." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "params = mi.traverse(scene)\n", "initial_vertex_positions = dr.unravel(mi.Point3f, params['bunny.vertex_positions'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While it would be possible to optimize the vertex positions of the bunny independently, in this example we are only going to optimize a translation and rotation parameter. This drastically constrains the optimization process, which helps with convergence.\n", "\n", "Therefore, we instantiate an optimizer and assign two variables to it: `angle` and `trans`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "opt = mi.ad.Adam(lr=0.025)\n", "opt['angle'] = mi.Float(0.25)\n", "opt['trans'] = mi.Point2f(0.1, -0.25)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the optimizer's point of view, those variables are the same as any other variables optimized in the previous tutorials, to the exception that when calling `opt.update()`, the optimizer doesn't know how to propagate their new values to the scene parameters. This has to be done *manually*, and we encapsulate exactly that logic in the function defined below. More detailed explaination on this can be found [here][1].\n", "\n", "After clamping the optimized variables to a proper range, this function creates a transformation object combining a translation and rotation and applies it to the vertex positions stored previously. It then flattens those new vertex positions before assigning them to the scene parameters.\n", "\n", "[1]: https://mitsuba.readthedocs.io/en/latest/src/how_to_guides/use_optimizers.html#Optimizing-latent-variables" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def apply_transformation(params, opt):\n", " opt['trans'] = dr.clamp(opt['trans'], -0.5, 0.5)\n", " opt['angle'] = dr.clamp(opt['angle'], -0.5, 0.5)\n", " \n", " trafo = mi.Transform4f.translate([opt['trans'].x, opt['trans'].y, 0.0]).rotate([0, 1, 0], opt['angle'] * 100.0)\n", " \n", " params['bunny.vertex_positions'] = dr.ravel(trafo @ initial_vertex_positions)\n", " params.update()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is now time to apply our first transformation to get the bunny to its initial state before starting the optimization." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "Bitmap[\n", " pixel_format = rgb,\n", " component_format = uint8,\n", " size = [64, 64],\n", " srgb_gamma = 1,\n", " struct = Struct<3>[\n", " uint8 R; // @0, normalized, gamma, premultiplied alpha\n", " uint8 G; // @1, normalized, gamma, premultiplied alpha\n", " uint8 B; // @2, normalized, gamma, premultiplied alpha\n", " ],\n", " data = [ 12 KiB of image data ]\n", "]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "apply_transformation(params, opt)\n", "\n", "img_init = mi.render(scene, seed=0, spp=1024)\n", "\n", "mi.util.convert_to_bitmap(img_init)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the following cell we define the hyper parameters controlling the optimization, such as the number of iterations and number of samples per pixels for the differentiable rendering simulation:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "iteration_count = 50\n", "spp = 16" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "nbsphinx": "hidden", "tags": [] }, "outputs": [], "source": [ "# IGNORE THIS: When running under pytest, adjust parameters to reduce computation time\n", "import os\n", "if 'PYTEST_CURRENT_TEST' in os.environ:\n", " iteration_count = 2\n", " spp = 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The optimization loop below is very similar to the one used in the other tutorials, except that we need to apply the transformation to update the bunny's state and record the relation between the rendered image and the optimized parameters." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration 49: error=0.002785, angle=0.0040, trans=[-0.0001, -0.0021]\r" ] } ], "source": [ "loss_hist = []\n", "for it in range(iteration_count):\n", " # Apply the mesh transformation\n", " apply_transformation(params, opt)\n", " \n", " # Perform a differentiable rendering\n", " img = mi.render(scene, params, seed=it, spp=spp)\n", "\n", " # Evaluate the objective function\n", " loss = dr.sum(dr.sqr(img - img_ref)) / len(img)\n", " \n", " # Backpropagate through the rendering process\n", " dr.backward(loss)\n", "\n", " # Optimizer: take a gradient descent step\n", " opt.step()\n", "\n", " loss_hist.append(loss)\n", " print(f\"Iteration {it:02d}: error={loss[0]:6f}, angle={opt['angle'][0]:.4f}, trans=[{opt['trans'].x[0]:.4f}, {opt['trans'].y[0]:.4f}]\", end='\\r')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualizing the results\n", "\n", "Finally, let's visualize the results and plot the loss over iterations" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "nbsphinx-thumbnail": {}, "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib import pyplot as plt\n", "\n", "fig, axs = plt.subplots(2, 2, figsize=(10, 10))\n", "\n", "axs[0][0].plot(loss_hist)\n", "axs[0][0].set_xlabel('iteration'); \n", "axs[0][0].set_ylabel('Loss'); \n", "axs[0][0].set_title('Parameter error plot');\n", "\n", "axs[0][1].imshow(mi.util.convert_to_bitmap(img_init))\n", "axs[0][1].axis('off')\n", "axs[0][1].set_title('Initial Image')\n", "\n", "axs[1][0].imshow(mi.util.convert_to_bitmap(mi.render(scene, spp=1024)))\n", "axs[1][0].axis('off')\n", "axs[1][0].set_title('Optimized image')\n", "\n", "axs[1][1].imshow(mi.util.convert_to_bitmap(img_ref))\n", "axs[1][1].axis('off')\n", "axs[1][1].set_title('Reference Image');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## See also\n", "\n", "- [Detailed look at Optimizer](https://mitsuba.readthedocs.io/en/latest/src/how_to_guides/use_optimizers.html)\n", "- [mitsuba.ad.Optimizer](https://mitsuba.readthedocs.io/en/latest/src/api_reference.html#mitsuba.ad.Optimizer)\n", "- [prb_reparam plugin](https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_integrators.html#reparameterized-path-replay-backpropagation-integrator-prb-reparam)\n", "- [direct_reparam plugin](https://mitsuba.readthedocs.io/en/latest/src/generated/plugins_integrators.html#reparameterized-direct-integrator-direct-reparam)" ] } ], "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.9.12" }, "vscode": { "interpreter": { "hash": "524ef5c892e16adde62d9febd56e921248026795a369fc4d8cb46b781ffa4996" } } }, "nbformat": 4, "nbformat_minor": 4 }