{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# The HFM library - A fast marching solver with adaptive stencils\n", "\n", "## Part : Algorithmic enhancements to the fast marching method\n", "## Chapter : Geodesic computation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The fast marching method is a numerical scheme devoted to solving a Partial Differential Equation (PDE), the eikonal equation, which characterizes the arrival time of a front in a domain. In order to extract the corresponding minimal paths, a subsequent step is necessary, which involves solving an Ordinary Differential Equation (ODE). \n", "\n", "The HFM library and the Eikonal module offer state of the art implementations these two methods, written in C++ and cuda respectively. However, for pedagogical purposes, we also illustrate these tools with a Python implementation. The present notebook is devoted to geodesic computation, whereas the fast marching method is introduced in this other [notebook](../Notebooks_NonDiv/EikonalEulerian.ipynb)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[**Summary**](Summary.ipynb) of volume Fast Marching Methods, this series of notebooks.\n", "\n", "[**Main summary**](../Summary.ipynb) of the Adaptive Grid Discretizations \n", "\tbook of notebooks, including the other volumes.\n", "\n", "# Table of contents\n", " * [1. Theoretical tools](#1.-Theoretical-tools)\n", " * [1.1 Integrating the geodesic flow](#1.1-Integrating-the-geodesic-flow)\n", " * [1.2 Solving Hamilton's equations of motion](#1.2-Solving-Hamilton's-equations-of-motion)\n", " * [2. Isotropic metrics and the Brachistochrone problem](#2.-Isotropic-metrics-and-the-Brachistochrone-problem)\n", " * [2.1 Explicit solution: the cycloid.](#2.1-Explicit-solution:-the-cycloid.)\n", " * [2.2 Numerical solution using the fast marching method](#2.2-Numerical-solution-using-the-fast-marching-method)\n", " * [2.3 Solving Hamilton's equations of motion](#2.3-Solving-Hamilton's-equations-of-motion)\n", " * [2.4 Initial momentum from the PDE solution](#2.4-Initial-momentum-from-the-PDE-solution)\n", " * [2.5 The geodesic flow](#2.5-The-geodesic-flow)\n", " * [3. Riemannian metrics, and the fastest slide on a landscape](#3.-Riemannian-metrics,-and-the-fastest-slide-on-a-landscape)\n", " * [3.1 Numerical solution using the fast-marching method](#3.1-Numerical-solution-using-the-fast-marching-method)\n", " * [3.2 Integrating the flow](#3.2-Integrating-the-flow)\n", " * [3.3 Geodesic shooting](#3.3-Geodesic-shooting)\n", "\n", "\n", "\n", "This Python® notebook is intended as documentation and testing for the [HamiltonFastMarching (HFM) library](https://github.com/mirebeau/HamiltonFastMarching), which also has interfaces to the Matlab® and Mathematica® languages. \n", "More information on the HFM library in the manuscript:\n", "* Jean-Marie Mirebeau, Jorg Portegies, \"Hamiltonian Fast Marching: A numerical solver for anisotropic and non-holonomic eikonal PDEs\", 2019 [(link)](https://hal.archives-ouvertes.fr/hal-01778322)\n", "\n", "Copyright Jean-Marie Mirebeau, University Paris-Sud, CNRS, University Paris-Saclay" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 0. Importing the required libraries" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:32.919508Z", "iopub.status.busy": "2024-04-30T09:14:32.919098Z", "iopub.status.idle": "2024-04-30T09:14:32.929037Z", "shell.execute_reply": "2024-04-30T09:14:32.928238Z" } }, "outputs": [], "source": [ "import sys; sys.path.insert(0,\"..\") # Allow import of agd from parent directory (useless if conda package installed)\n", "#from Miscellaneous import TocTools; print(TocTools.displayTOC('HamiltonianShooting','FMM'))" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:32.932328Z", "iopub.status.busy": "2024-04-30T09:14:32.932030Z", "iopub.status.idle": "2024-04-30T09:14:33.187026Z", "shell.execute_reply": "2024-04-30T09:14:33.186632Z" } }, "outputs": [], "source": [ "from agd import Eikonal\n", "from agd import LinearParallel as lp\n", "from agd import Metrics\n", "from agd.ODE.hamiltonian import GenericHamiltonian,MetricHamiltonian\n", "from agd import AutomaticDifferentiation as ad\n", "from agd import FiniteDifferences as fd\n", "from agd.Plotting import savefig; #savefig.dirName = 'Images/HamiltonianShooting'\n", "from agd import Interpolation\n", "\n", "norm_infinity = ad.Optimization.norm_infinity\n", "Interp = Interpolation.UniformGridInterpolation" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:33.188710Z", "iopub.status.busy": "2024-04-30T09:14:33.188590Z", "iopub.status.idle": "2024-04-30T09:14:33.279998Z", "shell.execute_reply": "2024-04-30T09:14:33.279696Z" } }, "outputs": [], "source": [ "import numpy as np\n", "import scipy.integrate\n", "from matplotlib import pyplot as plt" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:33.281718Z", "iopub.status.busy": "2024-04-30T09:14:33.281606Z", "iopub.status.idle": "2024-04-30T09:14:33.284260Z", "shell.execute_reply": "2024-04-30T09:14:33.284030Z" } }, "outputs": [], "source": [ "def reshape_input_flatten_output(f,vdim):\n", " return lambda q,*args,**kwargs : f(q.reshape((vdim,q.size//vdim)),*args,**kwargs).flatten()\n", "\n", "def add_patches(hfmIn):\n", " \"\"\"Draws a bounding rectangle, and scatters the seeds\"\"\"\n", " plt.gca().add_patch(plt.Rectangle(hfmIn['origin'],*(hfmIn['dims']*hfmIn['gridScale']),\n", " linewidth=1,edgecolor='black',facecolor='none'))\n", " plt.gca().add_patch(plt.Circle(np.array(hfmIn['seeds']).T,3*hfmIn['gridScale']))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:33.285651Z", "iopub.status.busy": "2024-04-30T09:14:33.285573Z", "iopub.status.idle": "2024-04-30T09:14:33.287548Z", "shell.execute_reply": "2024-04-30T09:14:33.287303Z" } }, "outputs": [], "source": [ "def reload_packages():\n", " from Miscellaneous.rreload import rreload\n", " global ad,lp,fd,Metrics,Interp,GenericHamiltonian,MetricHamiltonian\n", " ad,lp,fd,Metrics,Interp,GenericHamiltonian,MetricHamiltonian = rreload([ad,lp,fd,Metrics,Interp,GenericHamiltonian,MetricHamiltonian],rootdir=\"../..\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 0.1 Optional configuration\n", "Uncomment the following line to use the GPU eikonal solver. (Comment it for the CPU eikonal solver.)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "editable": true, "execution": { "iopub.execute_input": "2024-04-30T09:14:33.288825Z", "iopub.status.busy": "2024-04-30T09:14:33.288710Z", "iopub.status.idle": "2024-04-30T09:14:33.290304Z", "shell.execute_reply": "2024-04-30T09:14:33.290080Z" }, "slideshow": { "slide_type": "" }, "tags": [ "EikonalGPU_config" ] }, "outputs": [], "source": [ "#Eikonal.dictIn.default_mode = 'gpu_transfer'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Theoretical tools\n", "\n", "In order to define minimal path problem, one needs several ingredients.\n", "Consider a domain $\\Omega \\subset R^d$, and a metric $F : \\Omega \\times R^d \\to R_+$ denoted\n", "$$\n", " (q,v) \\mapsto F_q(v).\n", "$$\n", "Assume that $F$ is $1$-homogeneous, convex, and definite (vanishes only at the origin) w.r.t. the second variable.\n", "\n", "Let also $q_* \\in \\Omega$, referred to as the seed point, and define $u : \\Omega \\to R$ as the length of the shortest path from $q_*$ to any given point, w.r.t. the metric. For any $q \\in \\Omega$\n", "$$\n", " u(q) := \\min_{\\gamma \\in \\Gamma( q_* , q) } \\int_0^1 F_{\\gamma(t)}(\\gamma'(t)) \\mathrm{d}t.\n", "$$\n", "We denoted by $\\Gamma(q_0,q_1)$ the collection of all paths $\\gamma : [0,1] \\to \\Omega$ with Lipschitz regularity and such that $\\gamma(0) = q_0$ and $\\gamma(1)=q_1$.\n", "\n", "It is known that $u$ is the unique viscosity solution to the eikonal equation\n", "$$\n", " F_q^*(\\nabla u(q)) = 1\n", "$$\n", "for all $q \\in \\Omega\\setminus\\{q_*\\}$, with $u(q_*)=0$ and outflow boundary conditions on $\\partial \\Omega$. We denoted by $F_q^*$ the dual metric, defined by \n", "$$\n", " F_q^*(p) := \\sup\\{
; F_q(v)\\leq 1\\}.\n", "$$\n", "Solving the eikonal equation is the purpose of a PDE solver, such as the fast marching method, see [notebook](../Notebooks_NonDiv/EikonalEulerian.ipynb). In this notebook, we assume that $u$ has already been numerically computed, and that one would like to find the minimal geodesic path from the seed $q_*$ to a given $q \\in \\Omega$.\n", "\n", "Two approaches can be considered:\n", "* Integrating the geodesic flow, which is a sort of gradient descent of the function $u$ distorted by the metric. This is the most robust method, in particular in the presence of obstacles, and a variant of it is implemented in the HFM library.\n", "* Solving Hamilton's equations of motion, with an initial momentum proportional to $\\nabla u(q)$. The originality of this ODE is that it is completely autonomous: the solution $u$ to the eikonal equation is only used to provide the initial condition.\n", "\n", "We describe these approaches in more detail below, and prepare some tools needed for the implementation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1 Integrating the geodesic flow\n", "\n", "This approach to geodesic computation is based on the observation that geodesics follow the direction of greatest slope of the value function, w.r.t the metric.\n", "More precisely, the geodesic $\\gamma$ from a seed $q_*$ to a given tip $q$, parametrized at constant speed w.r.t the metric, obeys the ordinary differential equation\n", "$$\n", " \\gamma'(t) = V(\\gamma(t)), \n", "$$\n", "with terminal condition $\\gamma(T) = q$. \n", "We denoted by $T = u(q)$ is the geodesic distance from the seed $q_*$ to the tip $q$, and by $V : \\Omega \\to R^d$ the geodesic flow, gradient of the distance *w.r.t the metric*. In the Riemannian case\n", "$$\n", " V(q) = M(q)^{-1} \\nabla u(q),\n", "$$\n", "where $\\nabla$ denotes the usual Euclidean gradient. The fast marching algorithm produces, as a byproduct, an upwind approximation of this vector field.\n", "We illustrate below a such an approach for geodesic computation. \n", "\n", "**Note on the HFM implementation.**\n", "The implementations of geodesic computation presented below and in the HFM library are related but also have significant differences. The HFM implementation only uses a first order interpolation of the flow, but has mechanisms designed to improve robustness in the presence of obstacles, and for problems whose distance maps are discontinuous (e.g. [Dubins model](Curvature.ipynb)), etc. It also has different stopping criteria.\n", "\n", "**Note on interpolation of $V$ and regularity.**\n", "The geodesic flow $V : \\Omega \\to R^d$ and the value function $u:\\Omega \\to R^d$ have a singularity at the seed $q_*$. In order to extend $V$ from the computation grid to the domain, the function below uses the quotient \n", "$$\n", " I(u V)/\\sqrt{I(u^2)}\n", "$$\n", "of the interpolations of $uV$ and $u^2$. Let us explain why $u^2$ and $u V$ are good candidates for interpolation. \n", "\n", "The squared distance $u^2$ is smooth, far from the cut-locus, in the absence of obstacles, and when the metric is Riemannian. This follows from the expression (notice the squares)\n", "$$\n", " u(q)^2 = \\min_{\\gamma \\in \\Gamma(q_*,q)} \\int_0^1 F_{\\gamma(t)}(\\gamma'(t))^2 \\mathrm{d} t\n", "$$\n", "which has better properties that the above definition of $q$ (without squares). E.g. the lack of invariance to reparametrization (so that there is a unique minimizer) and the smoothness of $v\\mapsto F_q(v)^2$ (when $F$ is a Riemannian metric).\n", "\n", "Likewise, the product $u V$ of the flow times the distance to the seed point $u : \\Omega \\to R_+$ is smooth, under the same assumptions. Indeed, it is the gradient of the path energy $u^2$, which is smooth, see the next section. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:33.291578Z", "iopub.status.busy": "2024-04-30T09:14:33.291485Z", "iopub.status.idle": "2024-04-30T09:14:33.293813Z", "shell.execute_reply": "2024-04-30T09:14:33.293572Z" } }, "outputs": [], "source": [ "def value_flow_i(hfmIn,hfmOut,**kwargs):\n", " \"\"\"Returns the distance to the seed, and the upwind geodesic flow, interpolated.\"\"\"\n", " grid = hfmIn.Grid()\n", " value = hfmOut['values']\n", " flow = hfmOut['flow']\n", " \n", " flowXvalue_i = Interp(grid, flow*value,**kwargs)\n", " valueXvalue_i = Interp(grid,value*value,**kwargs)\n", " \n", " def value_i(q): return np.sqrt(np.maximum(0.,valueXvalue_i(q)))\n", " def flow_i(q,t=None,mult=1): return mult*flowXvalue_i(q)/value_i(q)\n", " \n", " return value_i,flow_i" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Possible improvements.**\n", "Some numerical methods use the path computed by the above numerical method as a first guess, which is then improve to reduce length and more closely satisfy Hamilton's equations of motion using e.g. a homotopy method (small deformations of the path)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2 Solving Hamilton's equations of motion\n", "\n", "The hamiltonian associated to a (minimal) geodesic problem reads \n", "$$\n", " H(q,p) := \\frac 1 2 F_q^*(p)^2,\n", "$$\n", "where $F^*$ is the dual metric, see above. It is known that geodesics obey Hamilton's equations of motion\n", "$$\n", " \\frac {dq}{dt} = \\frac {\\partial H}{\\partial p}, \\quad \\frac {dp}{dt} = -\\frac {\\partial H}{\\partial q},\n", "$$\n", "where $q(t) = \\gamma(t)$ is the geodesic path, and $p(t) = \\eta(t)$ is the impulsion which can also be regarded as an optimal control. \n", "\n", "**Initial momentum**\n", "Hamilton's equations are autonomous ODEs, and are also considered in this [notebook on dense automatic differentiation](../Notebooks_Algo/Dense.ipynb), and this [notebook on the wave equation](../Notebooks_Div/Time1D_Div.ipynb). In the context of minimal geodesic computation, from a seed $q_*$ to a given point $q$, the difficulty lies in finding the correct initial momentum, or final momentum if the equation is solved backwards in time.\n", "\n", "For that purpose, the numerical solution of the eikonal PDE provides valuable information. Indeed, one shows that the adequate final momentum is precisely\n", "$$\n", " p = \\nabla U(q),\n", "$$\n", "where $U = \\frac 1 2 u^2$ and $u: \\Omega \\to R_+$ is the distance map from the seed $q_*$. If the terminal condition is $(q,\\nabla U(q))$ at time $t=1$, for some $q\\in \\Omega$ the the geodesic goes through the seed $q_*$ at time $t=0$. The quantity $U(q)$ is often referred to as the energy of the minimal path from $q_*$ to $q\\in \\Omega$.\n", "\n", "As discussed in the previous section, $U$ is smooth far from the cut-locus, including at the seed point, under suitable assumptions (Riemannian metric, without obstacles). It is therefore a good candidate for interpolation.\n", "\n", "**Limitation.** This approach only works if the Riemannian geodesic between the seed and tip remains in the computational domain interior at all times, and does not meet any obstacles." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:33.295221Z", "iopub.status.busy": "2024-04-30T09:14:33.295139Z", "iopub.status.idle": "2024-04-30T09:14:33.297290Z", "shell.execute_reply": "2024-04-30T09:14:33.297074Z" } }, "outputs": [], "source": [ "def energy_impulsion_i(hfmIn,hfmOut,**kwargs):\n", " \"\"\"Returns the energy x -> u(x)^2/2, and its euclidean gradient referred to as the impulsion, interpolated.\"\"\"\n", " grid = hfmIn.Grid()\n", " values = hfmOut['values']\n", " \n", " energy_i = Interp(grid,0.5*values**2,**kwargs)\n", " \n", " def impulsion_i(q):\n", " q_ad = ad.Dense.identity(constant=q,shape_free=q.shape[:1])\n", " return energy_i(q_ad).gradient()\n", " \n", " return energy_i,impulsion_i" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Possible improvement.**\n", "In practical applications, the final momentum $p=\\nabla U(q)$ extracted from the numerical solution to the eikonal equation, is usually only used as a first guess. An iterative optimization method refines this guess afterwards.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Isotropic metrics and the Brachistochrone problem\n", "\n", "A brachistochrone curve, in mathematics and physics, is a curve of fastest descent, between two points in a uniform gravity field, and neglecting friction. The standard brachistochrone problem assumes that the curve can be constructed without constraints in free space and admits an explicit solution: the cycloid. See [Wikipedia](https://en.wikipedia.org/wiki/Brachistochrone_curve).\n", "\n", "In this section, we recover this explicit solution numerically.\n", "Consider a point of mass $m$, at altitude $h$, with velocity $v$, and denote by $g$ the intensity of the gravity field. The total energy (kinetic + potential) of this point is \n", "$$\n", " E = m g h + \\frac 1 2 m \\|v\\|^2,\n", "$$\n", "and it is conserved along the motion, provided there is no friction.\n", "\n", "For simplicity, but without loss of generality, we assume that $m = 1$ and $g=1$, and denote $z = -h$. Up to a vertical translation, we may also assume that the conserved energy equals zero. Then we obtain $-z+\\frac 1 2 \\|v\\|^2=0$, equivalently\n", "$$\n", " \\frac {\\|v\\|^2}{2 z} = 1.\n", "$$\n", "Thus the brachistochrone problem amounts to find a geodesic, between two given points, for an isotropic metric whose (half squared) expression is given above. More explicitly, denoting by $q=(x,z)$ the position, and $v$ the speed\n", "$$\n", " F_q(v) := \\frac {\\|v\\|}{\\sqrt z}.\n", "$$\n", "The matrix form, the Riemannian metric at $q=(x,z) \\in R \\times R_{++}$ reads\n", "$$\n", " M(q) = M(x,z) = \\frac {\\mathrm{Id}} z.\n", "$$\n", "\n", "**A closely related model.** The Poincare model of the hyperbolic plane is posed on the same domain $R\\times R_{+++}$ and involves the metric $M(x,z) = \\mathrm{Id} / {z^2}$ (note the square in the denominator). One significant difference is that the Poincare model is geodesically complete, whereas the Brachistochrone model isn't (geodesics reach the boundary $R \\times \\{0\\}$ in finite time).\n", "The Poincare half plane model naturally arises in the context of [Fisher-Rao metrics](FisherRao.ipynb)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.1 Explicit solution: the cycloid.\n", "An explicit geodesic is known for the brachistochrone metric, known as the cycloid, see [Wikipedia](https://en.wikipedia.org/wiki/Brachistochrone_curve), and reading\n", "$$\n", " (x(t),z(t)) = (t-\\sin t, 1-\\cos t),\n", "$$\n", "for $t \\in ]0,2 \\pi[$.\n", "All other geodesics are dilations and horizontal translations of this particular solution $\\gamma(t)=(x(t),z(t))$\n", "$$\n", " \\lambda \\gamma(t/\\lambda) + (x_0,0),\n", "$$\n", "where $\\lambda>0$ and $x_0 \\in R$." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:33.298772Z", "iopub.status.busy": "2024-04-30T09:14:33.298695Z", "iopub.status.idle": "2024-04-30T09:14:33.300467Z", "shell.execute_reply": "2024-04-30T09:14:33.300258Z" } }, "outputs": [], "source": [ "def Cycloid(t): return ad.array((t-np.sin(t),1.-np.cos(t)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note : recall that the vertical axis is reversed, a.k.a. $z=-h$, w.r.t the physical brachistochrone problem." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2024-04-30T09:14:33.301836Z", "iopub.status.busy": "2024-04-30T09:14:33.301751Z", "iopub.status.idle": "2024-04-30T09:14:33.389839Z", "shell.execute_reply": "2024-04-30T09:14:33.389552Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "