{ "cells": [ { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Dijkstra and Fast Marching Algorithms\n", "=====================================\n", "$\\newcommand{\\dotp}[2]{\\langle #1, #2 \\rangle}$\n", "$\\newcommand{\\enscond}[2]{\\lbrace #1, #2 \\rbrace}$\n", "$\\newcommand{\\pd}[2]{ \\frac{ \\partial #1}{\\partial #2} }$\n", "$\\newcommand{\\umin}[1]{\\underset{#1}{\\min}\\;}$\n", "$\\newcommand{\\umax}[1]{\\underset{#1}{\\max}\\;}$\n", "$\\newcommand{\\umin}[1]{\\underset{#1}{\\min}\\;}$\n", "$\\newcommand{\\uargmin}[1]{\\underset{#1}{argmin}\\;}$\n", "$\\newcommand{\\norm}[1]{\\|#1\\|}$\n", "$\\newcommand{\\abs}[1]{\\left|#1\\right|}$\n", "$\\newcommand{\\choice}[1]{ \\left\\{ \\begin{array}{l} #1 \\end{array} \\right. }$\n", "$\\newcommand{\\pa}[1]{\\left(#1\\right)}$\n", "$\\newcommand{\\diag}[1]{{diag}\\left( #1 \\right)}$\n", "$\\newcommand{\\qandq}{\\quad\\text{and}\\quad}$\n", "$\\newcommand{\\qwhereq}{\\quad\\text{where}\\quad}$\n", "$\\newcommand{\\qifq}{ \\quad \\text{if} \\quad }$\n", "$\\newcommand{\\qarrq}{ \\quad \\Longrightarrow \\quad }$\n", "$\\newcommand{\\ZZ}{\\mathbb{Z}}$\n", "$\\newcommand{\\CC}{\\mathbb{C}}$\n", "$\\newcommand{\\RR}{\\mathbb{R}}$\n", "$\\newcommand{\\EE}{\\mathbb{E}}$\n", "$\\newcommand{\\Zz}{\\mathcal{Z}}$\n", "$\\newcommand{\\Ww}{\\mathcal{W}}$\n", "$\\newcommand{\\Vv}{\\mathcal{V}}$\n", "$\\newcommand{\\Nn}{\\mathcal{N}}$\n", "$\\newcommand{\\NN}{\\mathcal{N}}$\n", "$\\newcommand{\\Hh}{\\mathcal{H}}$\n", "$\\newcommand{\\Bb}{\\mathcal{B}}$\n", "$\\newcommand{\\Ee}{\\mathcal{E}}$\n", "$\\newcommand{\\Cc}{\\mathcal{C}}$\n", "$\\newcommand{\\Gg}{\\mathcal{G}}$\n", "$\\newcommand{\\Ss}{\\mathcal{S}}$\n", "$\\newcommand{\\Pp}{\\mathcal{P}}$\n", "$\\newcommand{\\Ff}{\\mathcal{F}}$\n", "$\\newcommand{\\Xx}{\\mathcal{X}}$\n", "$\\newcommand{\\Mm}{\\mathcal{M}}$\n", "$\\newcommand{\\Ii}{\\mathcal{I}}$\n", "$\\newcommand{\\Dd}{\\mathcal{D}}$\n", "$\\newcommand{\\Ll}{\\mathcal{L}}$\n", "$\\newcommand{\\Tt}{\\mathcal{T}}$\n", "$\\newcommand{\\si}{\\sigma}$\n", "$\\newcommand{\\al}{\\alpha}$\n", "$\\newcommand{\\la}{\\lambda}$\n", "$\\newcommand{\\ga}{\\gamma}$\n", "$\\newcommand{\\Ga}{\\Gamma}$\n", "$\\newcommand{\\La}{\\Lambda}$\n", "$\\newcommand{\\si}{\\sigma}$\n", "$\\newcommand{\\Si}{\\Sigma}$\n", "$\\newcommand{\\be}{\\beta}$\n", "$\\newcommand{\\de}{\\delta}$\n", "$\\newcommand{\\De}{\\Delta}$\n", "$\\newcommand{\\phi}{\\varphi}$\n", "$\\newcommand{\\th}{\\theta}$\n", "$\\newcommand{\\om}{\\omega}$\n", "$\\newcommand{\\Om}{\\Omega}$\n" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "This numerical tours details the implementations\n", "of Dijkstra and Fast Marching algorithms in 2-D.\n", "\n", "\n", "The implementation are performed in Matlab, and are hence quite slow." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [], "source": [ "using PyPlot\n", "using NtToolBox" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Installation\n", "------------\n", "*Important:* Please read the [installation page](http://gpeyre.github.io/numerical-tours/installation_python/) for details about how to install the toolboxes." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Navigating on the Grid\n", "----------------------\n", "We use a cartesian grid of size $n \\times n$, and defines operators to navigate in the grid.\n", "\n", "\n", "We use a singe index $i \\in \\{1,\\ldots,n^2\\}$ to index a position on\n", "the 2-D grid.\n", "\n", "\n", "Size of the grid." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "n = 40;" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The four displacement vector to go to the four neightbors." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "neigh = [1 -1 0 0; 0 0 1 -1];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "For simplicity of implementation, we use periodic boundary conditions." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "text/plain": [ "(::#1) (generic function with 1 method)" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "boundary = x -> mod(x-1,n)+1" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "For a given grid index |k|, and a given neighboring index k in ${1,2,3,4}$,\n", "|Neigh(k,i)| gives the corresponding grid neighboring index." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "ind2sub1 = k -> Int.([rem(k-1, n)+1; (k - rem(k-1, n) - 1)/n + 1])\n", "sub2ind1 = u -> Int((u[2]-1)*n + u[1])\n", "Neigh = (k,i) -> sub2ind1(boundary(ind2sub1(k) + neigh[:,i]));" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Check that these functions are indeed bijections." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[13,27]\n", "134\n" ] } ], "source": [ "println( ind2sub1( sub2ind1([13, 27]) ) )\n", "println( sub2ind1( ind2sub1(134) ) )" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Dikstra Algorithm\n", "-----------------\n", "The Dijkstra algorithm compute the geodesic distance on a graph.\n", "We use here a graph whose nodes are the pixels, and whose edges defines the\n", "usual 4-connectity relationship.\n", "\n", "\n", "In the following, we use the notation $i \\sim j$ to indicate that an\n", "index $j$ is a neighbor of $i$ on the graph defined by the discrete\n", "grid.\n", "\n", "\n", "The metric $W(x)$. We use here a constant metric." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "W = ones( (n,n) );" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Set $\\Ss = \\{x_0\\}$ of initial points." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "x0 = [Base.div(n,2), Base.div(n,2)];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Initialize the stack of available indexes." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "I = [sub2ind1(x0)];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Initialize the distance to $+\\infty$, excepted for the boundary conditions." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "D = ones( n,n ) + Inf\n", "u = ind2sub1(I)\n", "D[u[1],u[2]] = 0;" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Initialize the state to 0 (unexplored), excepted for the boundary point $\\Ss$ (indexed by |I|)\n", "to $1$ (front)." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "S = zeros(n,n)\n", "S[u[1],u[2]] = 1;" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Define a callbabk to use a 1-D indexing on a 2-D array." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "extract = (x,I) -> x[I]\n", "extract1d = (x,I) -> extract(vec(x),I);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The first step of each iteration of the method is\n", "to pop the from stack the element $i$ with smallest current distance $D_i$." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "j = sortperm( extract1d(D,I) )\n", "if ndims(j)==0\n", " j = [j] # make sure that j is a list a not a singleton\n", "end\n", "j = j[1]\n", "i = I[j] \n", "a = deleteat!(I,j);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "We update its state $S$ to be dead (-1)." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "u = ind2sub1(i);\n", "S[u[1],u[2]] = -1;" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Retrieve the list of the neighbors that are not dead and add to I those that are not yet in it." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "J = [] \n", "for k in 1:4\n", " j = Neigh(i,k)\n", " if extract1d(S,j)!= -1\n", " # add to the list of point to update\n", " append!(J,j) \n", " if extract1d(S,j)==0\n", " # add to the front\n", " u = ind2sub1(j)\n", " S[u[1],u[2]] = 1\n", " append!(I,j)\n", " end\n", " end\n", "end" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "imageplot(S)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Update neighbor values.\n", "For each neightbo $j$ of $i$, perform the update,\n", "assuming the length of the edge between $j$ and $k$ is $W_j$.\n", "$$D_j \\leftarrow \\umin{k \\sim j} D_k + W_j.$$" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "DNeigh = (D,k) -> extract1d(D,Neigh(j,k))\n", "dx = 0; dy = 0; w = 0\n", "for j in J\n", " dx = min(DNeigh(D,1), DNeigh(D,2))\n", " dy = min(DNeigh(D,3), DNeigh(D,4))\n", " u = ind2sub1(j)\n", " w = extract1d(W,j);\n", " D[u[1],u[2]] = min(dx + w, dy + w)\n", "end" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 1__\n", "\n", "Implement the Dijkstra algorithm by iterating these step while the\n", "stack |I| is non empty.\n", "Display from time to time the front that propagates." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "include(\"NtSolutions/fastmarching_0_implementing/exo1.jl\")" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "## Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display the geodesic distance map using a cosine modulation to make the\n", "level set appears more clearly." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "displ = D -> cos(2*pi*5*D/maximum(D) )\n", "imageplot(displ(D))\n", "set_cmap(\"jet\")" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Fast Marching\n", "-------------\n", "The Dijstra algorithm suffers from a strong metrization problem, and it\n", "actually computes the $\\ell^1$ distance on the grid.\n", "\n", "\n", "The Fast Marching algorithm replace the graph update by a local\n", "resolution of the Eikonal equation. This reduces significantly the grid\n", "bias, and can be shown to converge to the underlying geodesic distance\n", "when the grid step size tends to zero.\n", "\n", "\n", "Over a continuous domain, the distance map $D(x)$ to a set of seed\n", "points $\\Ss$ is the unique solution in the viscosity sense\n", "$$\\forall x \\notin \\Ss, \\quad \\norm{\\nabla D(x)} = W(x)\n", " \\qandq\n", " \\forall y \\in \\Ss, \\quad D(y) = 0.$$\n", "\n", "\n", "The equation is then discretized on a grid of $n \\times n$ pixel, and a\n", "solution $(D_{k,\\ell})_{k,\\ell=1}^n \\in \\RR^{n \\times n}$ is found by using\n", "an upwind finite difference approximation, that is faithful to the\n", "viscosity solution\n", "$$\\forall (k,\\ell) \\notin \\tilde \\Ss, \\quad\n", " \\norm{ (\\nabla D)_{k,\\ell} } = W_{k,\\ell}\n", " \\qandq\n", " \\forall (k,\\ell) \\notin \\tilde \\Ss, \\quad D_{k,\\ell}=0,\n", "$$\n", "where $\\tilde \\Ss$ is the set of discrete starting points (defined here\n", "by |x0|).\n", "\n", "\n", "To be consisten with the viscosity solution, one needs to use a\n", "non-linear upwind gradient derivative. This corresponds to computing\n", "the norm of the gradient as\n", "$$\\norm{ (\\nabla D)_{k,\\ell} }^2 =\n", " \\max( D_{k+1,\\ell}-D_{k,\\ell}, D_{k-1,\\ell}-D_{k,\\ell}, 0 )^2 +\n", " \\max( D_{k,\\ell+1}-D_{k,\\ell}, D_{k,\\ell-1}-D_{k,\\ell}, 0 )^2.\n", "$$\n", "\n", "\n", "A each step of the FM propagation, one update $D_{k,\\ell} \\leftarrow d$\n", "by solving the eikonal equation with respect to $D_{k,\\ell}$ alone.\n", "This is equivalent to solving the quadratic equation\n", "$$(d-d_x)^2 + (d-d_y)^2 = w^2 \\qwhereq w=W_{k,\\ell}.$$\n", "and where\n", "$$d_x = \\min(D_{k+1,\\ell},D_{k-1,\\ell}) \\qandq\n", " d_y = \\min(D_{k,\\ell+1},D_{k,\\ell-1}).$$\n", "\n", "\n", "The update is thus defined as\n", "$$\n", " d = \\choice{\n", " \\frac{d_x+d_y+ \\sqrt{\\De}}{2} \\quad\\text{when}\\quad \\De \\geq 0, \\\\\n", " \\min(d_x,d_y)+w \\quad \\text{otherwise.}\n", " }\n", " \\qwhereq\n", " \\De = 2 w^2 - (d_x-d_y)^2.\n", "$$\n", "\n", "\n", "Note that in the case where $\\De<0$, one has to use the Dijkstra\n", "update.\n", "\n", "\n", "Once the Dijstra algorithm is implemented, the implementation of the Fast\n", "Marching is trivial. It just corresponds to replacing the graph udpate" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "D[u[1],u[2]] = min(dx + w, dy + w);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "by the eikonal update." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "Delta = 2*w - (dx-dy)^2\n", "if (Delta>=0)\n", " D[u[1],u[2]] = (dx + dy + sqrt(Delta))/ 2\n", "else\n", " D[u[1],u[2]] = min(dx + w, dy + w)\n", " end;" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 2__\n", "\n", "Implement the Fast Marching algorithm.\n", "Display from time to time the front that propagates." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "include(\"NtSolutions/fastmarching_0_implementing/exo2.jl\")" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "## Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display the geodesic distance map using a cosine modulation to make the\n", "level set appears more clearly." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "imageplot(displ(D))\n", "set_cmap(\"jet\")" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Computation of Geodesic Paths\n", "-----------------------------\n", "We use a more complicated, non-constant metric, with a bump in the\n", "middle." ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "n = 100\n", "x = collect(linspace(-1, 1, n))\n", "(Y, X) = meshgrid(x, x)\n", "sigma = .2\n", "W = 1 + 8 * exp(-(X.^2 + Y.^2) / (2*sigma^2));" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display it." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "imageplot(W)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Starting points." ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "x0 = Int.([round(.1*n); round(.1*n)]);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 3:__ \n", "\n", "Compute the distance map to these starting point using the FM algorithm. _Important:_ use symetric boundary conditions." ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "include(\"NtSolutions/fastmarching_0_implementing/exo3.jl\")" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "## Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Once the geodesic distance map to $\\Ss$\n", "has been computed, the geodesic curve between any point $x_1$ and $\\Ss$\n", "extracted through gradient descent\n", "$$\\ga'(t) = - \\eta_t \\nabla D(\\ga(t)) \\qandq \\ga(0)=x_1$$\n", "where $\\eta_t>0$ controls the parameterization speed of the resulting\n", "curve.\n", "\n", "\n", "To obtain unit speed parameterization, one can use $\\eta_t =\n", "\\norm{\\nabla D(\\ga(t))}^{-1}$ (one need to be careful when\n", "$\\ga$ approaches $\\Ss$ since $D$ is not smooth on $\\Ss$).\n", "\n", "\n", "Compute the gradient $G_0(x) = \\nabla D(x) \\in \\RR^2$ of the distance map.\n", "Use centered differences." ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "G0 = grad(D);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Normalize the gradient to obtained $G(x) = G_0(x)/\\norm{G_0(x)}$, in order to have unit speed geodesic curve (parameterized\n", "by arc length)." ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "d = sqrt(sum(G0.^2, 3))\n", "U = zeros(n,n,2)\n", "U[:,:,1] = d\n", "U[:,:,2] = d\n", "G = G0 ./ U;" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The geodesic is then numerically computed using a discretized gradient\n", "descent, which defines a discret curve $(\\ga_k)_k$ using\n", "$$\\ga_{k+1} = \\ga_k - \\tau G(\\ga_k)$$\n", "where $\\ga_k \\in \\RR^2$ is an approximation of $\\ga(t)$ at time\n", "$t=k\\tau$, and the step size $\\tau>0$ should be small enough.\n", "\n", "\n", "Step size $\\tau$ for the gradient descent." ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "tau = .8;" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Initialize the path with the ending point." ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "x1 = Int(round(.9*n)) + im*Int(round(.88*n))\n", "gamma = [x1];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Define a shortcut to interpolate $G$ at a 2-D points.\n", "_Warning:_ the |interp2| switches the role of the axis ..." ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "Geval = (G,x) -> bilinear_interpolate(G[:,:,1], imag(x), real(x) ) + im * bilinear_interpolate(G[:,:,2],imag(x), real(x));" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Compute the gradient at the last point in the path, using interpolation." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Perform the descent and add the new point to the path." ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "text/plain": [ "1×1 Array{Complex{Float64},2}:\n", " 0.32013+0.947373im" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g = Geval(G, gamma[end] )" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "append!(float(gamma), gamma[end] - tau*g);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 4__\n", "\n", "Perform the full geodesic path extraction by iterating the gradient\n", "descent. You must be very careful when the path become close to\n", "$x_0$, because the distance function is not differentiable at this\n", "point. You must stop the iteration when the path is close to $x_0$." ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "include(\"NtSolutions/fastmarching_0_implementing/exo4.jl\");" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "## Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display the geodesic curve." ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "imageplot(W) \n", "set_cmap(\"gray\")\n", "h = plot(imag(gamma), real(gamma), \".b\", linewidth=2)\n", "h = plot(x0[2], x0[1], \".r\", markersize=20)\n", "h = plot(imag(x1), real(x1), \".g\", markersize=20);" ] }, { "cell_type": "raw", "metadata": {}, "source": [ "" ] } ], "metadata": { "kernelspec": { "display_name": "Julia 0.5.0", "language": "julia", "name": "julia-0.5" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "0.5.0" } }, "nbformat": 4, "nbformat_minor": 1 }