From 83d2e352dc3c2fca656d374ddc531eee420d9e2a Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Sun, 16 Mar 2025 20:48:27 +0100 Subject: [PATCH 01/11] POC --- arclength_interpolation.ipynb | 1531 +++++++++++++++++++++++++++++++++ src/DataInterpolations.jl | 4 +- src/derivatives.jl | 34 + src/interpolation_caches.jl | 258 ++++++ src/interpolation_methods.jl | 37 + src/interpolation_utils.jl | 5 + 6 files changed, 1867 insertions(+), 2 deletions(-) create mode 100644 arclength_interpolation.ipynb diff --git a/arclength_interpolation.ipynb b/arclength_interpolation.ipynb new file mode 100644 index 00000000..536b5ce3 --- /dev/null +++ b/arclength_interpolation.ipynb @@ -0,0 +1,1531 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Smooth arclength interpolation\n", + "\n", + "## The problem\n", + "\n", + "Say we have an ordered set of points $u_1, \\ldots, u_n \\in \\mathbb{R}^N$ and we want to make a lightweight $C^1$ smooth interpolation by arc-length $\\tilde{\\gamma}: [0,T] \\rightarrow \\mathbb{R}^N$ through these points. The first part is easy, just pick your favorite established interpolation method that achieves $C^1$ smoothness. The arc-length part however turns out to be quite [nasty](https://ijpam.eu/contents/2006-31-3/10/10.pdf). Here I propose a method that is quite general (the linked article only considers curves in $\\mathbb{R}^2$), and cheap to compute. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The 2-dimensional case\n", + "\n", + "2 is the smallest number of dimensions in which the posed problem is non-trivial. Say we use an established (non arc-length) interpolation method for our set of points to obtain the $C^1$ curve\n", + "\n", + "$$\n", + " \\gamma : [0, T] \\rightarrow \\mathbb{R}^2\n", + "$$\n", + "\n", + "for which \n", + "\n", + "$$\n", + " \\gamma(t_i) = u_i \\quad i = 1, \\ldots, n,\n", + "$$\n", + "\n", + "given a suitable set of 'time' values \n", + "\n", + "$$\n", + " 0 = t_1 < t_2 < \\ldots < t_n = T,\n", + "$$\n", + "\n", + "for instance\n", + "\n", + "$$\n", + " t_i = \\sum_{k=1}^{i-1} \\|u_{k+1} - u_k\\|_2.\n", + "$$\n", + "\n", + "We now want to approximate $\\gamma$ piecewise with sections that are trivially parameterizable by arc-length, namely line segments and circle segments. To do this, we fix some $m \\in \\mathbb{N}$ and define a refined set of time points $\\left(\\tilde{t}_j\\right)_{j=1}^{m(n-1) + 1}$ given by\n", + "\n", + "$$\n", + " \\tilde{t}_{m(k-1) + l} = t_k + \\frac{l}{m + 1}(t_{k+1} - t_k), \\quad k = 1 \\ldots n-1, \\; l = 1, \\ldots m.\n", + "$$\n", + "\n", + "In these refined time points we evaluate $\\gamma$ and its normalized derivative:\n", + "\n", + "$$\n", + " \\tilde{u}_j = \\gamma\\left(\\tilde{t}_j\\right), \\; \\tilde{d}_j = \\frac{\\dot{\\gamma}\\left(\\tilde{t}_j\\right)}{\\|\\dot{\\gamma}\\left(\\tilde{t}_j\\right)\\|_2}, \\qquad j = 1, \\ldots, m(n-1) + 1.\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a first step to create the interpolation by arc length $\\tilde{\\gamma}$, we make a piecewise linear curve which is tangent to $\\gamma$ in $\\tilde{u}_j$ for each line segment, where we denote the intersection of consecutive tangent lines by $\\tilde{u}_{j, \\text{int}}$:\n", + "\n", + "$$\n", + " \\begin{align*}\n", + " \\tilde{u}_{j, \\text{int}} &=& \\tilde{u}_j + \\frac{\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_j \\\\\n", + " &=& \\tilde{u}_{j+1} + \\frac{\\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_{j+1}.\n", + " \\end{align*}\n", + "$$\n", + "\n", + "As expected this doesn't work for $\\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2 = 1$, which means that the consecutive tangent lines are parallel. In fact, in the above equation we want the coefficient of $\\tilde{d}_j$ to be positive and the coefficient of $\\tilde{d}_{j+1}$ to be negative, to ensure that $\\tilde{u}_{j, \\text{int}}$ lies properly in between $\\tilde{u}_j$ and $\\tilde{u}_{j+1}$." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "using DataInterpolations\n", + "using Plots\n", + "using Random\n", + "using LinearAlgebra\n", + "\n", + "Random.seed!(4)\n", + "\n", + "n = 4\n", + "m = 2\n", + "u = [rand(2) for _ in 1:n]\n", + "t = cumsum(norm.(diff(u)))\n", + "pushfirst!(t, 0)\n", + "\n", + "γ = QuadraticSpline(u, t)\n", + "\n", + "t_eval = range(first(t), last(t), length = 250)\n", + "u_eval = hcat(γ.(t_eval)...)\n", + "\n", + "t_tilde = zeros(m * (n - 1) + 1)\n", + "\n", + "for k in 1:(n-1)\n", + " t_tilde[m * (k - 1) + 1 : m * k] = range(t[k], t[k+1], length = m + 1)[1:(end - 1)]\n", + "end\n", + "\n", + "t_tilde[end] = t[end]\n", + "u_tilde = hcat(γ.(t_tilde)...)\n", + "\n", + "d_tilde = DataInterpolations.derivative.(Ref(γ), t_tilde)\n", + "normalize!.(d_tilde)\n", + "d_tilde = hcat(d_tilde...)\n", + "\n", + "n_intervals = length(t_tilde) - 1\n", + "intersection_points = zeros(2, n_intervals)\n", + "\n", + "u_tilde_j_int_1 = zeros(2)\n", + "u_tilde_j_int_2 = zeros(2)\n", + "\n", + "for j in 1:n_intervals\n", + " d_tilde_j = view(d_tilde, :, j)\n", + " d_tilde_j_plus_1 = view(d_tilde, :, j + 1)\n", + " d_inner = dot(d_tilde_j, d_tilde_j_plus_1)\n", + " u_tilde_j = view(u_tilde, :, j)\n", + " u_tilde_j_plus_1 = view(u_tilde, :, j + 1)\n", + " Δu = u_tilde_j_plus_1 - u_tilde_j\n", + "\n", + " coef_1 = (dot(Δu, d_tilde_j) - d_inner * dot(Δu, d_tilde_j_plus_1))/(1 - d_inner^2)\n", + " coef_2 = (d_inner * dot(Δu, d_tilde_j) - dot(Δu, d_tilde_j_plus_1))/(1 - d_inner^2)\n", + "\n", + " @. u_tilde_j_int_1 = u_tilde_j + coef_1 * d_tilde_j\n", + " @. u_tilde_j_int_2 = u_tilde_j_plus_1 + coef_2 * d_tilde_j_plus_1\n", + " @assert u_tilde_j_int_1 ≈ u_tilde_j_int_2\n", + "\n", + " intersection_points[:, j] .= u_tilde_j_int_1\n", + "end\n", + "\n", + "function plot_tangent_curve()\n", + " p = plot(; aspect_ratio = :equal, legend = :topleft, title = \"m = $m\")\n", + " \n", + " # Plot curve γ\n", + " plot!(u_eval[1,:], u_eval[2,:]; label = raw\"\\gamma\")\n", + "\n", + " # Plot original points\n", + " u_ = hcat(u...)\n", + " scatter!(u_[1,:], u_[2,:], label = raw\"$u_i$\"; markersize = 6, markerstrokewidth = 0)\n", + "\n", + " # Plot refined evaluation points\n", + " scatter!(u_tilde[1,:], u_tilde[2,:]; label = raw\"$\\tilde{u}_j$\", markerstrokewidth = 0)\n", + "\n", + " # Plot tangent curve\n", + " scatter!(intersection_points[1, :], intersection_points[2, :]; \n", + " markerstrokewidth = 0, markersize = 3, label = raw\"$\\tilde{u}_{j, int}$\")\n", + " plot!([u_tilde[1, 1], intersection_points[1, :]..., u_tilde[1, end]], \n", + " [u_tilde[2, 1], intersection_points[2, :]..., u_tilde[2, end]]; \n", + " label = \"Tangent curve\")\n", + " # xlims!(0,1)\n", + " # ylims!(0,1)\n", + " p\n", + "end\n", + "\n", + "plot_tangent_curve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a last step to obtain our curve by arc length $\\tilde{\\gamma}$ we want to get rid of the kinks in the tangent curve. We do this by replacing sections of the tangent curve by circle arcs. For each $\\tilde{u}_{j, \\text{int}}$ we compute the shortest distance to the neighboring evaluation points on $\\gamma$:\n", + "\n", + "$$\n", + " \\delta_j = \\min\\left\\{\n", + " \\|\\tilde{u}_j - \\tilde{u}_{j, \\text{int}}\\|_2, \n", + " \\|\\tilde{u}_{j + 1} - \\tilde{u}_{j, \\text{int}}\\|_2\n", + " \\right\\}.\n", + "$$\n", + "\n", + "From this we compute 2 points that are on the tangent curve and equidistant from $\\tilde{u}_{j + \\frac{1}{2}}$:\n", + "\n", + "$$\n", + " \\tilde{u}_{j, \\text{start}} = \\tilde{u}_{j, \\text{int}} - \\delta_j \\tilde{d}_j, \n", + "$$\n", + "\n", + "$$\n", + " \\tilde{u}_{j, \\text{end}} = \\tilde{u}_{j, \\text{int}} + \\delta_j \\tilde{d}_{j+1}.\n", + "$$\n", + "\n", + "Note that by this definition\n", + "\n", + "$$\n", + " \\tilde{u}_{j, \\text{start}} = \\tilde{u}_j \\quad \\vee \\quad \\tilde{u}_{j, \\text{end}} = \\tilde{u}_{j + 1}.\n", + "$$\n", + "\n", + "Now we can define a circle arc from $\\tilde{u}_{j, \\text{start}}$ to $\\tilde{u}_{j, \\text{end}}$ given the center\n", + "\n", + "$$\n", + " c_j = \\tilde{u}_{j, \\text{int}} + \\delta_j\\frac{\\tilde{d}_{j+1} - \\tilde{d}_j}{1 - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle}\n", + "$$\n", + "\n", + "and radius\n", + "\n", + "$$\n", + " R_j = \\delta_j\\sqrt{\\frac{1 + \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle}}.\n", + "$$\n", + "\n", + "We obtain the circle arc\n", + "\n", + "$$\n", + " c_j + \\cos\\left(\\frac{t}{R_j}\\right)v_{j, 1} + \\sin\\left(\\frac{t}{R_j}\\right)v_{j, 2}, \\quad t \\in [0, \\Delta t_{j, \\text{arc}}],\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + " v_{j, 1} = -\\delta_j \\frac{\\tilde{d}_{j+1} - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle\\tilde{d}_j}{1 - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle},\n", + " \\quad\n", + " v_{j, 2} = R_j \\tilde{d}_j.\n", + "$$\n", + "\n", + "By this definition $\\|v_{j, 1}\\|_2 = \\|v_{j, 2}\\|_2 = R_j$ and $\\langle v_{j, 1}, v_{j, 2}\\rangle = 0$. Furthermore:\n", + "\n", + "$$\n", + " \\Delta t_{j, \\text{arc}} = R_j\\theta_{j, \\;\\max}= 2R_j \\arctan\\left(\\frac{\\delta_j}{R_j}\\right).\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "function mark_right_angle!(corner, dir1, dir2; l = 0.05)\n", + " points = zeros(3, 2)\n", + " points[1, :] = corner + l * dir1\n", + " points[2, :] = points[1, :] + l * dir2\n", + " points[3, :] = points[2, :] - l * dir1\n", + " \n", + " plot!(points[:, 1], points[:, 2]; color = :black, label = \"\")\n", + "end\n", + "\n", + "function plot_arc_construction(; indicate_delta = true)\n", + " p = plot(; aspect_ratio = :equal, axis = false)\n", + "\n", + " tu_j = [0.0, 0.2]\n", + " tu_j_int = [0.5, 0.6]\n", + " tu_j_plus_1 = [1.2, 0.3]\n", + " δⱼ = norm(tu_j_int - tu_j)\n", + " tu_j_start = tu_j\n", + " tu_j_end = tu_j_int + δⱼ * (tu_j_plus_1 - tu_j_int) / norm(tu_j_plus_1 - tu_j_int)\n", + "\n", + " td_j = tu_j_int - tu_j\n", + " normalize!(td_j)\n", + " td_j_plus_1 = tu_j_plus_1 - tu_j_int\n", + " normalize!(td_j_plus_1)\n", + " inner = dot(td_j, td_j_plus_1)\n", + " Δtd_j = td_j_plus_1 - td_j\n", + "\n", + " tc_j = tu_j_int + δⱼ / (1 - inner) * Δtd_j\n", + "\n", + " Rⱼ = δⱼ * sqrt((1 + inner)/(1 - inner))\n", + " vⱼ₁ = -δⱼ * (td_j_plus_1 - inner * td_j)/(1 - inner)\n", + " vⱼ₂ = Rⱼ * td_j\n", + " Δt_j_arc = 2 * Rⱼ * atan(δⱼ, Rⱼ)\n", + "\n", + " T_ = range(0, π/2; length = 100)\n", + " x_arc = @. tc_j[1] + cos(T_) * vⱼ₁[1] + sin(T_) * vⱼ₂[1]\n", + " y_arc = @. tc_j[2] + cos(T_) * vⱼ₁[2] + sin(T_) * vⱼ₂[2]\n", + " plot!(x_arc, y_arc; label = \"\", color = :gray, ls = :dash)\n", + " \n", + " T = range(0, Δt_j_arc, length = 100)\n", + " X_arc = @. tc_j[1] + cos(T/Rⱼ) * vⱼ₁[1] + sin(T/Rⱼ) * vⱼ₂[1]\n", + " Y_arc = @. tc_j[2] + cos(T/Rⱼ) * vⱼ₁[2] + sin(T/Rⱼ) * vⱼ₂[2]\n", + " plot!(X_arc, Y_arc; label = \"\", color = :black, linewidth = 2)\n", + "\n", + " x_arc = @. tc_j[1] + cos(T/Rⱼ) * vⱼ₁[1] / 7 + sin(T/Rⱼ) * vⱼ₂[1] / 7\n", + " y_arc = @. tc_j[2] + cos(T/Rⱼ) * vⱼ₁[2] / 7 + sin(T/Rⱼ) * vⱼ₂[2] / 7\n", + " plot!(x_arc, y_arc; label = \"\", color = :black)\n", + "\n", + " z = tc_j + vⱼ₂\n", + "\n", + " annotate!(tu_j..., \"\\n\\n\\n\" * raw\"$\\tilde{u}_j = \\tilde{u}_{j, \\mathrm{start}}$\")\n", + " annotate!(tu_j_int..., raw\"$\\tilde{u}_{j, \\mathrm{int}}$\" * \"\\n\\n\\n\")\n", + " annotate!(tu_j_end..., raw\"$\\tilde{u}_{j, \\mathrm{end}}$\" * \"\\n\\n\\n\")\n", + " annotate!(tu_j_plus_1..., \"\\n\\n\\n\" * raw\"$\\tilde{u}_{j + 1}$\")\n", + " annotate!((tu_j + td_j/5)..., raw\"$\\tilde{d}_j$\" * \" \")\n", + " annotate!((tu_j_plus_1 + td_j_plus_1/5)..., raw\"$\\tilde{d}_{j+1}$\" * \"\\n\\n\")\n", + " annotate!(tc_j..., \" \" * raw\"$\\tilde{c}_j$\")\n", + " annotate!(tc_j + vⱼ₁/2..., raw\"$v_{j,1}$\" * \" \")\n", + " annotate!(tc_j + vⱼ₂/2..., \"\\n \" * raw\"$v_{j,2}$\")\n", + " annotate!(tc_j..., raw\"$\\theta_{j, \\max}$\" * \" \\n\\n\\n\\n\\n\")\n", + " indicate_delta && annotate!((tu_j + tu_j_int)/2..., raw\"$\\delta_j$\" * \"\\n\\n\")\n", + "\n", + " mark_right_angle!(tu_j_start, td_j, normalize(tc_j - tu_j_start))\n", + " mark_right_angle!(tu_j_end, td_j_plus_1, normalize(tc_j - tu_j_end))\n", + " mark_right_angle!(tc_j, normalize(vⱼ₁), normalize(vⱼ₂))\n", + "\n", + " # u connections\n", + " points = hcat(tu_j, tu_j_int, tu_j_end, tu_j_plus_1)\n", + " plot!(points[1, :], points[2, :]; marker = :circle, c = :black, ls = :dash, label = \"\")\n", + "\n", + " # line segment\n", + " plot!([tu_j_plus_1[1], tu_j_end[1]], [tu_j_plus_1[2], tu_j_end[2]], c = :black, label = \"\", linewidth = 2)\n", + "\n", + " # td_j and td_j_plus_1\n", + " plot!([tu_j[1], tu_j[1] + td_j[1]/5], [tu_j[2], tu_j[2] + td_j[2]/5]; arrow=(:closed, 2.0), color = :black, label = \"\")\n", + " plot!([tu_j_plus_1[1], tu_j_plus_1[1] + td_j_plus_1[1]/5], [tu_j_plus_1[2], tu_j_plus_1[2] + td_j_plus_1[2]/5]; arrow=(:closed, 2.0), color = :black, label = \"\")\n", + "\n", + " # Circle segment radii\n", + " points = hcat(tu_j_start, tc_j, tu_j_end)\n", + " plot!(points[1, :], points[2, :]; color = :gray, label = \"\", ls = :dash)\n", + "\n", + " # v₂ⱼ\n", + " points = hcat(tc_j, tc_j + vⱼ₂)\n", + " plot!(points[1, :], points[2, :]; color = :gray, label = \"\", ls = :dash)\n", + "\n", + " # tc_j\n", + " scatter!([tc_j[1]], [tc_j[2]]; color = :gray, label = \"\")\n", + " ylims!(-0.65, 0.8)\n", + " return p, (; tu_j, tu_j_plus_1, tu_j_int, tu_j_start, tu_j_end, td_j, td_j_plus_1, inner, tc_j, δⱼ, Rⱼ)\n", + "end\n", + "\n", + "plot_arc_construction()[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = plot_tangent_curve()\n", + "\n", + "δ = [min(\n", + " norm(intersection_points[:, j] - u_tilde[:, j]), \n", + " norm(intersection_points[:, j] - u_tilde[:, j+1])\n", + " ) \n", + " for j in 1:n_intervals\n", + "]\n", + "\n", + "u_tilde_start = zeros(2, n_intervals)\n", + "u_tilde_end = zeros(2, n_intervals)\n", + "\n", + "for j in 1:n_intervals\n", + " u_tilde_intⱼ = intersection_points[:, j]\n", + " u_tildeⱼ = u_tilde[:, j]\n", + " u_tildeⱼ₊₁ = u_tilde[:, j + 1]\n", + " d_tildeⱼ = d_tilde[:, j]\n", + " d_tildeⱼ₊₁ = d_tilde[:, j + 1]\n", + "\n", + " u_tilde_start[:, j] = u_tilde_intⱼ - δ[j] * d_tildeⱼ\n", + " u_tilde_end[:, j] = u_tilde_intⱼ + δ[j] * d_tildeⱼ₊₁\n", + "end\n", + "\n", + "scatter!(u_tilde_start[1, :], u_tilde_start[2, :]; markersize = 3, markerstrokewidth = 0, \n", + " label = raw\"$\\tilde{u}_{j, start}$\")\n", + "scatter!(u_tilde_end[1, :], u_tilde_end[2, :]; markersize = 3, markerstrokewidth = 0,\n", + " label = raw\"$\\tilde{u}_{j, end}$\")\n", + "\n", + "origins = zeros(2, n_intervals)\n", + "\n", + "for j in 1:n_intervals\n", + " u_tilde_intⱼ = intersection_points[:, j]\n", + " d_tildeⱼ = d_tilde[:, j]\n", + " d_tildeⱼ₊₁ = d_tilde[:, j + 1]\n", + " inner = dot(d_tildeⱼ, d_tildeⱼ₊₁)\n", + "\n", + " origins[:, j] = u_tilde_intⱼ + δ[j] / (1 - inner) * (d_tildeⱼ₊₁ - d_tildeⱼ)\n", + "\n", + " plot!([u_tilde_start[1, j], origins[1, j], u_tilde_end[1, j]], \n", + " [u_tilde_start[2, j], origins[2, j], u_tilde_end[2, j]]; \n", + " label = (j ==1) ? \"radii of circle arc\" : \"\", ls = :dash, c = :gray)\n", + "\n", + " Rⱼ = δ[j] * sqrt((1 + inner)/(1 - inner))\n", + " v₁ = -δ[j] * (d_tildeⱼ₊₁ - inner * d_tildeⱼ) / (1 - inner)\n", + " v₂ = Rⱼ * d_tildeⱼ\n", + " Δt = 2 * Rⱼ * atan(δ[j], Rⱼ)\n", + " T = range(0, Δt, length = 25)\n", + " x = @. origins[1, j] + cos(T/Rⱼ) * v₁[1] + sin(T/Rⱼ) * v₂[1]\n", + " y = @. origins[2, j] + cos(T/Rⱼ) * v₁[2] + sin(T/Rⱼ) * v₂[2]\n", + " plot!(x,y; c = :green, label = (j == 1) ? \"circle arc\" : \"\")\n", + "end\n", + "\n", + "scatter!(origins[1, :], origins[2, :]; label = raw\"$\\tilde{c}_j$\", c= :gray, markerstrokewidth = 0)\n", + "\n", + "p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's pretty neat, but this method does not directly generalize to higher dimensional spaces. That is because in general the intersection points $\\tilde{u}_{j, \\text{int}}$ of the tangent lines do not exist." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The higher dimensional case\n", + "\n", + "Let's try to generalize the method above. The goal is to find a point $\\tilde{u}_{j + \\frac{1}{2}}$ and unit direction $\\tilde{d}_{j + \\frac{1}{2}}$ to add to the tangent curve between $\\tilde{u}_j$ and $\\tilde{u}_{j+1}$ such that:\n", + "\n", + "- the tangent line intersections $\\tilde{u}_{j, \\text{int left}}, \\tilde{u}_{j, \\text{int right}}$ exist. This means that the new line is fixed by these 2 points; \n", + "- constructing $\\tilde{\\gamma}$ including this point gives gives an identical result to constructing $\\tilde{\\gamma}$ excluding this point if the tangent line intersection already existed. The latter implies that $\\tilde{u}_{j + \\frac{1}{2}}$ and $\\tilde{d}_{j + \\frac{1}{2}}$ yield a tangent line to the constructed circle arc.\n", + "\n", + "Let's assume the tangent line intersection exists, and we define\n", + "\n", + "$$\n", + " \\tilde{u}_{j, \\text{int left}} = \\tilde{u}_{j, \\text{int}} - \\delta_j^* \\tilde{d}_{j},\n", + "$$\n", + "$$\n", + " \\tilde{u}_{j, \\text{int right}} = \\tilde{u}_{j, \\text{int}} + \\delta_j^* \\tilde{d}_{j+1}.\n", + "$$\n", + "\n", + "It turns out that if we then let\n", + "\n", + "$$\n", + "\\delta^*_j = \\delta_j \\frac{2 - \\sqrt{2 + 2 \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle}}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle},\n", + "$$\n", + "\n", + "The line between $\\tilde{u}_{, \\text{int left}}$ and $ \\tilde{u}_{, \\text{int right}}$ touches the circle arc as constructed before. It follows that\n", + "\n", + "$$\n", + " \\tilde{u}_{j + \\frac{1}{2}} = \\frac{1}{2}\\left[\\tilde{u}_{j, \\text{int left}} + \\tilde{u}_{j, \\text{int right}}\\right],\n", + " \\qquad\n", + " \\tilde{d}_{j + \\frac{1}{2}} = \\frac{\\tilde{u}_{j, \\text{int right}} - \\tilde{u}_{j, \\text{int left}}}{\\|\\tilde{u}_{j, \\text{int right}} - \\tilde{u}_{j, \\text{int left}}\\|_2}.\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p, vars = plot_arc_construction(; indicate_delta = false)\n", + "xlims!(0.0, 1.3)\n", + "ylims!(0.0, 0.8)\n", + "δⱼ_star = vars.δⱼ * (2 - sqrt(2 + 2 * vars.inner)) / (1 - vars.inner)\n", + "tu_j_int_left = vars.tu_j_int - δⱼ_star * vars.td_j\n", + "tu_j_int_right = vars.tu_j_int + δⱼ_star * vars.td_j_plus_1\n", + "tu_j_plus_half = vars.tu_j_int + δⱼ_star / 2 * (vars.td_j_plus_1 - vars.td_j)\n", + "td_j_plus_half = (vars.td_j_plus_1 + vars.td_j) / sqrt(2 + 2 * vars.inner)\n", + "\n", + "scatter!([tu_j_int_left[1], tu_j_plus_half[1], tu_j_int_right[1]], \n", + " [tu_j_int_left[2], tu_j_plus_half[2], tu_j_int_right[2]]; color = :black, label = \"\")\n", + "annotate!(tu_j_int_left..., raw\"$\\tilde{u}_{j, \\mathrm{int \\; left}}$\" * \"\\n\\n\")\n", + "annotate!(tu_j_int_right..., raw\"$\\tilde{u}_{j, \\mathrm{int \\; right}}$\" * \"\\n\\n\")\n", + "annotate!(tu_j_plus_half..., \"\\n\\n\" * raw\"$\\tilde{u}_{j + \\frac{1}{2}}$\")\n", + "annotate!(tu_j_plus_half..., \" \" * raw\"$\\tilde{d}_{j + \\frac{1}{2}}$\" * \"\\n\\n\\n\")\n", + "annotate!((vars.tu_j_int + δⱼ_star / 2 * normalize(vars.tu_j - vars.tu_j_int))..., raw\"$\\delta^*_j$\" * \"\\n\\n\")\n", + "plot!(\n", + " [vars.tu_j_int[1] - δⱼ_star * vars.td_j[1], vars.tu_j_int[1] + δⱼ_star * vars.td_j_plus_1[1]],\n", + " [vars.tu_j_int[2] - δⱼ_star * vars.td_j[2], vars.tu_j_int[2] + δⱼ_star * vars.td_j_plus_1[2]];\n", + " color = :black, ls = :dash, label = \"\")\n", + "plot!([tu_j_plus_half[1], tu_j_plus_half[1] + td_j_plus_half[1]/5], \n", + " [tu_j_plus_half[2], tu_j_plus_half[2] + td_j_plus_half[2]/5]; \n", + " arrow=(:closed, 2.0), color = :black, label = \"\")\n", + "\n", + "p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we generalize the definition of $\\tilde{u}_{j, \\text{int}}$ then we can compute $\\tilde{u}_{j + \\frac{1}{2}}$ and $\\tilde{d}_{j + \\frac{1}{2}}$ as above. Something we can always compute are the points on the tangent lines which are closest together, given by:\n", + "\n", + "$$\n", + " \\argmin_{s,\\; t \\;\\in\\; \\mathbb{R}} \\|\\tilde{u}_{j+1} + s\\tilde{d}_{j+1} - (\\tilde{u}_j + t\\tilde{d}_j)\\|_2.\n", + "$$\n", + "\n", + "This yields \n", + "\n", + "$$\n", + " \\tilde{u}_{j, \\text{close left}} = \\tilde{u}_j + \\frac{\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_j,\n", + "$$\n", + "$$\n", + " \\tilde{u}_{j, \\text{close right}} = \\tilde{u}_{j+1} + \\frac{\\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_{j+1}.\n", + "$$\n", + "\n", + "This is the same as the two expressions for $\\tilde{u}_{j, \\text{int}}$ from before, except now these expressions aren't necessarily equal. We define $\\tilde{u}_{j, \\text{int}}$ as the average of these expressions:\n", + "\n", + "$$\n", + " \\tilde{u}_{j, \\text{int}} = \\frac{\\tilde{u}_{j, \\text{close left}} + \\tilde{u}_{j, \\text{close right}}}{2}.\n", + "$$\n", + "\n", + "From this $\\delta_j$ and $\\delta_j^*$ follow, and \n", + "\n", + "$$\n", + " \\tilde{u}_{j, \\text{int left}} = \\tilde{u}_{j, \\text{close left}} - \\delta_j^* \\tilde{d}_{j},\n", + "$$\n", + "$$\n", + " \\tilde{u}_{j, \\text{int right}} = \\tilde{u}_{j, \\text{close right}} + \\delta_j^* \\tilde{d}_{j+1}.\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SmoothArcLengthInterpolation with 31 points\n", + "┌───────────┬─────────────┬──────────┬──────────┐\n", + "│\u001b[1m time \u001b[0m│\u001b[1m u1 \u001b[0m│\u001b[1m u2 \u001b[0m│\u001b[1m u3 \u001b[0m│\n", + "├───────────┼─────────────┼──────────┼──────────┤\n", + "│ 0.0 │ 0.0491718 │ 0.119079 │ 0.393271 │\n", + "│ 0.0703603 │ 0.0269864 │ 0.153539 │ 0.450413 │\n", + "│ 0.137097 │ 0.00971137 │ 0.192336 │ 0.501846 │\n", + "│ 0.203801 │ -0.00355192 │ 0.23671 │ 0.549797 │\n", + "│ 0.270541 │ -0.0125266 │ 0.286242 │ 0.593559 │\n", + "│ 0.337314 │ -0.0172039 │ 0.34013 │ 0.63265 │\n", + "│ 0.407777 │ -0.0175421 │ 0.400798 │ 0.668408 │\n", + "│ 0.478301 │ -0.0138159 │ 0.464221 │ 0.698958 │\n", + "│ ⋮ │ ⋮ │ ⋮ │ ⋮ │\n", + "│ 1.03979 │ 0.204067 │ 0.911244 │ 0.824877 │\n", + "│ 1.09888 │ 0.257848 │ 0.887916 │ 0.826758 │\n", + "│ 1.15943 │ 0.307302 │ 0.853081 │ 0.826189 │\n", + "│ 1.25314 │ 0.372683 │ 0.786276 │ 0.821875 │\n", + "│ 1.34719 │ 0.432338 │ 0.713833 │ 0.815967 │\n", + "│ 1.47879 │ 0.507208 │ 0.606141 │ 0.805672 │\n", + "│ 1.61049 │ 0.577164 │ 0.495155 │ 0.794274 │\n", + "│ 1.78126 │ 0.661425 │ 0.347513 │ 0.778149 │\n", + "└───────────┴─────────────┴──────────┴──────────┘\n", + "\u001b[36m 15 rows omitted\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "using DataInterpolations: SmoothArcLengthInterpolation\n", + "\n", + "Random.seed!(1)\n", + "\n", + "n = 4\n", + "u = rand(3, n)\n", + "A = SmoothArcLengthInterpolation(u; m = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_eval = 500\n", + "t_eval = range(0, last(A.t), n_eval)\n", + "u_eval = zeros(3, n_eval)\n", + "\n", + "for (i, t) in enumerate(t_eval)\n", + " u_eval[:, i] = A(t)\n", + "end\n", + "\n", + "p = plot(; aspect_ratio = :equal)\n", + "\n", + "plot!(u_eval[1, :], u_eval[2, :], u_eval[3, :]; label = \"Arc-length parameterized curve\")\n", + "scatter!(A.u[1, :], A.u[2, :], A.u[3, :]; label = \"Points defining tangent curve\")\n", + "scatter!(u[1, :], u[2, :], u[3, :]; label = \"Original data\")\n", + "\n", + "p" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It would be nice to have a rigorous proof of $\\tilde{\\gamma}$ converging to the arc-length reparametrization of $\\gamma$ as $m \\rightarrow \\infty$ (and how fast). For now we can look at the convergence of the arc-length of $\\tilde{\\gamma}$ to the arc-length of $\\gamma$ with $m$ for the example above: " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "M = 5:1000\n", + "E = zeros(length(M))\n", + "\n", + "(; shape_itp) = A\n", + "t_eval = range(0, last(shape_itp.t), length = 1_000_000)\n", + "u_eval = shape_itp.(t_eval)\n", + "l = sum(norm.(diff(u_eval)))\n", + "\n", + "\n", + "for (i, m) in enumerate(M)\n", + " A = SmoothArcLengthInterpolation(u; m)\n", + " E[i] = abs(l - last(A.t))\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd0AT5+MG8PeSsPdGEBBQpiAggiIq4paioKLgok7ACWjVKop7oiwH7q111tE6quJAARUVRRy4BUGGbFkhye+P9MeXWupMcgl5Pn8lx3H3gJgn7+XuPYrH4xEAAABpxaA7AAAAAJ1QhAAAINVQhAAAINVQhAAAINVQhAAAINVQhAAAINVQhAAAINVQhAAAINVQhAAAINVQhAAAINWaZxHm5eWtWbOG7hQiwmaz6Y4A0ojL5XI4HLpTgDQS+Ite8yzCN2/eHD9+nO4UIlJTU0N3BJBGHA4Hb8KAFgJ/0WueRQgAAPCVUIQAACDVUIQAACDVUIQAACDVUIQAACDVUIQAACDVUIQAACDVUIQAACDVUISk/Pz+ok1zOcUFdAcBAAAasOgOQD/VXv6VSafz105R8Ryi4ulHKIruRABS59q1a/n5+XSnAHHXuXNnAwMDgW8WRUh2PKdqdAZMCHMtPbiu+uFNzeHhLB1DukMBSJehQ4e6urrKycnRHQTEV2ZmZkBAQEREhMC3jCIk3fSpkVc4J9/o7BizSv3BuYLYcJXug1W6DyEMHDcGEBEej7d161ZdXV26g4D4ioyM5HK5wtgyXuuJuSp13ZvlacBwPMHZr9lXNyym5smdgviZ9fnZdEcDAAChQxESQgiTIrPbMS71Z218xA1I12WMW6nUoWdB/MyKS4eJcN6AAACAmEAR/o+dJpU6kGWuSuyPcxJb9tUNi615ercgLpyd/5buaAAAICwown+QZ5KVHZhHejDDU7ljM3QUxq9QculdGDuj7PQOHqee7nQAACB4KMImuOlRd3xZCixi/zvnjlk/vZkb2DnPC9ZNY+e8oDsaAAAIGIqwaaoyZLM7c4Mbc/hlTvhTLZWJy1V7BRQmzMPQEACgmUERfk4/I+qeLyv7I3E+Uf/UyF1v1sb6guyCqCl12c/ojgYAQsTlcu/evXv8+PHU1NTq6mph7y4tLW3nzp3C2HJRUdGSJUuEseXmBEX4BTry5HhP5gInRp9z9Uueq6mPjVTuPrho8/zys3sxNARolp49e+bo6Dh06NADBw7MnDnT0tLy8uXLQt1jZmbmiRMnBLW1oUOHJiYm8h8XFxfHxcUJasvNFYrwq/iZMm4NZF3L43U5XZ9n1VNv1iZ23uuCqCl1b7PojgYAglRXV+fl5eXu7v7kyZOjR49ev379woULLNYX5h7h8XjPnz8vLS39zDoVFRWvXr36mkvC6+vrX758WVVV9cny8vLyFy9e1Nf/4y14Xl5eXl5e4yW5ubkfP3785HvfvXuXm5v7mZ1mZ2cXFxd/srCuru7x48e1tbX8pyUlJc+fP28I8/r1ax6P98m3FBQUvH79+jM7EkMowq9lokxd7M8aYspwO1W/K09Na+x81T4jPmyLLDu9g1fPpjsdAAjGH3/8UVxcvGbNmobys7S07NKlCyFEXV294SV+6tSp/EOO+/bt69y5c9euXf38/Pbv36+srPzq1Sv+OsnJyS1btuRwOLW1tWPHjrW3tx81apSFhcW9e/c+E+DAgQOmpqY///xz69ato6Oj+Qvt7OwmT57s5uY2cOBAe3v7Dx8+EELq6uoGDx7s5ubm6+sbEhJCUVR5eXlMTMz9+/fDw8OdnZ23bdtGCOHxeKGhoT4+Pk5OTiEhIf/eY3p6urW1NX+WO39/fzabzf8B/fz8HB0dR4wY8fDhQz09vcmTJ7u6ugYFBXG53ODgYCsrK39/fzMzs1u3bhFCKioqKIqaNm2ah4dHZGTkj/9DiBKmWPsGDIqE2zH6tKRGXuFczuNtce+i19qu5MiG/JVBGgFhcuZ2dAcEaCbYXHLqjSgms6AI8TZmyDH/tyQ9Pd3W1lZRUfHrN3L79u1bt245ODgQQlJTU/fv38+fD3P37t2BgYFMJnP16tWlpaXPnj1jsVi///77uHHj7t692+Smnj17NmPGjNTUVBMTk+LiYgcHh969e9va2hJCSktLHzx4QFGUt7f37t27w8PDd+7cmZub++TJEzk5udWrV/O3EBoaevTo0dmzZ3t7exNCsrKyPnz44ObmFhMTU1RUZGZmNmvWLFNT04Y9stnsYcOGRUVFeXt7czgcHx+f7du3BwcHE0LS0tLS0tK0tLT4a9bV1T19+pSiqH379l29evXp06cqKiqbN28ePXr0o0eP+Ovo6+s3PJYgKMJvZqtBpQxgTb7B6XSq/nhPNfMx86rTk4p3LZe366TuM5GSlac7IIDEq2STE294tRyh70iOSTxakMZFWFdXJy//bf+LnZ2d+S1ICPn555+Dg4PnzZtXW1t75MiR5ORkQsipU6fc3d1///13QgiHw3nw4EFlZaWysvK/N3Xu3LlWrVrdunWLP8wyNjZOTk7mF+HIkSMZDAYhpFOnTi9fviSEXLlyxd/fnz9TeWBg4OzZs5uMp6io6OfnRwjR1tZu06bNy5cvGxfhkydP8vLyampqjhw5QggxMDBISkriF6Gvr29DCxJCxo4dS1EUIeTixYsjRoxQUVEhhIwbN27q1Klv377lrzl+/Phv+tWJCRTh95Bnku1dmVuecDueqt/ahenj0EXOwrHsjx35q0M0/MPkWtvTHRBAsmnIkb0ezC+vJwTm5uaHDx/m8XjUZ+/IxuH8r6U1NDQaHnt6enI4nOTk5OzsbGtraysrK0JISUlJSUkJv70IIcuWLfv3R2t8JSUl/A8I+U+9vb3t7f9+PVFSUuI/YLFY/I8Ja2pqGjr7M+WtqKjY8LPIyMjwj3w23iOLxWrYo5mZmZmZGf+xurp64zUbfsyKigp+C/LDKCoqlpeX84uw8a9CgqAIv99EK4atBjUskZNawFvurKwxdFrNo1vF+1bL27ioD5xAySnQHRAAvpmPj09YWNjBgweHDx/OX8Jms3Nzc01MTLS0tPLz81u1akUIefjwYYsWLf797RRFjRw5cvfu3dnZ2YGBgfyFdnZ2RkZG/zVia8zOzu7QoUMzZ85kMr/8PsDe3j4pKSkoKIgQcu3atYblsrKyn5xQ8xnW1tbV1dXDhw83MjL6ym+xsrK6ffs2//HTp09ramrMzMz+q9olAorwh3TWo+75soZdqh/wV/2+7ix1Gxe92Qllp3fkr56k4T9dro0D3QEB4Nvo6Ojs2rUrMDDw6tWrHTp0eP/+/eHDh3/55ZdRo0b179//l19+CQoKSk5O/uREzcYCAwOdnJy4XO5vv/3GX7J48WJPT082m+3s7JyXl5eWlrZ9+/Ymv3fgwIEbNmzw9fUdMWIEm81OSkqaPHlyw6DwE1OmTHFxcQkMDDQyMkpJSSGE8I+dOjs7x8bGZmVlubu76+jofPHnnTt3bt++fcPDw9XU1B48eGBubt5Q4U2aPHmyo6NjRESEjY3NqlWrZsyYoaysXFFR8fkdiTPmwoUL6c4geDk5OefPnxfN0WolFhnRmvGwlBd+k+vRgtJXlVOwdWXpGpYcjKkvyJFvbU+xZIQaoK6uDrczBdHjcrk8Hu+L1xV8paioqEmTJjUc/aOXjY3N8OHDc3NzMzMzlZSUQkNDvby8CCE9e/asrKy8f//+Tz/95O3tbWlpaWRkxGQyDQ0N+R/j8WlqamppaQ0ZMsTZ2Zm/REdHZ+TIkU+fPk1LSyOE+Pn5fTL8kpGRMTY2trKyoihqxIgRPB7v9u3b79+/79y5c+fOnWVkZOTk5JydndXU1Pgrm5qatm7dWklJafTo0RwOR1tbe/z48Xv37uWfrtmtWzd1dfXy8vKWLVuamJhoaGi4urrydyQnJ+fk5PTJAcxu3brZ2Njcvn37+fPnxsbGAwYMUFZWlpGRsbS0NDY25q8jLy/fsWNH/jlEKioqw4cPz8zMfPbsWWBg4JQpUwghFEUpKyu7u7t//pDyj7hy5QqDwejWrZvAX/QoiR7P/pfU1NSwsDD+WySROfCCG5bKievEHGbGIIRwqyrLTmyufZGh4R8q1KFh4+P1ACLDZrM5HM63nlfyX/T09DIyMnBj3m915coVNze3qqqqadOmcbncffv20Z1IiCIjI5lM5oIFCwT+oofrCAVmuDnjr36sube5Qdc5bC5hKCprDJ+hPmRy8YF1JYfjuDWfXhsLAPCD1q9fb2Vl5eLiIi8vjxlkvhuKUJDaaVL3BrHyq0nPM/XvqwkhRN66g97sBEJI/ooJ1Q9Tac4HAM3L0aNHX758mZWVtWXLFk1NTbrjSCqcLCNgqjLk917M1fe5LifqD/dgdtSlGPKKGkOn1b58WHJgXVXaJY2h0xiKOJIJINZu3rz54sULBwcHGxubJlcoKyt78eKFvr6+gYFBw8Lq6uqkpKSSkpLu3bs3HOatqalJTk7Oz8+3sLBo3759w8psNvvatWsFBQVdunRp2bIlf2Fpaent27cLCwt1dHQ8PDxkZIR7hsG/lZeXP3v2zN7e/it3/fDhw8zMTDU1tS5dujT5ES+Px0tOTn779q2Tk5OlpWXD8sLCwhs3bnC53I4dOzb+Hebn5+fk5Jiamoqy1zEiFDyKkNntGJvcmT4X6mMf/j05hpxZW71Zm1haLfJXBVdnJNObEAA+Y/bs2QEBAYmJiZ6envxZyj4xatQoXV3drl27bt68uWFhYWGho6NjdHT0+fPn27Zty78ins1m6+vrL1iw4MyZM4MGDRo6dCh/rtHKyspOnTotXbo0MTHRycnpwoUL/I0EBQVFRUX99ddfc+fObdu2bUFBgUh+4r+VlpZ6enr+9NNPAQEBX3MBRkhIyIABA06cOLFixYo2bdpkZX069zKXyx04cODUqVOvXr3q6enZcK5sSkqKpaXl0aNHT58+3bZt27Nnz/KXd+jQwdTUtHPnzufOnRPsj/YFvOYoJSWlY8eOdKfgPSnl2hxhj75SX173v4U1Lx7mLR1btHMpp7JMIHspLy8XyHYAvkldXV11dbWgtqarq5ufny+orf2InJwceXn5N2/e8Hi8q1ev6ujo1NTUfLLOixcvqqurAwICFixY0LDwl19+8fX15T/euHFjz549eTweh8PJysriLywqKlJRUbl69SqPx1u1alWXLl34Z94eOXLEwcHhk11wuVxXV9fo6Oh/Jzx06FBBQUHD04yMjCtXrvx7tfLy8rq6usLCwvT09Lq6Oh6PV1lZmZ6eXllZ2eQPXllZ2aVLl2nTplVXVw8dOnTIkCFsNvu/f088Ho+XlZXF4XD4j4cPHz527NhPVjh27JiJiQn/F3jv3j1tbW3+38zw4cPDwsL46yxbtqx37978x0+fPmWz2Y6Ojvv37//37hYsWLBo0SKeEF70MCIUIks1Ks2HpS5L7I/XJ+f/fXaunJnt30PD1SHV96/TmxAAPnHmzBlnZ2f+ZQNdunRhMpmpqZ9+um9mZvbv02UfP37csWNH/uNOnTpdunSpoqKCwWC0adOGv1BTU1NRUbGmpoa/squrK/9Kg44dO6anp39yxwYej8dms5ucqCUrK6tHjx6FhYWEkIcPH/bp0+ffd40ghPTq1WvcuHG9e/cePXq0k5PTpUuX3N3dJ0+ezJ9l7ZOVq6qqvL29BwwYEBsbKy8vf+DAAV1d3XHjxn3+Xhlt2rThX7lICGnZsiX/R2vsyZMnjo6O/EsdHBwcKisrr1+/TghRV1dvuKNFbW1tw49pYWEhqAtyvgk+IxQuBRaJ7cT0aMH1vVgfYs1Y4MhkUISSkVXzHqvQtmPxb9FV965qDJnCUFajOymAGOHVs6vSEglX+JONMhiK7T0pGdmGBe/evWv4xI6iKENDw3fv3n3NloyNjTMzM/mPMzMzeTzeu3fv+FOs8W3btk1FRYV/IwtjY2P+NYX8lQkhOTk5/DlrTpw4sXv37szMzH79+o0YMeLfO4qIiOByuT169IiNjR05cmRcXJyvr2+Tkerr6+/cuUMI6dix45w5c5KTkxUUFIKCgrZs2bJy5crGayoqKjbcwpAQwmQyN2zY8DU/NV9ubu7OnTv379//79/J3r17uVwug8F48eJFTU1NTk4OIWTRokWjR4/28vKSkZEpLS399zeKGIpQFHxbMZx1qJGXOUnv6/d0YxoqUYQQWVMbvZkbyv/clb86RH1wiEK7LnTHBBAXvPo6ds4znvDvP0FRDJ5958ZFWF9f3zDKIYSwWKxPJuf8L6GhoZ06dQoKCtLV1T179iyDwWg8nEpMTJw3b96ff/6poKBACAkJCWnfvv3o0aPNzc1PnTqlpKTUsLKDg4OcnNz9+/djYmICAgIaRpmNLViw4P37956enlu2bBk8ePB/RRo8eDB/0NmuXTtdXV3+rh0cHK5evfo1P9G/FRYW8q/PVlFR6d69O39heXm5j4/P2LFje/Xq9cn6Q4YMWb16tbe3t5ub24kTJ/T19fk/5rVr17KysmbMmCEjI7N27dpz586NGzfu+yIJBIpQRIyUqEQvVtQDboeT9Zvdmd7GDEIIJSOr5jNRwaFL8cHoqrvXNPwmM5TVv7gpgGaPIa+kPmQKLbtu0aIF/zwXvvz8/MbnNH5GmzZtHj58+McffzCZzK1bt7Zv377hJg83btwICAg4cuRIhw4d+Ev09fUzMjJOnjzJZrMPHTpkaWnZMNV1q1atWrVq1a9fv5KSktjY2CaL8OHDh6dOnfL391+/fr2vr6+2tnaTkRpuJsVisfgtSBrN2f0d3r9/f+jQIUKIgYEBvwgrKyv79+/v4uKyYsWKf68vLy9/8+bNEydOFBcXHzx40MPDg/9jRkRELF68mD+bq7Gx8ahRo1CE0oJJkdntGB4tqOGXOUde8hLcmYosQgiRbWWtN3N9xaXD71cGq/UfreTWn+6kANKra9euc+bM4d8m6dmzZwUFBfz2qq2t5XK5DXXSJH19ff7MjgsXLvT09OSvnJqa6uPjs2fPnm7dujVeWVNTc8yYMYSQDRs22NnZNRyPbVBSUtLk/ClPnjzx8vKKj4/39fVdvXp1165dExMT9fX1f+zn/ip2dnaND2NWVVUNGDDA0tIyLi6u8cxqVVVVLBZLVlaWEKKgoBAQEEAIOX/+fG1tLX+yN4qiGm7f0fg+HnRBEYqaqy51bxAr5Dqnw4n6g55Me02KEELJyKr2Halg51Z8cG31wxSNodOZ6k2/xQMAobKzs/P09Bw4cODgwYO3bNkyadIk/t2IIiMjHz9+fPLkSULIkSNHLl68eOvWradPn75//z4gIMDDwyMrKys6OtrS0vL+/ftnzpy5fPkyIaSioqJv374mJiYnTpw4ceIEIWTEiBFdu3YtKCiYM2eOvb19VlbWb7/91nD9gIeHh4eHh6am5p07d06cOME/teQTS5YsiY6O5n8uOGvWrNra2u3bt8+bN09kv6IGU6dOvXnzprm5Of/G92ZmZvw7bPTq1cvX13fmzJmEEP6pOu/evdu2bdv27dv5bw4mTJgwa9asoqIi/qHRiRMn8jcYFxeXmZmZnZ29ffv2q1evhoeHN770UHhQhDRQlSH7uzP3POP2OFMf4cCc3vbvDyRkDM10w2IrrxzPj5qCoSEAXQ4fPrxjx47nz5/PmjWLP5ohhPj4+DQM6Vq2bNm+ffuGq+P5d3ho0aKFra3tq1evbGxsVqxYwR+iycjINNw7vvHKampqHTt2fPr0qZGRUXp6esPc1nPnzk1NTX3z5o2zs/Pq1av19PT+HW/fvn2Nh1/z58/nNTVl9Jw5c9q2bct/PHz48Iar3bt06cI/K+fH+fn5NUznTQhpSDtz5syGw8J9+vS5e/euiorK9evXG6YmDw0NdXBwSExM5HK5Gzdu7NevH395mzZt5OXlG36xIptFGZNu0+lpGS8gkWOqQm3pwtRqNJc6O+91yYG1DGU1jWHTmepfuIsKJt0GWmDSbRAxTLrdPFmqUSkDWKYqpM1hduBVzrX3f78rkWnRSjcsRq61fX7UlI/JZ0hzfLMCACAmUIQ0k2OSKFfmy2EynfWo6SkcyyP1C+9ysj/yCIOp0mOozuRVH1POFm2O4JSIdKYlAADpgSIUC+qyZKIV454v62B3Zl4VsT9W3+ts/ZFXXErv/4eGa6d+vPEnhoYAAAKHIhQv7bWpze7MvBEyE60YW55wTX6rn3OHFLgM1Q2Nrrp7pTB+Zn3hV01yAQAAXwlFKI7kmcTPlHGhH+tCfyabS9xO1wfc1ysdtUrRuUdBTFjFpcMYGgIACAqKUKzZqFNrXZnZATLuelTnPzjh3D7UpNiax2kFcTPqC3LoTgcA0BzgOkIJIMsg09syRrVhrH7AsUvUnuCyfGbtXwVxM1S6D1bpPoTudACCER8fr6ysTHcKEF83btzo2rWrMLaMIpQYmnJkZQfmZBvG0ntc27e9lng5DLwbV52RLDsgiKhY050O4IfMmzcvNze3pKSE7iAgvpydnRsuvRcsXFAvke4U8Wbd4uR95CXInjO/uUe1h59K9yGEgQPdIDqCvaAe4OvhgnoghJD22tSl/qy1HVlTOP2mtov+kJmev3YKO+cF3bkAACQPilCC9TOi7vmyulpoumosvNTKtyBhXtnpHTzOd95gBQBAOqEIJRuTIuNac9IHyx7X9AywjSt8+7Zg7VR2znO6cwEASAwUYXPQQpEc7cH8pbN2d82I34z9CzfPLzu9g1f/VbfVBgCQcijC5sPbmJExmPWopbuvRUzu6zcF0dMxNAQA+CIUYbOiLks2uzNX99QdqD9/t45v/qaI8j93Y2gIAPAZKMJmqFsL6p4vK9fKs59FfPab7IKoKXVvn9IdCgBATKEImyclFonpyNzST3ug9pzfWg0v2rqw5HAcr66G7lwAAGIHRdicddKl7vqy7ui7D7GJ/1BZm786pPZ5Bt2hAADEC4qwmVOVIXs8mGEdNTvLhZ6xn1i8b1XJ4ThebTXduQAAxAWKUCr4mTJuD2TtYXYYYx9XUVmdv2Zy7cuHdIcCABALKEJpYaxMXerP8jBX7yAX/sAtuHgPhoYAAISgCKUKkyJz2jHO9GFN/eC03GNDPZfkrw6pzbpHdy4AADqhCKVOe23qjg+rlCh1Y00q7Tul+GB0yeE4bk0V3bkAAOiBIpRGyjJkrwdzTjtGl6ftjntvJITkr5hQ/TCV7lwAADTAjXml1+g2DBcdalgidVN3cqyte9mx2JqMFDXfiQx5JbqjAQCIDkaEUs1Knbo5kKUhRzo9si8I2sxQVstfMbE6I5nuXAAAooMilHbyTBLbiTnfkdHzAnOFfiBz+NyyU9s/7FrG/VhOdzQAAFFAEQIhhIxozbjryyqtJTa3LLb1Xs/RaJG/OqT6wQ26cwEACB2KEP7WUolKcGfe9WVl18raVY462Wl2yakdxXtWYmgIAM0bihD+wViZ2uzOvOrFuiJr27lV3AO2Rv6q4Or7SXTnAgAQFpw1Ck2wUqd+82Q+KFacc3ucHOW+5mSs+q2LGkOnMdW06I4GACBgGBHCf7LXpM70YU3uYzPUOuZQrfm71ZM/Jp+hOxQAgIChCOELehpSNwcr1nuMHG284Nn5k++3LuaUl9AdCgBAYFCE8GUyDDK9LePwaJsEz9gtJUZvVoRU3b5EdygAAMFAEcLX0lUgCd3k+4/9eabt0nunf8/eEMEpLaQ7FADAj0IRwrdx1qYOD2991y86vtr25cop5TfOEB6P7lAAAN8PRQjfjMUgU+1kQoL8Vzotu3vuzIv4CE5JAd2hAAC+E4oQvpOpCrVtaOu3o6K319m8XDW1DENDAJBMKEL4fhQhoy1kQiePiHKLSvkr8dW6mfWF7+gOBQDwbVCE8KN0FcjmAUaVgavWMDxeRYWVXjyMoSEASBAUIQjGEDPmrxN/WtJhzZ2klDexs+qL8uhOBADwVVCEIDBGStTuISZZQ6NiOS5vo6ZXXv0dQ0MAEH8oQhAkipAQW+bUiUPCHaNvXUvJjQ6vz8+mOxQAwOegCEHwTFWoo36GSf2Xr6K65sTMqEg8SrhcukMBADQNRQhCwWKQyPasAcN8hlpGP7x5+31sOPv9W7pDAQA0AUUIQtTDgDobYBjvumyxTL+c2Fllp3fwOPV0hwIA+AcUIQiXlhw54MkaOrh3oH3ctQdvsldPZec8pzsUAMD/oAhBFDxaUJeG6T7xjlykMOD1+nkfzuzD0BAAxASKEEREhkF+sWcsntB3TbcNf6W9eL58Sl12Ft2hAABQhCBahkrUln7ahhMXxOr6P1sf+eLIDl49m+5QACDVUIRAg676VMwEj+uD41My32YsnVL+CkNDAKANihDowWKQIBftXrMXnm0z/PWmyAd7NvHqaukOBQDSCEUIdNJTILNHdCsYv/F2dsWDRcH5jzLoTgQAUgdFCPTraaHhP3tWisPPeTtX3NqzhceuozsRAEgRFCGIBSUWCfbrxpm6OT2v6kFkUH7mfboTAYC0QBGCGGlvrDLml9CHnSbk7l6VumMjr66G7kQA0PyhCEG8yDDICG83zpTNj99/zFgYUvQIQ0MAEC4UIYgjZ2OVgNm/XHcNeb1r7f0dcbzaaroTAUCzhSIEMSXPJJMGulRM2pjynv1oUXDZo7t0JwKA5glFCGKteyvlYTNmHGk35fmemMc7Y7g1H+lOBADNDYoQxJ2GHFk4rEPBxC0nC5WfLJxYeDeF7kQA0Kyw6A7QhLdv3968eZP/uEOHDq1atWr81dLS0nPnzqmrq/fp04eiKBryAR36mcm7hY7f9KdTj0OxOWk32o0MZigq0x0KAJoDcRwRJiUlJSQkvHz58uXLl5WVlY2/VFNT4+npmZeXd/To0dDQULoSAi3UZMkcX6fayZtSSuUfLQp6eQtDQwAQAHEcERJC3NzcZs+e/e/lJ06caN++fVhYGI/HMzMzW7hwoYaGhujjAY3cjRVdZ045cKmLxbGYtynXXH4OUVRTpTsUAEgwcRwREkL27t3r4ODg5+eXl5fXePmjR4/s7e0JIRRFWVhYPH+Oe51LIxkGCezVznjOpncM9ZHzz1QAACAASURBVOfLgm9dTqI7EQBIMDpHhCdPnty6dWvjJV5eXiEhIT/99JO/vz+TyVy7dm1oaOihQ4caVqipqZGVleU/lpOTq6qqEmliECeGGvIjpgZdudmVdWLd+dQLTuOm6+hq0R0KACSPEIuwurqazWarqv7jsFVFRUVWVpaJiYm2tnbPnj1dXFwaf1VJSYkQoqamxn/q7+//SVMaGBjk5ubyH+fm5hoaGgovP0gED1frCrsNF/buyY2a8rBHUPc+HnQnAgAJI5RDo6dPn7a2tlZWVvb09Gy8/MyZM2ZmZtOmTbO0tNy6dauSklKLf+K35oMHD/glumnTJldXV0JIdnb2vn37CCEDBgw4evRoeXn5nTt36uvrW7duLYz8IFlUFGUHBY3njFrCuHb4r+XzCwo+0J0IACSJUIqwdevWO3bsSEhIaLyQw+FMmjRp48aNN27cuHDhQlhYWGlpaZPfnpyc3L17d3d399LS0ujoaEJIeXl5RkYGIYR/goyvr+/ixYsPHz4sjPAgoZzsWneYH/tRx+z9milXz16iOw4ASAyKx+MJadP79u2LiYlJS0vjP01OTvb29i4oKGAymYQQZ2fn6dOnjxo1Shi7PnnypL+/v76+fsOSBQsW+Pn5CWNftKusrFRWxhV1/5Px+DX79/U1Kjq2IyaqaeKkYmFhs9kcDkdeXp7uICB1vulFT15ensX6woeAojtZ5u3btyYmJvwWJISYmpq+fftWSPvS09OztrY+evRowxIDA4Pm+j+Wx+OhCBvr1KHtR/v1f+w9WBw/812PsS59+9CdqHlCEQJdBP6iJ7oirKqqkpOTa3iqoKDw8aMQ542Uk5MzMzMT3vZBnCnJsYaNH3X9fufaw2uvpl9zGB+qpq1DdygAEFOiu45QT0+vuLi44emHDx8aH7oEEDj3dmYuC+Leattkr5qSduZPIrRPAQBAoomuCB0cHF6/fp2fn08Iqa+vv3nzprOzs8j2DtJJRY45avyID6NWlSafu7z817zcfLoTAYDYEUoRvnv3bsuWLZcvXy4sLNyyZcvZs2cJIYaGhoMHDx4zZsylS5cmTJjQunVrNzc3Yewd4BPd7Fu5LYj90NLhw7qpfxw5zeFiaAgA/yOUIqyurn758qWOjk5AQMDLly/fv3/PX75t27YOHTpER0draGj88ccfwtg1QJMUZRlDAv1lg6OUHl66uHhWxvNcuhMBgLgQ4uUTNEpNTQ0LC0tJkYq7E1RUVKioqNCdQmLwuNzEY7/r3Tz0sJ2/T4CvPAt38vpOOGsU6CLwFz0xnXQbQEgoBqOH32Dt6dGGr25cWTzj9uMcuhMBAM1QhCCN9I0Mu8yPUnHqqrA9fP/Ow1V1XLoTAQBtUIQgrSiqs4+P/ozYlrlp15eEpT1+Q3cgAKAHihCkmnaLFt3mrlLs0Etux6yjuw7W1XPoTgQAooYiBKlHUe4DftILi9fIeXBjYWjmk1d0BwIAkUIRAhBCiK6Bbo95y+td+nO3zzm1a39NXT3diQBARFCEAP+PonoN6Kcetl4+93Hqomk30p/THQgARAFFCPAPRgY6veculXX3Ud0XsWfTnsKPGBoCNHMoQoAmuPXr3WruxlYfX2YunXwi+QndcQBAiFCEAE1T0dTsOnOhTl//1icWbYvfnlNaS3ciABAKFCHA59h269563kbr+tyXK6ccu/aI7jgAIHgoQoAvkFfT6Bw2X997lMUfS3fGbn6HoSFA84IiBPgqFp27Ws5PaE0+vF4RcvpaBt1xAEBgUIQAX0tWRbXL9LnqA8cZ/7nyQNym/DIMDQGaAxQhwLexdetsEZGgxyt/tSLo+OX7zfA2ZgBSBkUI8M0UVFR6TJ+t7hNsfm7Nrqj4pwVVdCcCgO+HIgT4TlYdO9pGJlgoscvWhmw/c5eNWzkBSCYW3QEAJBhLUblzSHhOeprcoZjdGY5OIyc6GSrRHQoAvg1GhAA/qqWDs11kQjstBjc2ePOpW7W4lROARMGIEEAAGPKKHcZPf5+RLnsw5kDmNYdRQY4tVegOBQBfBSNCAIHRt3Owi9xkq6fAjQvedToVnxoCSAQUIYAgUXIKLmMn6wfOtk/Z/NuqVelvy+hOBABfgCIEEDxDW3vHhQlt9NV460M2H7tehVs5AYgxFCGAUFCych3HBBuOm+d6d+exFcuvPCulOxEANA1FCCBEupa27RZusjPT1dgyKfrAldI6ugMBwL+gCAGEi5KRdRgxvlXwAs8nB06vXHL+aTHdiQDgH1CEAKKgZm5lv2CDg0VLg22TY/ZfKsPQEEBsoAgBRIRiydj5jzGatLhr1pGzKyIvPSmiOxEAEIIiBBAxddM2jgvWW1m31t02JX7v+RLcygmAbihCAFGjmCyHoaOMpi5ze3nywoqIEw8K6E4EINVQhAD0UDcxd4qIa+tg02bv1NU7zuR+xDw0APRoogg/fPjg7Ox8+fJl0acBkCoUk2XjM9w0dFXvd2dTVs377c57uhMBSKMmipCiqDt37sjLy4s+DYAUUjRs5TAvxs65nd1v01dvPY2hIYCINVGEmpqajo6OSUlJok8DIKUYTIsB/mbha3oWJN5aNefo3Xd0BwKQIk3fhik6OnrkyJFMJtPb21tHR6fxlzQ0NEQSDEDqKLQwdvp1rdLZ45yDYdF3AvwCBrZUxqf4AEJH8Xi8fy/V19fPz89v8huaXF/cpKamhoWFpaSk0B1EFCoqKlRUcOu7ZqU6/92j7evyqngfvMJGdTRiUHQHagqbzeZwOPgMBURP4C96TY8I16xZU11dLcDdAMDXU9AzbP9r1Iu/TtYdn7Hq3tDBAb4WGky6QwE0W00X4ahRo0ScAwD+gaLM+/jUObn227HuWdT1q33DxrmbiOfQEEDSfeETiLKysszMzOJiTBMMQANZnRYOs1a37d6j8+lZURt+e16CGxsCCN5/FuGuXbvMzMzU1dXbtm2rpaVlaGgYHR0tER8QAjQrFGXS09tiTnyv6vsvosJ2Jb3k4n8hgEA1fWh0y5YtQUFB7dq1W758ub6+flFR0alTp8LDw8vLyyMjI0UcEQBYmrqOM5e/vHLO6PSv6+4N6Dt8aFttGbpDATQTTZw1yuPxDA0NPT099+7dS1H/+1Bi1qxZ69evLyoqUlRUFG3Ib4azRqG5qi8tzNgR++FD8ePu4UGerWXpu7wCZ40CXQT+otfEf6P8/Py8vLzQ0NDGLUgICQsLq66ufvLkiQB3DwDfhKWu4xi+1LqfT8+/ImJi99zNZ9OdCEDiNVGEsrKyhJDKyspPlvOXyMnJiSAWAHyGoXtvi4iNfRgvymOmxP/1lI1J2QB+QNNTrNnZ2c2ePfvDhw8NCysrK8PDw/X09KysrEQYDwCaxlTVbDd9kcWAYT0vLYyP2XGvAPe8B/hOTZ8sExcX17dvXxMTk+7duxsYGBQWFl69erW0tPS3335jMnFhL4C4MOjkqWfrWLMrvjJ6ckzXsODeNvL4DwrwjZr+qN3Dw+PWrVsDBw5MT08/cOBAamqqh4dHUlKSn5+fiPMBwOcxVTUcpy1o7TOyz9UlG9dtuZGDe94DfJsmRoTV1dVxcXE//fTT/v37RR8IAL5DC9duerYO7L0bKtZPWuMeOrmvnWLTh3sA4FNNjAjLysrmzJnz75NlAECcMZTV7EPmWviN87q+csu6Tck5NXQnApAMTRShjo6Orq7umzdvRJ8GAH6QTns3q/mbPFXLGfEhUafvf8SkbABf0kQRMpnMZcuWzZ8//+nTp6IPBAA/iKGkah882zwgqF/ymu1R6xNfVdGdCECsNf0xwl9//VVcXGxra2tpadmiRYvGV9ZfuHBBVNkA4PvpOHTUsmzL27+lenPIig7TJ3k7qcnSnQlALP3n5+kODg6izAEAAsdQUG47PrwkI03xYMzep06W/hN6mSnRHQpA7DRRhDweb/PmzQoKCphFEKAZ0LBzVmuziXdwW83mkJUdpoYM6IChIUBjTXxG+P79e01NzatXr4o+DQAIA0Neqe2Y6eaBYd531x9cs/bMs3K6EwGIkSaKUE1NjclkYk5RgGZGw8bRJjKhq5Fci22TlhxMKcLlFQCEkCaLUFFRcdCgQfv27RN9GgAQKkpOwWb0FPOxswZlbjketer0kzK6EwHQr+mTZby9vcPDw7Ozs729vfX09Bp/CbOsAUg6VUt7mwUJjCM763ZMWu4QEjTYXQsHgECKNXFjXkKIvr5+fn5+k9/Q5PriBjfmBfga5c8y3+xZd1vWXGPwJF8b9W/6XtyYF+gi8Be9pkeEN2/e5HA4AtwNAIgh1Ta2bRdskjm2p27XpMVtgyb6ddNXoDsTgMg1XYQmJiYizgEAtKBkZK38x390dR+0e9351VcVB032s9OiOxSASP3jZJnHjx8XFBT816rZ2dnHjh0TfiQAEDUlUyvbees72hhZ752ybE9iHiZlA2nyjyLs27fv9u3b+Y95PJ66uvrx48cbvpqUlDRkyBCRpgMAUaFkZC39xrSavMj75aHENZEH0osk4HQAAEFo+sa8hBAej1dWVlZXVyfKNABAL2UTC7v5G1zszO33T1my43z2R7QhNH//WYQAIJ0oJqvNoNGtpy3zyTl1Y838/fcK6U4EIFwoQgBogryRud28WGcHK4cDU5ZuPfu6nEt3IgBhQRECQNMoJqu1z0jz0FUD3p+9vTZi5833OE4KzdKnl088e/bs/Pnz5P8vnH/w4IGGhgb/Sw8ePBBxOACgnbxhK/t50cpnjtQcm740feTIAC9TVbyBhmblHzPLmJiYvH379vPfgJllxA1mlgHRqM17+2TnuhfVcqVe0392NeDUY2YZoIdwZ5ZJSEj4+PGjALcOAM2GXAvjdnPWqZw/XnssdPm94YP8+psp050JQBD+UYT9+vWjKwcASAAGw6zfkLr2nbx3rHsRk3Sl19Tgrq0YFN2pAH4MjvUDwLeR1TVsNzuqbWe37n/MWrXxaFYpTigFyYYiBIBvR1Etew4wCl3dr/Lms6gZm6+9qUcbgsRCEQLAd2Jp6TvMWm3X3bPr6V9Wbzj06ANuWQMSCUUIAD+Aoox7eLf+Nb5/7b2cdaGbrr7C0BAkDooQAH6UjKaew4wV1j37evw5Jyr+wIOieroTAXwDFCEACAJFGXX3spi7vh8nM3/d9PhLL9gYGoKEQBECgMAw1XXahS+z6Teg5/l5MbF77hey6U4E8GUoQgAQMMMufSzmbehFPf8QPS3uQlYtzqEB8YYiBADBY6ppOYQutv7Jr9fFyPiYnXfycWdTEF8oQgAQlhZunhbzNvaSfVsZMzX2/GMMDUE8oQgBQIiYqhrtpka2GRjQ+/LiDdFbb+bW0p0I4FMoQgAQOoOOHpYRCZ6KBfVxk2L+fFiDoSGIExQhAIgCQ1nNYdK81kPG9E5avnltQkpODd2JAP6GIgQA0dFzdrean+ChWkbFh6w7fb8KV96DGPj0DvUAAELFUFJtFzy78F6q6qHV2x+7tQ8Y62akQHcokGoYEQIADXQcO1ot2NxVvZq1PmTtybsfMTQE+mBECAD0YCgqt5s4s+jBbaWD0bseO9sHTOhiokh3KJBGGBECAJ207TtYRyZ00eHJbwyOOn67ApOygchhRAgANGPIK9mPC/2QeVdhf+z+J/aWw4O6t1KmOxRIEYwIAUAsaNk62UYmuBnIqm4MiTpysxxDQxAVjAgBQFxQcgr2P08teXxfbl/MoaxrpsOCe7ZWoTsUNH8YEQKAeNGwbmcbuamjsbLWluA1h5PLMF83CBmKEADEDiUrbzcqpNX4X/s82H581Yq/ssroTgTNGYoQAMSUhkVbu8hNHcy09LaGRB28WoqhIQgHihAAxBclI9t2xMRWwQt6Pd53cuXSc0+L6U4EzRCKEADEnZq5lf38De0tDAy2T16zL7EYt3ICgUIRAoAEoGRk2/qPbRWyqNezQ2dXLvoj8wPdiaD5QBECgMRQNbVot2CDo00rk12T1+65UIRbOYEgoAgBQJJQTJaNX6DplGWer45fXDn/VEYh3YlA4qEIAUDyKJuYO0TE29tbmu2ZErXrbEEVj+5EIMHEcWaZ8vLyoqKihqfGxsYs1v9yvnr1isfjEULk5eUNDAxoyAcAYoBismwGjax06dxjx9prq5JYg6b5tNOnOxRIJHEswlu3bm3ZsoUQUl1dnZiYWFBQ0LgI27dv37NnT0KItbX1okWLaEsJAGJAuaWpY0Ss/Okj3H3T16WNGhHgpadI0R0KJIw4FmHPnj35Vbdv3z4tLS0lJaXGX9XQ0Dh8+DBN0QBA/DCY1gP9Pzq7ddu59sbKJOI7fZAjjhXBNxDrzwi3b98+duzYTxaWlpb26dNn5MiR9+/fpyUVAIghJUPj9nOjbTo4Wx4IW7ftZN5HfGoIX4vOEeGrV682bNjQeImJicnUqVMbvpqTk9OlS5dPvuvs2bMWFhYpKSkDBgx48OCBmpqaiOICgJhjMKy8/ao7dOq6fe2tVUl1A8L8nA3pzgQSgIYi/Pjxo7y8PJPJ1NTU9PLyavwlVVXVhsf84SBFfXq438XFhRDSr18/a2vrjIwMd3d3EWQGAEmhoN/See46lbO/cw6Fxdwd5jfc11BZrA99Ae2E8vfx+vXrESNGWFpaampq8s/w5CsoKPDw8DAyMtLW1o6Pj1dTU+v+T+3bt+evyeVy9+/fP3LkyIanJ0+eJIRUVFTU1tYSQvLz8x89emRqaiqM/AAg2SjKsv8gs19i3D+kpq+cceTWW7oDgVgT1hslNze3yMjIkpKSxgvnzJljbGxcVFSUmpo6f/78x48f/9e3p6amdunSxcjIiP+UzWbPnTuXEPL8+XMXFxdHR8fevXsvX77c0BDHPQCgafK6Bs5zVrfu2t32yMzYhMPZFRy6E4GYohqP2ATryZMn1tbWXC6Xf3iztrZWQ0MjNTXV3t6eEDJq1KiWLVuuWLFCGLv+888/R4wY4eTkxH9KUdSUKVN69eoljH3RrrKyUllZme4UIHXYbDaHw5GXl6c7yJfVfSh4djChuKK2qM9kHycDXF0h6b7pRU9eXr7xBXhNEt1nhHl5edXV1VZWVvyn1tbWwjvtU11d3cDA4Ndff21Y0rZtW0VFRSHtjl4cDqe5/mggziSoCBUVW3X4ZcXzxLPGp+fvyBg4cMQQY1VxvHIMvtI3vegxGF8+8Cm6v4bS0lIZGRlZWVn+U2Vl5eJiYd1ajMlkqqmpNdch4CcYDMbX/EsDCBaDweDxeBL0t2fR66daJ5eqHTHP1iSneIX7u5lhaCihBP6iJ7o/Yh0dHTabXVVVxX9aWlqqq6srsr0DAMhp6XaYucykh7f9779uiN/zpoxNdyIQC6IrQj09PS0trbt37/Kf3r1719bWVmR7BwAghBCKsvDs02bexg61z16smrb/2jNceA9CKUI2m33x4sWUlBRCyMWLF69du0YIYbFY48ePj4iIePXq1bFjxxITEwMDA4WxdwCAz5NV13KducSkz2CHPxZsitv5qqSO7kRAJ6GcNVpZWenr69vwtGF20Jqamjlz5pw7d05LS2vhwoXC+wwvNTU1LCyM38TNXkVFhYqKCt0pQOpI0Mkyn1FXVnxvR3x1QW5O37DhXa0Y+NhQEgj8RU+Il0/QCEUIIGzNowj5Xly/XH16S1KLHr1HjTLXkqM7DnyBwF/0JOaMLwAAITF3724VscmRev9uzZR9iZncZjg6gM9BEQIAEJaKesfpEUY+oxzOL9sas/nZh1q6E4HooAgBAP5m2rGr1fwEe5mSwjUhey5mcDA0lA4oQgCA/2Epq3aaMqeF73jHCyt3rNuQVVRNdyIQOhQhAMCnTF3dbCI3t1WoKlkTsvd8OoaGzRuKEACgCUxF5U6TftEfOqnd5bW7o+KeFFTRnQiEBUUIAPCfTNq72C5MsFapr4gK3n32Tj2X7kAgBChCAIDPYcordQoO1wuY1u5a7N6o6EfvK+lOBAKGIgQA+DJjR2f7hZstNZhV64J3/3ELQ8PmBEUIAPBVGHIKbhOm6Y2c2S55w4HVax7mVtCdCAQDRQgA8A2M7B3aLdzcWkexLjpo16kUNoaGkg9FCADwbShZebdxk3XH/Gp/c+uhlase5JTRnQh+CIoQAOB7tLSxc4zcZNpCnRMXsvvEdQwNJReKEADgO1Gycp3HBOmNmWebtuvoiuX3s0vpTgTfA0UIAPBDDKxt20duNDHSJXEhu45drsPQUNKgCAEAfhQlI+s2erzOhIW29w6eWL4o/U0x3YngG6AIAQAEw8DC0nnhBqNWJoz1k/ccuVjLoTsQfB0UIQCAwFAsmU4jf9YLXmKZcez0ssg7L4voTgRfhiIEABAwPfPWLpHxBq1by26avPvQ+RoMDcUbihAAQPAoJstt+CjdkBUWj06dWzov7XkB3YngP6EIAQCERc/MrOOCWB0rW7nNU/ce+KOmHjc2FEcoQgAAIaKYrM7DhutNWW2e9ddfS3+99ew93YngUyhCAACh0zUxcVsQo23rpLBl+p59p6rZGBqKERQhAIBIMBhufkP1p0aZv0hMXDrr5pNcugPB31CEAACio2Ns1HlBtGa7jkrbQvftPl6FoaEYQBECAIgWRXUaNLhFeEyrtzeuLZmR+jiH7kDSDkUIAEADLQMD94goNaeuytvD9+08XIUpSumDIgQAoAlFdfLx0Z8Ra5R75/qSsOSHb+gOJKVQhAAAdNJu0aLb3JWqLr1Uds/av/1gJaYoFTkUIQAA3Siqo/dPhjPiDQsybi4OvfHgFd2BpAuKEABALGjq63rMWabU2Utlz68Ht+2tqKmnO5G0QBECAIgNiurYv6/xnA16RU/Tlky7kf6c7kBSAUUIACBe1LW1POcsVezqq7ov4uDmPeUYGgoZihAAQBy59ull9OtG3bKX9xZNTrr7lO44zRmKEABATKlrafaYtVC+xzD1gwsPJewoq6qjO1HzhCIEABBrrj09jX/dqFXxLmPp5KRbj+mO0wyhCAEAxJ2apkbPX+bL9h6lemTJ4Q1byj5iaChIKEIAAMng4tHVdF6Cem1R5pLgK6kP6Y7TfKAIAQAkhqq6au/wuaz+49SPrziyflNpZS3diZoDFCEAgIRx6dq5dUSCSn3l06VBV5Lv0x1H4qEIAQAkj7KqSt/QX5g/haidXHMsNr6kvJruRBIMRQgAIKmc3V3bRCQokbpny4KvJN2lO46kQhECAEgwZRXlvtNnMHymKv8Zczwmpqisiu5EkgdFCAAg8Zw7OVtHJMizqNfLghOv3KI7joRBEQIANAdKyor9p0ynBoepnttwYt3awpJKuhNJDBQhAEDz0d7V0WZ+goy8fPaK4MTLqXTHkQwoQgCAZkVRScFr0mQydJby+c0no1YVlFTQnUjcoQgBAJohJ2f7tgsSGEpq71YEXbpwg+44Yg1FCADQPCkqynmHBFP+cxUTd/yxenlBURndicQUihAAoDlzcGrrELmJp66Tuyrk0rmrdMcRRyhCAIBmTkFe1nviBDJyvsK1fX+uXPy+sITuROIFRQgAIBUc2lk7RW7kaLUsWD3p4plEuuOIERQhAIC0kJeTGTBhLG/0Irkbh8+uiMwrKKY7kVhAEQIASJd2dhYuC9fX6bcuXD3p4um/6I5DPxQhAIDUkZNhDRwzioxZJnPzxPllEXl5RXQnohOKEABAStnbmneMjKs2tC5aN/niqbOEx6M7ET1QhAAA0ktOhuXz8wgybhXz9pkLy+a+y8mnOxENUIQAANLOzqqVe2TMRxOH4thpF34/LW1DQxQhAAAQGRbTZ9QwxoQ11L1Ll5bOzsnOpTuR6KAIAQDgb7YWxt0WrCs3dSmNDb149ARPOoaGKEIAAPgfGRbDd+QQRvA6bkbSlcUz377JoTuR0KEIAQDgUzatW3ouiCq16FIWP+PC4WM8LpfuREKEIgQAgCawmJRvgA9rUjTn8c2ri8Nfv3xDdyJhQRECAMB/sjYz6Bmxqti6R8XGWRcPHuJxOXQnEjwUIQAAfA6LSQ0a5i07Ja7uWfr1RaGvn7+iO5GAoQgBAODLLFvp9YlYXmjfvyJhzsV9B7iceroTCQyKEAAAvgqTQQ0a3E9u+vrq14+SF017lfWC7kSCgSIEAIBvYGGk4zVvaYGDT8WWeRf37OHUS/zQEEUIAADfhkGRQYN6K4Su//j2xc2FU148yaI70Q9BEQIAwPdo01Lbe96i/A5+H7dHXty1k8Nm053oO6EIAQDgOzEo4juwh1LYhorc7LSFk55nPqY70fdAEQIAwA8xN9Ac+OuCXNeRH3ctvrR9a31dHd2Jvg2KEAAAfhSDIr4DuqnO2FRaUHh3YcizjId0J/oGKEIAABAMU331Qb/Ofdd5bOXe5Ze2JtTX1tKd6KugCAEAQGAoQny9OqvPTPhQXJa+MDjr/gO6E30ZihAAAATMVFfVb/bsHI+giv2rEjdvYFdX053oc1CEAAAgeBQhPn06as9KKCivzlgc/PTOPboT/ScUIQAACIuJtsqwX2a+7T6l/NC6S5ti66qq6E7UBBQhAAAIEUWIT+8O+nMSCj5yHy4OfnzrNt2JPoUiBAAAoTPSVAqYGZbdO7TyWPzl9etqP1bSneh/UIQAACAiAz2dDOYkvKuTebw45PHNm3TH+RuKEAAARMdQQ3Fk+NQ3/WaW/b7pcvzq2soKuhOhCAEAQOQGerQznpOQw1V5uiQ488YNesOgCAEAgAYG6vKjpoe88ZpTemr7lZgVNeXldCVBEQIAAG28u9qZz0t4w9TOWhr88No1WjKgCAEAgE76qrKBUydkD4woObP36rqlNWWlIg6AIgQAAPp5dbaxmLvhlazB86UhD65cFuWuUYQAACAW9FRlf54y9u2QyOLzvyVFLawqKRbNflGEAAAgRvq7WtlEbHihZPpi+aT7Fy+IYI8oQgAAEC+6SqyfQwLfDV3yIfH3IO9BnAAACDxJREFUpNXzPxYVCXV3KEIAABBHfTu0sY+Ie6Zq+WrV5PTz5wiPJ6QdoQgBAEBMaSuyxgaPzPVfUXTtz+ur5lUUFAhjLyhCAAAQa73bm7WPiMnSsnuzZuq9M38IfGiIIgQAAHGnocAcOyHg/fDV+ckX0uOXcurrBbhxlgC3BQAAIDw9HU1KraNPnrnWiWIKcLMYEQIAgMRQl2cM6tWexaQEuE0UIQAASDUUIQAASDUUocQ7dOgQT2iX1wD8l2fPnt2+fZvuFCCNjhw5wuFwBLhBFKHECw8Pr6ig/xbPIG3Onz9/6NAhulOANJozZ86HDx8EuEEUIQAASDUUIQAASDUUIQAASLXmeUF9cXFxZmams7Mz3UFEoaqqysPDg8HAexoQqYKCgtra2tTUVLqDgNQpLS3t3bs3i/VV/RUQEDBjxozPr0M1yxMO6+vrL1y4oKurS3cQUXj//r2+vj7dKUDqVFdXs9lsVVVVuoOA1PmmFz1DQ8Mvrtw8ixAAAOAr4XgaAABINRQhAABINRQhAABIteZ51qjU4nA427Zty8jIcHNzGz58ON1xQIpcu3Zt+/bt+fn5Tk5O8+bNU1JSojsRSAUulxsaGpqVlaWoqBgUFNSnT5/v2AhGhM0Kh8MpKytTUFC4fv063VlAuhQWFk6aNGnv3r0VFRURERF0xwEpMmjQoL179y5atGj8+PG5ubnfsQUUYbMiKys7a9YsR0dHuoOA1Bk8eLCrq6uOjs7AgQNfvnxJdxyQFgwGw8PDQ0dHx9bWVlNTs7a29ns2IvBYACC1OBzOqlWrxo4dS3cQkCIcDqdnz57m5uaDBw82NTX9ji2gCAFAMHg83oQJEzp16jRw4EC6s4AUYTKZf/3115kzZw4fPvzo0aPv2AJOlpEY+fn5aWlp79698/X11dHRaVj+5MmTQ4cOMRiMkSNHft+7IYDPqKmpSU9Pf/TokaWlZefOnRuWV1dX79y5Mzs7293d3cvLi8fjTZo0SUtLa/HixTSmhebk1atXaWlpJSUl48ePbzyL5PXr18+dO6ehoTFmzBhNTU1CCIPBsLa27tSpU0ZGho2NzbfuCDPLSIaamhotLS0HB4dbt26lpKQ0TKP68OHDzp07T506ta6ubtu2bWlpacnJyVeuXHn+/Pnw4cP9/f0xAxb8oBEjRqSlpdXV1Xl5ea1fv75huYeHh7y8fO/evTds2DBp0qSqqqq9e/fOnDmTEKKjo+Pr60tfZGgOUlNT+/XrZ2lpefPmTTab3TCz6LFjx4KDg3/55Zf79++npaUdOnTo3LlzNjY2r169iouLS05O1tPT+9Z9YUQoGeTk5MrKylgsloqKSuPl69atGzdu3NKlSwkhxcXF8fHx7du3d3FxcXFxoSkpNDe7d+9msVhTp05t/Kb52rVrT548efPmjZycnIuLy+DBg3fv3v0dL0AA/8XZ2bmkpOT58+dt2rRpvHzZsmVRUVGBgYE8Hs/V1fXmzZsGBgbp6ek6OjqpqamNj5Z9PRShZKAoqsmp1q9cubJp0yb+4z59+ixbtiw6Olq00aCZ+68/vO7du8vJyRFC3NzcqqurdXV1+/btK/J00Gw1+YdXVlZ27949/sWCFEX17t07JSVl165dP7gvnCwj2fLy8hreAenp6X3fNTQA3yovL6/h7i4MBkNHRwd/eyACeXl5FEUJ/EUPRSjZWCwWl8vlP66vr5eRkaE3D0iJxn94hBAOh4O/PRABFovF4/EE/qKHIpRsLVq0aHhDlJuba2BgQG8ekBIGBgbv3r3jP2az2QUFBfjbAxFo0aIFRVF5eXn8p7m5uS1atPjxzaIIJZuXl9exY8f4j48dO+bl5UVvHpASXl5eiYmJJSUlhJCzZ8/q6+vb2trSHQqaPyUlpW7duvFf9Orq6k6fPv3TTz/9+GZx+YTECAwMzM3NvXz5cvv27VVVVQ8cOKCjo5Odnd2pUyc3N7e6urqMjIyUlJSGT24ABGL//v27du16+vQpj8ezsrIKDAwcOXIkISQwMPDOnTtdunQ5duxYXFycv78/3UmhWamurh4wYEBVVVVycnKPHj3U1NT4/ZeUlOTj4+Pr6/vo0SM5ObkLFy40eVrNN0ERSowbN25UV1c3PHV3d5eXlyeElJaWnjt3jsVi9enT55OLKwB+3KtXr168eNHw1NzcnD9vA4/Hu3r16qtXr9zc3CwtLekLCM0Th8O5fPlyw1MZGZlu3brxH+fk5CQmJmpra/fq1UsgnxGiCAEAQKrhM0IAAJBqKEIAAJBqKEIAAJBqKEIAAJBqKEIAAJBqKEIAAJBqKEIAAJBqKEIAAJBqKEIAAJBqKEIAAJBquEM9QHPw7t27P//809fX9/Xr16dOneJyuUOGDHF0dOTxeKdPn75x44auru6IESP09fXpTgogdjDXKEBzcOHChd69e0+aNOnQoUP29vZZWVkFBQXnz5/fs2fPxYsXLSws7ty5o6ysnJ6erq2tTXdYAPGCQ6MAzceVK1cePXqUmJj45MkTIyOjIUOGVFVVvXjx4tKlSykpKfn5+Vu2bKE7I4DYQRECNB+zZ8/m35BSWVm5f//+xcXFK1askJWVJYRYW1vb2dk9ePCA7owAYgdFCNB8WFhYNDzW0tKSkZHh3zuQT1NTs6ioiI5cAGINRQjQfHxyq24mk0lRVMPTxo8BoAGKEAAApBqKEAAApBqKEAAApBouqAdoDlq1ajV79uzG18u7u7vX19c3XmfYsGEizwUgAXBBPQAASDUcGgUAAKmGIgQAAKmGIgQAgP9rrw4EAAAAAAT5Ww9ySbQmQgDWRAjAWv3ihmpqQZ+ZAAAAAElFTkSuQmCC", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = plot()\n", + "xlabel!(\"m\")\n", + "ylabel!(\"Error\")\n", + "plot!(M, E; xscale = :log10, yscale = :log10, label = \"Curve length error\")\n", + "\n", + "ε = log.(E)\n", + "μ = log.(M)\n", + "k = (dot(ε, μ) - sum(ε)*sum(μ)/length(M))/(dot(μ,μ) - (sum(μ)^2)/length(M))\n", + "C = exp((sum(ε) - k*sum(μ))/length(M))\n", + "\n", + "\n", + "plot!(M, @. C * M^k; label = \"$(round(C, digits = 5)) × m ^ $(round(k, digits = 3))\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.11.3", + "language": "julia", + "name": "julia-1.11" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/DataInterpolations.jl b/src/DataInterpolations.jl index 749e4bd5..2996d84f 100644 --- a/src/DataInterpolations.jl +++ b/src/DataInterpolations.jl @@ -112,8 +112,8 @@ _output_dim(::AbstractArray{<:Any, N}) where {N} = N - 1 # each value is an arra export LinearInterpolation, QuadraticInterpolation, LagrangeInterpolation, AkimaInterpolation, ConstantInterpolation, QuadraticSpline, CubicSpline, BSplineInterpolation, BSplineApprox, CubicHermiteSpline, PCHIPInterpolation, - QuinticHermiteSpline, LinearInterpolationIntInv, ConstantInterpolationIntInv, - ExtrapolationType + QuinticHermiteSpline, SmoothArcLengthInterpolation, LinearInterpolationIntInv, + ConstantInterpolationIntInv, ExtrapolationType export output_dim # added for RegularizationSmooth, JJS 11/27/21 diff --git a/src/derivatives.jl b/src/derivatives.jl index 2ec303df..4b02673c 100644 --- a/src/derivatives.jl +++ b/src/derivatives.jl @@ -300,3 +300,37 @@ function _derivative( (3c₁ + (3Δt₁ + Δt₀) * c₂ + (3Δt₁^2 + Δt₀ * 2Δt₁) * c₃) out end + +function _derivative(A::SmoothArcLengthInterpolation, t::Number, iguess) + (; out) = A + idx = get_idx(A, t, iguess) + Δt_circ_seg = A.Δt_circle_segment[idx] + Δt_line_seg = A.Δt_line_segment[idx] + short_side_left = A.short_side_left[idx] + Δt = t - A.t[idx] + + in_circle_arc = if short_side_left + Δt < Δt_circ_seg + else + Δt > Δt_line_seg + end + + if in_circle_arc + t_circle_seg = short_side_left ? Δt : Δt - Δt_line_seg + S, C = sincos(t_circle_seg / A.radius[idx]) + v₁ = view(A.dir_1, :, idx) + v₂ = view(A.dir_2, :, idx) + Rⱼ = A.radius[idx] + @. out = (-S * v₁ + C * v₂) / Rⱼ + else + if short_side_left + d₁ = view(A.d, :, idx + 1) + @. out = d₁ + else + d₀ = view(A.d, :, idx) + @. out = d₀ + end + end + + out +end diff --git a/src/interpolation_caches.jl b/src/interpolation_caches.jl index aab592d1..78bd170b 100644 --- a/src/interpolation_caches.jl +++ b/src/interpolation_caches.jl @@ -1325,3 +1325,261 @@ function QuinticHermiteSpline( ddu, du, u, t, I, p, extrapolation_left, extrapolation_right, cache_parameters, linear_lookup) end + +""" + Signature... + +Interpolate in a C¹ smooth way trough the data with unit speed. + +## Arguments + +... + +## Keyword Arguments + +... +""" +struct SmoothArcLengthInterpolation{ + uType, tType, IType, P, D, S <: Union{AbstractInterpolation, Nothing}, T} <: + AbstractInterpolation{T} + u::uType + t::tType + d::Matrix{D} + shape_itp::S + Δt_circle_segment::Vector{P} + Δt_line_segment::Vector{P} + center::Matrix{P} + radius::Vector{P} + dir_1::Matrix{P} + dir_2::Matrix{P} + # short_side_left[i] = true means that the line segment comes after the circle segment + short_side_left::Vector{Bool} + I::IType + p::Nothing + extrapolation_left::ExtrapolationType.T + extrapolation_right::ExtrapolationType.T + iguesser::Guesser{tType} + cache_parameters::Bool + linear_lookup::Bool + out::Vector{P} + function SmoothArcLengthInterpolation( + u, t, d, shape_itp, Δt_circle_segment, Δt_line_segment, + center, radius, dir_1, dir_2, short_side_left, + I, extrapolation_left, extrapolation_right, + assume_linear_t, out) + linear_lookup = seems_linear(assume_linear_t, t) + new{typeof(u), typeof(t), typeof(I), eltype(radius), + eltype(d), typeof(shape_itp), eltype(u)}( + u, t, d, shape_itp, Δt_circle_segment, Δt_line_segment, + center, radius, dir_1, dir_2, short_side_left, + I, nothing, extrapolation_left, extrapolation_right, + Guesser(t), false, linear_lookup, out + ) + end +end + +function SmoothArcLengthInterpolation( + u::AbstractMatrix{U}; + t::Union{AbstractVector, Nothing} = nothing, + interpolation_type::Type{<:AbstractInterpolation} = QuadraticSpline, + kwargs... +) where {U} + if isnothing(t) + # Compute default t based on point distances + N, n = size(u) + t = Vector{U}(undef, n) + t[1] = zero(U) + Δu = Vector{U}(undef, N) + for i in 2:n + @. Δu = u[:, i] - u[:, i - 1] + t[i] = t[i - 1] + norm(Δu) + end + end + shape_itp = interpolation_type(collect.(eachcol(u)), t) + SmoothArcLengthInterpolation(shape_itp; kwargs...) +end + +function SmoothArcLengthInterpolation( + shape_itp::AbstractInterpolation; m::Integer = 2, + kwargs... +) + (; u, t) = shape_itp + T = promote_type(eltype(eltype(u)), eltype(t)) + + # Resp. the output dimensionality and the number of data points in the original interpolation + N = length(first(u)) + n = length(u) + + # Number of points defining the tangent curve of itp + n_tilde = m * (n - 1) + 1 + + # The evaluations of itp + u_tilde = Matrix{T}(undef, N, n_tilde) + d_tilde = Matrix{T}(undef, N, n_tilde) + + j = 1 + + for i in 1:(n - 1) + for t_eval in range(t[i], t[i + 1], length = m + 1)[1:(end - 1)] + u_tilde[:, j] .= shape_itp(t_eval) + d_tilde[:, j] .= derivative(shape_itp, t_eval) + normalize!(view(d_tilde, :, j)) + j += 1 + end + end + + u_tilde[:, end] .= shape_itp(last(t)) + d_tilde[:, end] .= derivative(shape_itp, last(t)) + normalize!(view(d_tilde, :, n_tilde)) + + # Number of points in the augmented tangent curve of itp + n_hat = 2 * n_tilde - 1 + + # The data defining the augmented tangent curve of itp + u_hat = Matrix{T}(undef, N, n_hat) + d_hat = Matrix{T}(undef, N, n_hat) + + k = 1 + Δu_tilde = Vector{T}(undef, N) + u_tilde_j_close_left = Vector{T}(undef, N) + u_tilde_j_close_right = Vector{T}(undef, N) + u_tilde_j_int = Vector{T}(undef, N) + u_tilde_j_int_left = Vector{T}(undef, N) + u_tilde_j_int_right = Vector{T}(undef, N) + + for j in 1:(n_tilde - 1) + u_hat[:, k] .= u_tilde[:, j] + d_hat[:, k] .= d_tilde[:, j] + + u_tilde_j = view(u_tilde, :, j) + d_tilde_j = view(d_tilde, :, j) + u_tilde_j_plus_1 = view(u_tilde, :, j + 1) + d_tilde_j_plus_1 = view(d_tilde, :, j + 1) + d_tilde_inner = dot(d_tilde_j, d_tilde_j_plus_1) + + @. Δu_tilde = u_tilde_j_plus_1 - u_tilde_j + + inner_1 = dot(Δu_tilde, d_tilde_j) + inner_2 = dot(Δu_tilde, d_tilde_j_plus_1) + denom = 1 - d_tilde_inner^2 + d_tilde_j_coef = (inner_1 - d_tilde_inner * inner_2) / denom + d_tilde_j_plus_1_coef = (d_tilde_inner * inner_1 - inner_2) / denom + + if !((d_tilde_j_coef >= 0) && (d_tilde_j_plus_1_coef <= 0)) + error("Some consecutive tangent lines do not converge, consider increasing m.") + end + + @. u_tilde_j_close_left = u_tilde_j + d_tilde_j_coef * d_tilde_j + @. u_tilde_j_close_right = u_tilde_j_plus_1 + + d_tilde_j_plus_1_coef * d_tilde_j_plus_1 + @. u_tilde_j_int = (u_tilde_j_close_left + u_tilde_j_close_right) / 2 + + # compute δ_star + δ_j = min( + euclidean(u_tilde_j_int, u_tilde_j), + euclidean(u_tilde_j_int, u_tilde_j_plus_1) + ) + δ_j_star = δ_j * (2 - sqrt(2 + 2 * d_tilde_inner)) / (1 - d_tilde_inner) + + # Compute the points whose connecting line defines the tangent curve augmenting point + @. u_tilde_j_int_left = u_tilde_j_close_left - δ_j_star * d_tilde_j + @. u_tilde_j_int_right = u_tilde_j_close_right + δ_j_star * d_tilde_j_plus_1 + + # Compute tangent curve augmenting point + u_tilde_j_plus_half = view(u_hat, :, k + 1) + d_tilde_j_plus_half = view(d_hat, :, k + 1) + + @. u_tilde_j_plus_half = (u_tilde_j_int_left + u_tilde_j_int_right) / 2 + @. d_tilde_j_plus_half = u_tilde_j_int_right - u_tilde_j_int_left + normalize!(d_tilde_j_plus_half) + + k += 2 + end + + u_hat[:, end] .= u_tilde[:, end] + d_hat[:, end] .= d_tilde[:, end] + + return SmoothArcLengthInterpolation(u_hat, d_hat; shape_itp, kwargs...) +end + +function SmoothArcLengthInterpolation( + u::AbstractMatrix, + d::AbstractMatrix; + shape_itp::Union{AbstractInterpolation, Nothing} = nothing, + extrapolation::ExtrapolationType.T = ExtrapolationType.None, + extrapolation_left::ExtrapolationType.T = ExtrapolationType.None, + extrapolation_right::ExtrapolationType.T = ExtrapolationType.None, + cache_parameters = false, assume_linear_t = 1e-2) + # Note: this method assumes that consecutive tangent lines are coplanar, + # which is generally not the case for >2 dimensional points. Use the other constructors + # to make sure this is satisfied. + + N = size(u, 1) + n_circle_arcs = size(u, 2) - 1 + + P = promote_type(eltype(u), eltype(d)) + t = zeros(P, n_circle_arcs + 1) + Δt_circle_segment = zeros(P, n_circle_arcs) + Δt_line_segment = zeros(P, n_circle_arcs) + center = Matrix{P}(undef, N, n_circle_arcs) + radius = Vector{P}(undef, n_circle_arcs) + dir_1 = Matrix{P}(undef, N, n_circle_arcs) + dir_2 = Matrix{P}(undef, N, n_circle_arcs) + short_side_left = zeros(Bool, n_circle_arcs) + + # Intermediate results + Δu = Vector{P}(undef, N) + u_int = Vector{P}(undef, N) + + # Compute circle segments and line segments + for j in 1:n_circle_arcs + uⱼ = view(u, :, j) + uⱼ₊₁ = view(u, :, j + 1) + @. Δu = uⱼ₊₁ - uⱼ + + dⱼ = view(d, :, j) + dⱼ₊₁ = view(d, :, j + 1) + d_inner = dot(dⱼ, dⱼ₊₁) + + dⱼ_coef = (dot(Δu, dⱼ) - d_inner * dot(Δu, dⱼ₊₁)) / (1 - d_inner^2) + @. u_int = uⱼ + dⱼ_coef * dⱼ + + dist₁ = euclidean(u_int, uⱼ) + dist₂ = euclidean(u_int, uⱼ₊₁) + + δⱼ = if dist₁ < dist₂ + short_side_left[j] = true + dist₁ + else + dist₂ + end + + Rⱼ = δⱼ * sqrt((1 + d_inner) / (1 - d_inner)) + radius[j] = Rⱼ + cⱼ = view(center, :, j) + v₁ = view(dir_1, :, j) + v₂ = view(dir_2, :, j) + + @. cⱼ = u_int + δⱼ * (dⱼ₊₁ - dⱼ) / (1 - d_inner) + @. v₁ = -δⱼ * (dⱼ₊₁ - d_inner * dⱼ) / (1 - d_inner) + @. v₂ = Rⱼ * dⱼ + + Δt_circle_seg = 2Rⱼ * atan(δⱼ, Rⱼ) + Δt_line_seg = abs(dist₂ - dist₁) + Δt_circle_segment[j] = Δt_circle_seg + Δt_line_segment[j] = Δt_line_seg + + t[j + 1] = t[j] + Δt_circle_seg + Δt_line_seg + end + + extrapolation_left, extrapolation_right = munge_extrapolation( + extrapolation, extrapolation_left, extrapolation_right) + linear_lookup = seems_linear(assume_linear_t, t) + + out = Vector{P}(undef, N) + + return SmoothArcLengthInterpolation( + u, t, d, shape_itp, Δt_circle_segment, Δt_line_segment, + center, radius, dir_1, dir_2, short_side_left, + nothing, extrapolation_left, extrapolation_right, linear_lookup, out) +end diff --git a/src/interpolation_methods.jl b/src/interpolation_methods.jl index f2dd80ad..fd49ed3a 100644 --- a/src/interpolation_methods.jl +++ b/src/interpolation_methods.jl @@ -336,3 +336,40 @@ function _interpolate( out += Δt₀^3 * (c₁ + Δt₁ * (c₂ + c₃ * Δt₁)) out end + +function _interpolate(A::SmoothArcLengthInterpolation, t::Number, iguess) + (; out) = A + idx = get_idx(A, t, iguess) + Δt_circ_seg = A.Δt_circle_segment[idx] + Δt_line_seg = A.Δt_line_segment[idx] + short_side_left = A.short_side_left[idx] + Δt = t - A.t[idx] + + in_circle_arc = if short_side_left + Δt < Δt_circ_seg + else + Δt > Δt_line_seg + end + + if in_circle_arc + t_circle_seg = short_side_left ? Δt : Δt - Δt_line_seg + S, C = sincos(t_circle_seg / A.radius[idx]) + c = view(A.center, :, idx) + v₁ = view(A.dir_1, :, idx) + v₂ = view(A.dir_2, :, idx) + @. out = c + C * v₁ + S * v₂ + else + if short_side_left + u₁ = view(A.u, :, idx + 1) + d₁ = view(A.d, :, idx + 1) + t_line_seg = A.t[idx + 1] - t + @. out = u₁ - t_line_seg * d₁ + else + u₀ = view(A.u, :, idx) + d₀ = view(A.d, :, idx) + @. out = u₀ + Δt * d₀ + end + end + + out +end diff --git a/src/interpolation_utils.jl b/src/interpolation_utils.jl index 85edac07..f183a760 100644 --- a/src/interpolation_utils.jl +++ b/src/interpolation_utils.jl @@ -313,3 +313,8 @@ end typed_nan(::AbstractArray{T}) where {T <: AbstractFloat} = T(NaN) typed_nan(::AbstractArray{T}) where {T <: Integer} = zero(T) + +# Should be replaceable by LinearAlgebra function soon: https://github.com/JuliaLang/LinearAlgebra.jl/pull/1234 +function euclidean(x::AbstractArray, y::AbstractArray) + sqrt(mapreduce((xi, yi) -> abs2(yi - xi), +, x, y)) +end From 437284f04bcd8ec8a4680e8705cd692ab183f4a3 Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Thu, 20 Mar 2025 11:11:17 +0100 Subject: [PATCH 02/11] Transfer most of the notebook to the docs --- arclength_interpolation.ipynb | 1110 --------------------------- docs/Project.toml | 1 + docs/make.jl | 17 +- docs/src/arclength_interpolation.md | 491 ++++++++++++ docs/src/assets/Project.toml | 22 + 5 files changed, 526 insertions(+), 1115 deletions(-) create mode 100644 docs/src/arclength_interpolation.md create mode 100644 docs/src/assets/Project.toml diff --git a/arclength_interpolation.ipynb b/arclength_interpolation.ipynb index 536b5ce3..59387d90 100644 --- a/arclength_interpolation.ipynb +++ b/arclength_interpolation.ipynb @@ -1,1115 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Smooth arclength interpolation\n", - "\n", - "## The problem\n", - "\n", - "Say we have an ordered set of points $u_1, \\ldots, u_n \\in \\mathbb{R}^N$ and we want to make a lightweight $C^1$ smooth interpolation by arc-length $\\tilde{\\gamma}: [0,T] \\rightarrow \\mathbb{R}^N$ through these points. The first part is easy, just pick your favorite established interpolation method that achieves $C^1$ smoothness. The arc-length part however turns out to be quite [nasty](https://ijpam.eu/contents/2006-31-3/10/10.pdf). Here I propose a method that is quite general (the linked article only considers curves in $\\mathbb{R}^2$), and cheap to compute. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The 2-dimensional case\n", - "\n", - "2 is the smallest number of dimensions in which the posed problem is non-trivial. Say we use an established (non arc-length) interpolation method for our set of points to obtain the $C^1$ curve\n", - "\n", - "$$\n", - " \\gamma : [0, T] \\rightarrow \\mathbb{R}^2\n", - "$$\n", - "\n", - "for which \n", - "\n", - "$$\n", - " \\gamma(t_i) = u_i \\quad i = 1, \\ldots, n,\n", - "$$\n", - "\n", - "given a suitable set of 'time' values \n", - "\n", - "$$\n", - " 0 = t_1 < t_2 < \\ldots < t_n = T,\n", - "$$\n", - "\n", - "for instance\n", - "\n", - "$$\n", - " t_i = \\sum_{k=1}^{i-1} \\|u_{k+1} - u_k\\|_2.\n", - "$$\n", - "\n", - "We now want to approximate $\\gamma$ piecewise with sections that are trivially parameterizable by arc-length, namely line segments and circle segments. To do this, we fix some $m \\in \\mathbb{N}$ and define a refined set of time points $\\left(\\tilde{t}_j\\right)_{j=1}^{m(n-1) + 1}$ given by\n", - "\n", - "$$\n", - " \\tilde{t}_{m(k-1) + l} = t_k + \\frac{l}{m + 1}(t_{k+1} - t_k), \\quad k = 1 \\ldots n-1, \\; l = 1, \\ldots m.\n", - "$$\n", - "\n", - "In these refined time points we evaluate $\\gamma$ and its normalized derivative:\n", - "\n", - "$$\n", - " \\tilde{u}_j = \\gamma\\left(\\tilde{t}_j\\right), \\; \\tilde{d}_j = \\frac{\\dot{\\gamma}\\left(\\tilde{t}_j\\right)}{\\|\\dot{\\gamma}\\left(\\tilde{t}_j\\right)\\|_2}, \\qquad j = 1, \\ldots, m(n-1) + 1.\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As a first step to create the interpolation by arc length $\\tilde{\\gamma}$, we make a piecewise linear curve which is tangent to $\\gamma$ in $\\tilde{u}_j$ for each line segment, where we denote the intersection of consecutive tangent lines by $\\tilde{u}_{j, \\text{int}}$:\n", - "\n", - "$$\n", - " \\begin{align*}\n", - " \\tilde{u}_{j, \\text{int}} &=& \\tilde{u}_j + \\frac{\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_j \\\\\n", - " &=& \\tilde{u}_{j+1} + \\frac{\\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_{j+1}.\n", - " \\end{align*}\n", - "$$\n", - "\n", - "As expected this doesn't work for $\\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2 = 1$, which means that the consecutive tangent lines are parallel. In fact, in the above equation we want the coefficient of $\\tilde{d}_j$ to be positive and the coefficient of $\\tilde{d}_{j+1}$ to be negative, to ensure that $\\tilde{u}_{j, \\text{int}}$ lies properly in between $\\tilde{u}_j$ and $\\tilde{u}_{j+1}$." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "using DataInterpolations\n", - "using Plots\n", - "using Random\n", - "using LinearAlgebra\n", - "\n", - "Random.seed!(4)\n", - "\n", - "n = 4\n", - "m = 2\n", - "u = [rand(2) for _ in 1:n]\n", - "t = cumsum(norm.(diff(u)))\n", - "pushfirst!(t, 0)\n", - "\n", - "γ = QuadraticSpline(u, t)\n", - "\n", - "t_eval = range(first(t), last(t), length = 250)\n", - "u_eval = hcat(γ.(t_eval)...)\n", - "\n", - "t_tilde = zeros(m * (n - 1) + 1)\n", - "\n", - "for k in 1:(n-1)\n", - " t_tilde[m * (k - 1) + 1 : m * k] = range(t[k], t[k+1], length = m + 1)[1:(end - 1)]\n", - "end\n", - "\n", - "t_tilde[end] = t[end]\n", - "u_tilde = hcat(γ.(t_tilde)...)\n", - "\n", - "d_tilde = DataInterpolations.derivative.(Ref(γ), t_tilde)\n", - "normalize!.(d_tilde)\n", - "d_tilde = hcat(d_tilde...)\n", - "\n", - "n_intervals = length(t_tilde) - 1\n", - "intersection_points = zeros(2, n_intervals)\n", - "\n", - "u_tilde_j_int_1 = zeros(2)\n", - "u_tilde_j_int_2 = zeros(2)\n", - "\n", - "for j in 1:n_intervals\n", - " d_tilde_j = view(d_tilde, :, j)\n", - " d_tilde_j_plus_1 = view(d_tilde, :, j + 1)\n", - " d_inner = dot(d_tilde_j, d_tilde_j_plus_1)\n", - " u_tilde_j = view(u_tilde, :, j)\n", - " u_tilde_j_plus_1 = view(u_tilde, :, j + 1)\n", - " Δu = u_tilde_j_plus_1 - u_tilde_j\n", - "\n", - " coef_1 = (dot(Δu, d_tilde_j) - d_inner * dot(Δu, d_tilde_j_plus_1))/(1 - d_inner^2)\n", - " coef_2 = (d_inner * dot(Δu, d_tilde_j) - dot(Δu, d_tilde_j_plus_1))/(1 - d_inner^2)\n", - "\n", - " @. u_tilde_j_int_1 = u_tilde_j + coef_1 * d_tilde_j\n", - " @. u_tilde_j_int_2 = u_tilde_j_plus_1 + coef_2 * d_tilde_j_plus_1\n", - " @assert u_tilde_j_int_1 ≈ u_tilde_j_int_2\n", - "\n", - " intersection_points[:, j] .= u_tilde_j_int_1\n", - "end\n", - "\n", - "function plot_tangent_curve()\n", - " p = plot(; aspect_ratio = :equal, legend = :topleft, title = \"m = $m\")\n", - " \n", - " # Plot curve γ\n", - " plot!(u_eval[1,:], u_eval[2,:]; label = raw\"\\gamma\")\n", - "\n", - " # Plot original points\n", - " u_ = hcat(u...)\n", - " scatter!(u_[1,:], u_[2,:], label = raw\"$u_i$\"; markersize = 6, markerstrokewidth = 0)\n", - "\n", - " # Plot refined evaluation points\n", - " scatter!(u_tilde[1,:], u_tilde[2,:]; label = raw\"$\\tilde{u}_j$\", markerstrokewidth = 0)\n", - "\n", - " # Plot tangent curve\n", - " scatter!(intersection_points[1, :], intersection_points[2, :]; \n", - " markerstrokewidth = 0, markersize = 3, label = raw\"$\\tilde{u}_{j, int}$\")\n", - " plot!([u_tilde[1, 1], intersection_points[1, :]..., u_tilde[1, end]], \n", - " [u_tilde[2, 1], intersection_points[2, :]..., u_tilde[2, end]]; \n", - " label = \"Tangent curve\")\n", - " # xlims!(0,1)\n", - " # ylims!(0,1)\n", - " p\n", - "end\n", - "\n", - "plot_tangent_curve()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As a last step to obtain our curve by arc length $\\tilde{\\gamma}$ we want to get rid of the kinks in the tangent curve. We do this by replacing sections of the tangent curve by circle arcs. For each $\\tilde{u}_{j, \\text{int}}$ we compute the shortest distance to the neighboring evaluation points on $\\gamma$:\n", - "\n", - "$$\n", - " \\delta_j = \\min\\left\\{\n", - " \\|\\tilde{u}_j - \\tilde{u}_{j, \\text{int}}\\|_2, \n", - " \\|\\tilde{u}_{j + 1} - \\tilde{u}_{j, \\text{int}}\\|_2\n", - " \\right\\}.\n", - "$$\n", - "\n", - "From this we compute 2 points that are on the tangent curve and equidistant from $\\tilde{u}_{j + \\frac{1}{2}}$:\n", - "\n", - "$$\n", - " \\tilde{u}_{j, \\text{start}} = \\tilde{u}_{j, \\text{int}} - \\delta_j \\tilde{d}_j, \n", - "$$\n", - "\n", - "$$\n", - " \\tilde{u}_{j, \\text{end}} = \\tilde{u}_{j, \\text{int}} + \\delta_j \\tilde{d}_{j+1}.\n", - "$$\n", - "\n", - "Note that by this definition\n", - "\n", - "$$\n", - " \\tilde{u}_{j, \\text{start}} = \\tilde{u}_j \\quad \\vee \\quad \\tilde{u}_{j, \\text{end}} = \\tilde{u}_{j + 1}.\n", - "$$\n", - "\n", - "Now we can define a circle arc from $\\tilde{u}_{j, \\text{start}}$ to $\\tilde{u}_{j, \\text{end}}$ given the center\n", - "\n", - "$$\n", - " c_j = \\tilde{u}_{j, \\text{int}} + \\delta_j\\frac{\\tilde{d}_{j+1} - \\tilde{d}_j}{1 - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle}\n", - "$$\n", - "\n", - "and radius\n", - "\n", - "$$\n", - " R_j = \\delta_j\\sqrt{\\frac{1 + \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle}}.\n", - "$$\n", - "\n", - "We obtain the circle arc\n", - "\n", - "$$\n", - " c_j + \\cos\\left(\\frac{t}{R_j}\\right)v_{j, 1} + \\sin\\left(\\frac{t}{R_j}\\right)v_{j, 2}, \\quad t \\in [0, \\Delta t_{j, \\text{arc}}],\n", - "$$\n", - "\n", - "where\n", - "\n", - "$$\n", - " v_{j, 1} = -\\delta_j \\frac{\\tilde{d}_{j+1} - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle\\tilde{d}_j}{1 - \\langle\\tilde{d}_j,\\tilde{d}_{j+1}\\rangle},\n", - " \\quad\n", - " v_{j, 2} = R_j \\tilde{d}_j.\n", - "$$\n", - "\n", - "By this definition $\\|v_{j, 1}\\|_2 = \\|v_{j, 2}\\|_2 = R_j$ and $\\langle v_{j, 1}, v_{j, 2}\\rangle = 0$. Furthermore:\n", - "\n", - "$$\n", - " \\Delta t_{j, \\text{arc}} = R_j\\theta_{j, \\;\\max}= 2R_j \\arctan\\left(\\frac{\\delta_j}{R_j}\\right).\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "function mark_right_angle!(corner, dir1, dir2; l = 0.05)\n", - " points = zeros(3, 2)\n", - " points[1, :] = corner + l * dir1\n", - " points[2, :] = points[1, :] + l * dir2\n", - " points[3, :] = points[2, :] - l * dir1\n", - " \n", - " plot!(points[:, 1], points[:, 2]; color = :black, label = \"\")\n", - "end\n", - "\n", - "function plot_arc_construction(; indicate_delta = true)\n", - " p = plot(; aspect_ratio = :equal, axis = false)\n", - "\n", - " tu_j = [0.0, 0.2]\n", - " tu_j_int = [0.5, 0.6]\n", - " tu_j_plus_1 = [1.2, 0.3]\n", - " δⱼ = norm(tu_j_int - tu_j)\n", - " tu_j_start = tu_j\n", - " tu_j_end = tu_j_int + δⱼ * (tu_j_plus_1 - tu_j_int) / norm(tu_j_plus_1 - tu_j_int)\n", - "\n", - " td_j = tu_j_int - tu_j\n", - " normalize!(td_j)\n", - " td_j_plus_1 = tu_j_plus_1 - tu_j_int\n", - " normalize!(td_j_plus_1)\n", - " inner = dot(td_j, td_j_plus_1)\n", - " Δtd_j = td_j_plus_1 - td_j\n", - "\n", - " tc_j = tu_j_int + δⱼ / (1 - inner) * Δtd_j\n", - "\n", - " Rⱼ = δⱼ * sqrt((1 + inner)/(1 - inner))\n", - " vⱼ₁ = -δⱼ * (td_j_plus_1 - inner * td_j)/(1 - inner)\n", - " vⱼ₂ = Rⱼ * td_j\n", - " Δt_j_arc = 2 * Rⱼ * atan(δⱼ, Rⱼ)\n", - "\n", - " T_ = range(0, π/2; length = 100)\n", - " x_arc = @. tc_j[1] + cos(T_) * vⱼ₁[1] + sin(T_) * vⱼ₂[1]\n", - " y_arc = @. tc_j[2] + cos(T_) * vⱼ₁[2] + sin(T_) * vⱼ₂[2]\n", - " plot!(x_arc, y_arc; label = \"\", color = :gray, ls = :dash)\n", - " \n", - " T = range(0, Δt_j_arc, length = 100)\n", - " X_arc = @. tc_j[1] + cos(T/Rⱼ) * vⱼ₁[1] + sin(T/Rⱼ) * vⱼ₂[1]\n", - " Y_arc = @. tc_j[2] + cos(T/Rⱼ) * vⱼ₁[2] + sin(T/Rⱼ) * vⱼ₂[2]\n", - " plot!(X_arc, Y_arc; label = \"\", color = :black, linewidth = 2)\n", - "\n", - " x_arc = @. tc_j[1] + cos(T/Rⱼ) * vⱼ₁[1] / 7 + sin(T/Rⱼ) * vⱼ₂[1] / 7\n", - " y_arc = @. tc_j[2] + cos(T/Rⱼ) * vⱼ₁[2] / 7 + sin(T/Rⱼ) * vⱼ₂[2] / 7\n", - " plot!(x_arc, y_arc; label = \"\", color = :black)\n", - "\n", - " z = tc_j + vⱼ₂\n", - "\n", - " annotate!(tu_j..., \"\\n\\n\\n\" * raw\"$\\tilde{u}_j = \\tilde{u}_{j, \\mathrm{start}}$\")\n", - " annotate!(tu_j_int..., raw\"$\\tilde{u}_{j, \\mathrm{int}}$\" * \"\\n\\n\\n\")\n", - " annotate!(tu_j_end..., raw\"$\\tilde{u}_{j, \\mathrm{end}}$\" * \"\\n\\n\\n\")\n", - " annotate!(tu_j_plus_1..., \"\\n\\n\\n\" * raw\"$\\tilde{u}_{j + 1}$\")\n", - " annotate!((tu_j + td_j/5)..., raw\"$\\tilde{d}_j$\" * \" \")\n", - " annotate!((tu_j_plus_1 + td_j_plus_1/5)..., raw\"$\\tilde{d}_{j+1}$\" * \"\\n\\n\")\n", - " annotate!(tc_j..., \" \" * raw\"$\\tilde{c}_j$\")\n", - " annotate!(tc_j + vⱼ₁/2..., raw\"$v_{j,1}$\" * \" \")\n", - " annotate!(tc_j + vⱼ₂/2..., \"\\n \" * raw\"$v_{j,2}$\")\n", - " annotate!(tc_j..., raw\"$\\theta_{j, \\max}$\" * \" \\n\\n\\n\\n\\n\")\n", - " indicate_delta && annotate!((tu_j + tu_j_int)/2..., raw\"$\\delta_j$\" * \"\\n\\n\")\n", - "\n", - " mark_right_angle!(tu_j_start, td_j, normalize(tc_j - tu_j_start))\n", - " mark_right_angle!(tu_j_end, td_j_plus_1, normalize(tc_j - tu_j_end))\n", - " mark_right_angle!(tc_j, normalize(vⱼ₁), normalize(vⱼ₂))\n", - "\n", - " # u connections\n", - " points = hcat(tu_j, tu_j_int, tu_j_end, tu_j_plus_1)\n", - " plot!(points[1, :], points[2, :]; marker = :circle, c = :black, ls = :dash, label = \"\")\n", - "\n", - " # line segment\n", - " plot!([tu_j_plus_1[1], tu_j_end[1]], [tu_j_plus_1[2], tu_j_end[2]], c = :black, label = \"\", linewidth = 2)\n", - "\n", - " # td_j and td_j_plus_1\n", - " plot!([tu_j[1], tu_j[1] + td_j[1]/5], [tu_j[2], tu_j[2] + td_j[2]/5]; arrow=(:closed, 2.0), color = :black, label = \"\")\n", - " plot!([tu_j_plus_1[1], tu_j_plus_1[1] + td_j_plus_1[1]/5], [tu_j_plus_1[2], tu_j_plus_1[2] + td_j_plus_1[2]/5]; arrow=(:closed, 2.0), color = :black, label = \"\")\n", - "\n", - " # Circle segment radii\n", - " points = hcat(tu_j_start, tc_j, tu_j_end)\n", - " plot!(points[1, :], points[2, :]; color = :gray, label = \"\", ls = :dash)\n", - "\n", - " # v₂ⱼ\n", - " points = hcat(tc_j, tc_j + vⱼ₂)\n", - " plot!(points[1, :], points[2, :]; color = :gray, label = \"\", ls = :dash)\n", - "\n", - " # tc_j\n", - " scatter!([tc_j[1]], [tc_j[2]]; color = :gray, label = \"\")\n", - " ylims!(-0.65, 0.8)\n", - " return p, (; tu_j, tu_j_plus_1, tu_j_int, tu_j_start, tu_j_end, td_j, td_j_plus_1, inner, tc_j, δⱼ, Rⱼ)\n", - "end\n", - "\n", - "plot_arc_construction()[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p = plot_tangent_curve()\n", - "\n", - "δ = [min(\n", - " norm(intersection_points[:, j] - u_tilde[:, j]), \n", - " norm(intersection_points[:, j] - u_tilde[:, j+1])\n", - " ) \n", - " for j in 1:n_intervals\n", - "]\n", - "\n", - "u_tilde_start = zeros(2, n_intervals)\n", - "u_tilde_end = zeros(2, n_intervals)\n", - "\n", - "for j in 1:n_intervals\n", - " u_tilde_intⱼ = intersection_points[:, j]\n", - " u_tildeⱼ = u_tilde[:, j]\n", - " u_tildeⱼ₊₁ = u_tilde[:, j + 1]\n", - " d_tildeⱼ = d_tilde[:, j]\n", - " d_tildeⱼ₊₁ = d_tilde[:, j + 1]\n", - "\n", - " u_tilde_start[:, j] = u_tilde_intⱼ - δ[j] * d_tildeⱼ\n", - " u_tilde_end[:, j] = u_tilde_intⱼ + δ[j] * d_tildeⱼ₊₁\n", - "end\n", - "\n", - "scatter!(u_tilde_start[1, :], u_tilde_start[2, :]; markersize = 3, markerstrokewidth = 0, \n", - " label = raw\"$\\tilde{u}_{j, start}$\")\n", - "scatter!(u_tilde_end[1, :], u_tilde_end[2, :]; markersize = 3, markerstrokewidth = 0,\n", - " label = raw\"$\\tilde{u}_{j, end}$\")\n", - "\n", - "origins = zeros(2, n_intervals)\n", - "\n", - "for j in 1:n_intervals\n", - " u_tilde_intⱼ = intersection_points[:, j]\n", - " d_tildeⱼ = d_tilde[:, j]\n", - " d_tildeⱼ₊₁ = d_tilde[:, j + 1]\n", - " inner = dot(d_tildeⱼ, d_tildeⱼ₊₁)\n", - "\n", - " origins[:, j] = u_tilde_intⱼ + δ[j] / (1 - inner) * (d_tildeⱼ₊₁ - d_tildeⱼ)\n", - "\n", - " plot!([u_tilde_start[1, j], origins[1, j], u_tilde_end[1, j]], \n", - " [u_tilde_start[2, j], origins[2, j], u_tilde_end[2, j]]; \n", - " label = (j ==1) ? \"radii of circle arc\" : \"\", ls = :dash, c = :gray)\n", - "\n", - " Rⱼ = δ[j] * sqrt((1 + inner)/(1 - inner))\n", - " v₁ = -δ[j] * (d_tildeⱼ₊₁ - inner * d_tildeⱼ) / (1 - inner)\n", - " v₂ = Rⱼ * d_tildeⱼ\n", - " Δt = 2 * Rⱼ * atan(δ[j], Rⱼ)\n", - " T = range(0, Δt, length = 25)\n", - " x = @. origins[1, j] + cos(T/Rⱼ) * v₁[1] + sin(T/Rⱼ) * v₂[1]\n", - " y = @. origins[2, j] + cos(T/Rⱼ) * v₁[2] + sin(T/Rⱼ) * v₂[2]\n", - " plot!(x,y; c = :green, label = (j == 1) ? \"circle arc\" : \"\")\n", - "end\n", - "\n", - "scatter!(origins[1, :], origins[2, :]; label = raw\"$\\tilde{c}_j$\", c= :gray, markerstrokewidth = 0)\n", - "\n", - "p" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "That's pretty neat, but this method does not directly generalize to higher dimensional spaces. That is because in general the intersection points $\\tilde{u}_{j, \\text{int}}$ of the tangent lines do not exist." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The higher dimensional case\n", - "\n", - "Let's try to generalize the method above. The goal is to find a point $\\tilde{u}_{j + \\frac{1}{2}}$ and unit direction $\\tilde{d}_{j + \\frac{1}{2}}$ to add to the tangent curve between $\\tilde{u}_j$ and $\\tilde{u}_{j+1}$ such that:\n", - "\n", - "- the tangent line intersections $\\tilde{u}_{j, \\text{int left}}, \\tilde{u}_{j, \\text{int right}}$ exist. This means that the new line is fixed by these 2 points; \n", - "- constructing $\\tilde{\\gamma}$ including this point gives gives an identical result to constructing $\\tilde{\\gamma}$ excluding this point if the tangent line intersection already existed. The latter implies that $\\tilde{u}_{j + \\frac{1}{2}}$ and $\\tilde{d}_{j + \\frac{1}{2}}$ yield a tangent line to the constructed circle arc.\n", - "\n", - "Let's assume the tangent line intersection exists, and we define\n", - "\n", - "$$\n", - " \\tilde{u}_{j, \\text{int left}} = \\tilde{u}_{j, \\text{int}} - \\delta_j^* \\tilde{d}_{j},\n", - "$$\n", - "$$\n", - " \\tilde{u}_{j, \\text{int right}} = \\tilde{u}_{j, \\text{int}} + \\delta_j^* \\tilde{d}_{j+1}.\n", - "$$\n", - "\n", - "It turns out that if we then let\n", - "\n", - "$$\n", - "\\delta^*_j = \\delta_j \\frac{2 - \\sqrt{2 + 2 \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle}}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle},\n", - "$$\n", - "\n", - "The line between $\\tilde{u}_{, \\text{int left}}$ and $ \\tilde{u}_{, \\text{int right}}$ touches the circle arc as constructed before. It follows that\n", - "\n", - "$$\n", - " \\tilde{u}_{j + \\frac{1}{2}} = \\frac{1}{2}\\left[\\tilde{u}_{j, \\text{int left}} + \\tilde{u}_{j, \\text{int right}}\\right],\n", - " \\qquad\n", - " \\tilde{d}_{j + \\frac{1}{2}} = \\frac{\\tilde{u}_{j, \\text{int right}} - \\tilde{u}_{j, \\text{int left}}}{\\|\\tilde{u}_{j, \\text{int right}} - \\tilde{u}_{j, \\text{int left}}\\|_2}.\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p, vars = plot_arc_construction(; indicate_delta = false)\n", - "xlims!(0.0, 1.3)\n", - "ylims!(0.0, 0.8)\n", - "δⱼ_star = vars.δⱼ * (2 - sqrt(2 + 2 * vars.inner)) / (1 - vars.inner)\n", - "tu_j_int_left = vars.tu_j_int - δⱼ_star * vars.td_j\n", - "tu_j_int_right = vars.tu_j_int + δⱼ_star * vars.td_j_plus_1\n", - "tu_j_plus_half = vars.tu_j_int + δⱼ_star / 2 * (vars.td_j_plus_1 - vars.td_j)\n", - "td_j_plus_half = (vars.td_j_plus_1 + vars.td_j) / sqrt(2 + 2 * vars.inner)\n", - "\n", - "scatter!([tu_j_int_left[1], tu_j_plus_half[1], tu_j_int_right[1]], \n", - " [tu_j_int_left[2], tu_j_plus_half[2], tu_j_int_right[2]]; color = :black, label = \"\")\n", - "annotate!(tu_j_int_left..., raw\"$\\tilde{u}_{j, \\mathrm{int \\; left}}$\" * \"\\n\\n\")\n", - "annotate!(tu_j_int_right..., raw\"$\\tilde{u}_{j, \\mathrm{int \\; right}}$\" * \"\\n\\n\")\n", - "annotate!(tu_j_plus_half..., \"\\n\\n\" * raw\"$\\tilde{u}_{j + \\frac{1}{2}}$\")\n", - "annotate!(tu_j_plus_half..., \" \" * raw\"$\\tilde{d}_{j + \\frac{1}{2}}$\" * \"\\n\\n\\n\")\n", - "annotate!((vars.tu_j_int + δⱼ_star / 2 * normalize(vars.tu_j - vars.tu_j_int))..., raw\"$\\delta^*_j$\" * \"\\n\\n\")\n", - "plot!(\n", - " [vars.tu_j_int[1] - δⱼ_star * vars.td_j[1], vars.tu_j_int[1] + δⱼ_star * vars.td_j_plus_1[1]],\n", - " [vars.tu_j_int[2] - δⱼ_star * vars.td_j[2], vars.tu_j_int[2] + δⱼ_star * vars.td_j_plus_1[2]];\n", - " color = :black, ls = :dash, label = \"\")\n", - "plot!([tu_j_plus_half[1], tu_j_plus_half[1] + td_j_plus_half[1]/5], \n", - " [tu_j_plus_half[2], tu_j_plus_half[2] + td_j_plus_half[2]/5]; \n", - " arrow=(:closed, 2.0), color = :black, label = \"\")\n", - "\n", - "p" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we generalize the definition of $\\tilde{u}_{j, \\text{int}}$ then we can compute $\\tilde{u}_{j + \\frac{1}{2}}$ and $\\tilde{d}_{j + \\frac{1}{2}}$ as above. Something we can always compute are the points on the tangent lines which are closest together, given by:\n", - "\n", - "$$\n", - " \\argmin_{s,\\; t \\;\\in\\; \\mathbb{R}} \\|\\tilde{u}_{j+1} + s\\tilde{d}_{j+1} - (\\tilde{u}_j + t\\tilde{d}_j)\\|_2.\n", - "$$\n", - "\n", - "This yields \n", - "\n", - "$$\n", - " \\tilde{u}_{j, \\text{close left}} = \\tilde{u}_j + \\frac{\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_j,\n", - "$$\n", - "$$\n", - " \\tilde{u}_{j, \\text{close right}} = \\tilde{u}_{j+1} + \\frac{\\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle\\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_j\\rangle - \\langle\\tilde{u}_{j+1}-\\tilde{u}_j, \\tilde{d}_{j+1}\\rangle}{1 - \\langle\\tilde{d}_j, \\tilde{d}_{j+1}\\rangle^2}\\tilde{d}_{j+1}.\n", - "$$\n", - "\n", - "This is the same as the two expressions for $\\tilde{u}_{j, \\text{int}}$ from before, except now these expressions aren't necessarily equal. We define $\\tilde{u}_{j, \\text{int}}$ as the average of these expressions:\n", - "\n", - "$$\n", - " \\tilde{u}_{j, \\text{int}} = \\frac{\\tilde{u}_{j, \\text{close left}} + \\tilde{u}_{j, \\text{close right}}}{2}.\n", - "$$\n", - "\n", - "From this $\\delta_j$ and $\\delta_j^*$ follow, and \n", - "\n", - "$$\n", - " \\tilde{u}_{j, \\text{int left}} = \\tilde{u}_{j, \\text{close left}} - \\delta_j^* \\tilde{d}_{j},\n", - "$$\n", - "$$\n", - " \\tilde{u}_{j, \\text{int right}} = \\tilde{u}_{j, \\text{close right}} + \\delta_j^* \\tilde{d}_{j+1}.\n", - "$$" - ] - }, { "cell_type": "code", "execution_count": 21, diff --git a/docs/Project.toml b/docs/Project.toml index 56a44069..62776428 100644 --- a/docs/Project.toml +++ b/docs/Project.toml @@ -1,4 +1,5 @@ [deps] +DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" ModelingToolkitStandardLibrary = "16a59e39-deab-5bd0-87e4-056b12336739" diff --git a/docs/make.jl b/docs/make.jl index a6b062b5..f1ab91d7 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -9,12 +9,19 @@ makedocs(modules = [DataInterpolations], sitename = "DataInterpolations.jl", clean = true, doctest = false, - linkcheck = true, + linkcheck = false, + checkdocs = :none, + pagesonly = true, format = Documenter.HTML(assets = ["assets/favicon.ico"], canonical = "https://docs.sciml.ai/DataInterpolations/stable/"), - pages = ["index.md", "Interpolation methods" => "methods.md", - "Extrapolation methods" => "extrapolation_methods.md", - "Interface" => "interface.md", "Using with Symbolics/ModelingToolkit" => "symbolics.md", - "Manual" => "manual.md", "Inverting Integrals" => "inverting_integrals.md"]) + pages = [ + "index.md", + # "Interpolation methods" => "methods.md", + # "Extrapolation methods" => "extrapolation_methods.md", + # "Interface" => "interface.md", + # "Using with Symbolics/ModelingToolkit" => "symbolics.md", + "Manual" => "manual.md", + "Smooth arc length interpolation" => "arclength_interpolation.md" # "Inverting Integrals" => "inverting_integrals.md"]) + ]) deploydocs(repo = "github.com/SciML/DataInterpolations.jl"; push_preview = true) diff --git a/docs/src/arclength_interpolation.md b/docs/src/arclength_interpolation.md new file mode 100644 index 00000000..810fc43d --- /dev/null +++ b/docs/src/arclength_interpolation.md @@ -0,0 +1,491 @@ +# Smooth arc length interpolation + +Arc length interpolation is interpolation between points using a curve that is parameterized by arc length. That is: the curve parameterization has unit speed everywhere, and so the parameter `t` at each point on the curve is equal to the total distance traveled from the beginning of the curve. In this context, by 'smooth' we mean that the curve is continuously differentiable. + +## Usage + +`DataInteprolations.jl` offers an arc length interpolation method that approximates an existing non arc length interpolation by circle and line segments. This can be done by providing an interpolation object: + +```@example tutorial +using DataInterpolations +using Plots +using Random + +Random.seed!(2) + +# Example from interpolation object +u = cumsum([rand(3) for _ in 1:10]) +t = 1:10 +A_shape = QuadraticSpline(u, t) +A = SmoothArcLengthInterpolation(A_shape; m = 10) + +function plot_itp(itp) + t_eval = range(itp.t[1], itp.t[end]; length = 1000) + u_eval = zeros(3, 1000) + itp(u_eval, t_eval) + + plot(eachrow(u_eval)...; label = "SmoothArcLengthInterpolation") + scatter!(eachrow(u_eval[:, 1:50:end])...; label = "Equidistant points on the curve") + scatter!(eachrow(hcat(A.shape_itp.u...))...; label = "Original data") +end + +plot_itp(A) +``` + +Here `m` determines how fine the approximation is. It is also possible to just provide the data points, optionally providing `t` and a preferred interpolation type which determines the shape of the curve. + +```@example tutorial +# Example from only u +A = SmoothArcLengthInterpolation(hcat(u...)) +plot_itp(A) +``` + + +## Docstrings + +To do: add doc strings for the different constructors and add them here + +```@docs +SmoothArcLengthInterpolation +``` + +## Method derivation + +Say we have an ordered set of points $u_1, \ldots, u_n \in \mathbb{R}^N$ and we want to make a lightweight $C^1$ smooth interpolation by arc-length $\tilde{\gamma}: [0,T] \rightarrow \mathbb{R}^N$ through these points. The first part is easy, just pick your favorite established interpolation method that achieves $C^1$ smoothness. The arc-length part however turns out to be quite [nasty](https://ijpam.eu/contents/2006-31-3/10/10.pdf). Here I propose a method that is quite general and cheap to compute. + +### The 2-dimensional case + +2 is the smallest number of dimensions in which the posed problem is non-trivial. Say we use an established (non arc-length) interpolation method for our set of points to obtain the $C^1$ curve + +```math + \gamma : [0, T] \rightarrow \mathbb{R}^2 +``` + +for which + +```math + \gamma(t_i) = u_i \quad i = 1, \ldots, n, +``` + +given a suitable set of 'time' values + +```math + 0 = t_1 < t_2 < \ldots < t_n = T, +``` + +for instance + +```math + t_i = \sum_{k=1}^{i-1} \|u_{k+1} - u_k\|_2. +``` + +We now want to approximate $\gamma$ piecewise with sections that are trivially parameterizable by arc-length, namely line segments and circle segments. To do this, we fix some $m \in \mathbb{N}$ and define a refined set of time points $\left(\tilde{t}_j\right)_{j=1}^{m(n-1) + 1}$ given by + +```math + \tilde{t}_{m(k-1) + l} = t_k + \frac{l}{m + 1}(t_{k+1} - t_k), \quad k = 1 \ldots n-1, \; l = 1, \ldots m. +``` + +In these refined time points we evaluate $\gamma$ and its normalized derivative: + +```math + \tilde{u}_j = \gamma\left(\tilde{t}_j\right), \; \tilde{d}_j = \frac{\dot{\gamma}\left(\tilde{t}_j\right)}{\|\dot{\gamma}\left(\tilde{t}_j\right)\|_2}, \qquad j = 1, \ldots, m(n-1) + 1. +``` + +As a first step to create the interpolation by arc length $\tilde{\gamma}$, we make a piecewise linear curve which is tangent to $\gamma$ in $\tilde{u}_j$ for each line segment, where we denote the intersection of consecutive tangent lines by $\tilde{u}_{j, \text{int}}$: + +```math + \begin{align*} + \tilde{u}_{j, \text{int}} &=& \tilde{u}_j + \frac{\langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_j\rangle - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle \langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_{j+1}\rangle}{1 - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle^2}\tilde{d}_j \\ + &=& \tilde{u}_{j+1} + \frac{\langle\tilde{d}_j, \tilde{d}_{j+1}\rangle\langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_j\rangle - \langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_{j+1}\rangle}{1 - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle^2}\tilde{d}_{j+1}. + \end{align*} +``` + +As expected this doesn't work for $\langle\tilde{d}_j, \tilde{d}_{j+1}\rangle^2 = 1$, which means that the consecutive tangent lines are parallel. In fact, in the above equation we want the coefficient of $\tilde{d}_j$ to be positive and the coefficient of $\tilde{d}_{j+1}$ to be negative, to ensure that $\tilde{u}_{j, \text{int}}$ lies properly in between $\tilde{u}_j$ and $\tilde{u}_{j+1}$. + +```@setup tutorial +using DataInterpolations +using Plots +using Random +using LinearAlgebra + +Random.seed!(4) + +n = 4 +m = 2 +u = [rand(2) for _ in 1:n] +t = cumsum(norm.(diff(u))) +pushfirst!(t, 0) + +γ = QuadraticSpline(u, t) + +t_eval = range(first(t), last(t), length = 250) +u_eval = hcat(γ.(t_eval)...) + +t_tilde = zeros(m * (n - 1) + 1) + +for k in 1:(n-1) + t_tilde[m * (k - 1) + 1 : m * k] = range(t[k], t[k+1], length = m + 1)[1:(end - 1)] +end + +t_tilde[end] = t[end] +u_tilde = hcat(γ.(t_tilde)...) + +d_tilde = DataInterpolations.derivative.(Ref(γ), t_tilde) +normalize!.(d_tilde) +d_tilde = hcat(d_tilde...) + +n_intervals = length(t_tilde) - 1 +intersection_points = zeros(2, n_intervals) + +u_tilde_j_int_1 = zeros(2) +u_tilde_j_int_2 = zeros(2) + +for j in 1:n_intervals + d_tilde_j = view(d_tilde, :, j) + d_tilde_j_plus_1 = view(d_tilde, :, j + 1) + d_inner = dot(d_tilde_j, d_tilde_j_plus_1) + u_tilde_j = view(u_tilde, :, j) + u_tilde_j_plus_1 = view(u_tilde, :, j + 1) + Δu = u_tilde_j_plus_1 - u_tilde_j + + coef_1 = (dot(Δu, d_tilde_j) - d_inner * dot(Δu, d_tilde_j_plus_1))/(1 - d_inner^2) + coef_2 = (d_inner * dot(Δu, d_tilde_j) - dot(Δu, d_tilde_j_plus_1))/(1 - d_inner^2) + + @. u_tilde_j_int_1 = u_tilde_j + coef_1 * d_tilde_j + @. u_tilde_j_int_2 = u_tilde_j_plus_1 + coef_2 * d_tilde_j_plus_1 + @assert u_tilde_j_int_1 ≈ u_tilde_j_int_2 + + intersection_points[:, j] .= u_tilde_j_int_1 +end + +function plot_tangent_curve() + p = plot(; aspect_ratio = :equal, legend = :topleft, title = "m = $m") + + # Plot curve γ + plot!(u_eval[1,:], u_eval[2,:]; label = raw"\gamma") + + # Plot original points + u_ = hcat(u...) + scatter!(u_[1,:], u_[2,:], label = raw"$u_i$"; markersize = 6, markerstrokewidth = 0) + + # Plot refined evaluation points + scatter!(u_tilde[1,:], u_tilde[2,:]; label = raw"$\tilde{u}_j$", markerstrokewidth = 0) + + # Plot tangent curve + scatter!(intersection_points[1, :], intersection_points[2, :]; + markerstrokewidth = 0, markersize = 3, label = raw"$\tilde{u}_{j, \mathrm{int}}$") + plot!([u_tilde[1, 1], intersection_points[1, :]..., u_tilde[1, end]], + [u_tilde[2, 1], intersection_points[2, :]..., u_tilde[2, end]]; + label = "Tangent curve") + p +end +``` + +```@example tutorial +plot_tangent_curve() # hide +``` + +As a last step to obtain our curve by arc length $\tilde{\gamma}$ we want to get rid of the kinks in the tangent curve. We do this by replacing sections of the tangent curve by circle arcs. For each $\tilde{u}_{j, \text{int}}$ we compute the shortest distance to the neighboring evaluation points on $\gamma$: + +```math + \delta_j = \min\left\{ + \|\tilde{u}_j - \tilde{u}_{j, \text{int}}\|_2, + \|\tilde{u}_{j + 1} - \tilde{u}_{j, \text{int}}\|_2 + \right\}. +``` + +From this we compute 2 points that are on the tangent curve and equidistant from $\tilde{u}_{j + \frac{1}{2}}$: + +```math + \tilde{u}_{j, \text{start}} = \tilde{u}_{j, \text{int}} - \delta_j \tilde{d}_j, +``` + +```math + \tilde{u}_{j, \text{end}} = \tilde{u}_{j, \text{int}} + \delta_j \tilde{d}_{j+1}. +``` + +Note that by this definition + +```math + \tilde{u}_{j, \text{start}} = \tilde{u}_j \quad \vee \quad \tilde{u}_{j, \text{end}} = \tilde{u}_{j + 1}. +``` + +Now we can define a circle arc from $\tilde{u}_{j, \text{start}}$ to $\tilde{u}_{j, \text{end}}$ given the center + +```math + c_j = \tilde{u}_{j, \text{int}} + \delta_j\frac{\tilde{d}_{j+1} - \tilde{d}_j}{1 - \langle\tilde{d}_j,\tilde{d}_{j+1}\rangle} +``` + +and radius + +```math + R_j = \delta_j\sqrt{\frac{1 + \langle\tilde{d}_j,\tilde{d}_{j+1}\rangle}{1 - \langle\tilde{d}_j,\tilde{d}_{j+1}\rangle}}. +``` + +We obtain the circle arc + +```math + c_j + \cos\left(\frac{t}{R_j}\right)v_{j, 1} + \sin\left(\frac{t}{R_j}\right)v_{j, 2}, \quad t \in [0, \Delta t_{j, \text{arc}}], +``` + +where + +```math + v_{j, 1} = -\delta_j \frac{\tilde{d}_{j+1} - \langle\tilde{d}_j,\tilde{d}_{j+1}\rangle\tilde{d}_j}{1 - \langle\tilde{d}_j,\tilde{d}_{j+1}\rangle}, + \quad + v_{j, 2} = R_j \tilde{d}_j. +``` + +By this definition $\|v_{j, 1}\|_2 = \|v_{j, 2}\|_2 = R_j$ and $\langle v_{j, 1}, v_{j, 2}\rangle = 0$. Furthermore: + +```math + \Delta t_{j, \text{arc}} = R_j\theta_{j, \;\max}= 2R_j \arctan\left(\frac{\delta_j}{R_j}\right). +``` + +```@setup tutorial +function mark_right_angle!(corner, dir1, dir2; l = 0.05) + points = zeros(3, 2) + points[1, :] = corner + l * dir1 + points[2, :] = points[1, :] + l * dir2 + points[3, :] = points[2, :] - l * dir1 + + plot!(points[:, 1], points[:, 2]; color = :black, label = "") +end + +function plot_arc_construction(; indicate_delta = true) + p = plot(; aspect_ratio = :equal, axis = false) + + tu_j = [0.0, 0.2] + tu_j_int = [0.5, 0.6] + tu_j_plus_1 = [1.2, 0.3] + δⱼ = norm(tu_j_int - tu_j) + tu_j_start = tu_j + tu_j_end = tu_j_int + δⱼ * (tu_j_plus_1 - tu_j_int) / norm(tu_j_plus_1 - tu_j_int) + + td_j = tu_j_int - tu_j + normalize!(td_j) + td_j_plus_1 = tu_j_plus_1 - tu_j_int + normalize!(td_j_plus_1) + inner = dot(td_j, td_j_plus_1) + Δtd_j = td_j_plus_1 - td_j + + tc_j = tu_j_int + δⱼ / (1 - inner) * Δtd_j + + Rⱼ = δⱼ * sqrt((1 + inner)/(1 - inner)) + vⱼ₁ = -δⱼ * (td_j_plus_1 - inner * td_j)/(1 - inner) + vⱼ₂ = Rⱼ * td_j + Δt_j_arc = 2 * Rⱼ * atan(δⱼ, Rⱼ) + + T_ = range(0, π/2; length = 100) + x_arc = @. tc_j[1] + cos(T_) * vⱼ₁[1] + sin(T_) * vⱼ₂[1] + y_arc = @. tc_j[2] + cos(T_) * vⱼ₁[2] + sin(T_) * vⱼ₂[2] + plot!(x_arc, y_arc; label = "", color = :gray, ls = :dash) + + T = range(0, Δt_j_arc, length = 100) + X_arc = @. tc_j[1] + cos(T/Rⱼ) * vⱼ₁[1] + sin(T/Rⱼ) * vⱼ₂[1] + Y_arc = @. tc_j[2] + cos(T/Rⱼ) * vⱼ₁[2] + sin(T/Rⱼ) * vⱼ₂[2] + plot!(X_arc, Y_arc; label = "", color = :black, linewidth = 2) + + x_arc = @. tc_j[1] + cos(T/Rⱼ) * vⱼ₁[1] / 7 + sin(T/Rⱼ) * vⱼ₂[1] / 7 + y_arc = @. tc_j[2] + cos(T/Rⱼ) * vⱼ₁[2] / 7 + sin(T/Rⱼ) * vⱼ₂[2] / 7 + plot!(x_arc, y_arc; label = "", color = :black) + + z = tc_j + vⱼ₂ + + annotate!(tu_j..., "\n\n\n" * raw"$\tilde{u}_j = \tilde{u}_{j, \mathrm{start}}$") + annotate!(tu_j_int..., raw"$\tilde{u}_{j, \mathrm{int}}$" * "\n\n\n") + annotate!(tu_j_end..., raw"$\tilde{u}_{j, \mathrm{end}}$" * "\n\n\n") + annotate!(tu_j_plus_1..., "\n\n\n" * raw"$\tilde{u}_{j + 1}$") + annotate!((tu_j + td_j/5)..., raw"$\tilde{d}_j$" * " ") + annotate!((tu_j_plus_1 + td_j_plus_1/5)..., raw"$\tilde{d}_{j+1}$" * "\n\n") + annotate!(tc_j..., " " * raw"$\tilde{c}_j$") + annotate!(tc_j + vⱼ₁/2..., raw"$v_{j,1}$" * " ") + annotate!(tc_j + vⱼ₂/2..., "\n " * raw"$v_{j,2}$") + annotate!(tc_j..., raw"$\theta_{j, \max}$" * " \n\n\n\n\n") + indicate_delta && annotate!((tu_j + tu_j_int)/2..., raw"$\delta_j$" * "\n\n") + + mark_right_angle!(tu_j_start, td_j, normalize(tc_j - tu_j_start)) + mark_right_angle!(tu_j_end, td_j_plus_1, normalize(tc_j - tu_j_end)) + mark_right_angle!(tc_j, normalize(vⱼ₁), normalize(vⱼ₂)) + + # u connections + points = hcat(tu_j, tu_j_int, tu_j_end, tu_j_plus_1) + plot!(points[1, :], points[2, :]; marker = :circle, c = :black, ls = :dash, label = "") + + # line segment + plot!([tu_j_plus_1[1], tu_j_end[1]], [tu_j_plus_1[2], tu_j_end[2]], c = :black, label = "", linewidth = 2) + + # td_j and td_j_plus_1 + plot!([tu_j[1], tu_j[1] + td_j[1]/5], [tu_j[2], tu_j[2] + td_j[2]/5]; arrow=(:closed, 2.0), color = :black, label = "") + plot!([tu_j_plus_1[1], tu_j_plus_1[1] + td_j_plus_1[1]/5], [tu_j_plus_1[2], tu_j_plus_1[2] + td_j_plus_1[2]/5]; arrow=(:closed, 2.0), color = :black, label = "") + + # Circle segment radii + points = hcat(tu_j_start, tc_j, tu_j_end) + plot!(points[1, :], points[2, :]; color = :gray, label = "", ls = :dash) + + # v₂ⱼ + points = hcat(tc_j, tc_j + vⱼ₂) + plot!(points[1, :], points[2, :]; color = :gray, label = "", ls = :dash) + + # tc_j + scatter!([tc_j[1]], [tc_j[2]]; color = :gray, label = "") + ylims!(-0.65, 0.8) + return p, (; tu_j, tu_j_plus_1, tu_j_int, tu_j_start, tu_j_end, td_j, td_j_plus_1, inner, tc_j, δⱼ, Rⱼ) +end +``` + +```@example tutorial +plot_arc_construction()[1] # hide +``` + +```@setup tutorial +p = plot_tangent_curve() + +δ = [min( + norm(intersection_points[:, j] - u_tilde[:, j]), + norm(intersection_points[:, j] - u_tilde[:, j+1]) + ) + for j in 1:n_intervals +] + +u_tilde_start = zeros(2, n_intervals) +u_tilde_end = zeros(2, n_intervals) + +for j in 1:n_intervals + u_tilde_intⱼ = intersection_points[:, j] + u_tildeⱼ = u_tilde[:, j] + u_tildeⱼ₊₁ = u_tilde[:, j + 1] + d_tildeⱼ = d_tilde[:, j] + d_tildeⱼ₊₁ = d_tilde[:, j + 1] + + u_tilde_start[:, j] = u_tilde_intⱼ - δ[j] * d_tildeⱼ + u_tilde_end[:, j] = u_tilde_intⱼ + δ[j] * d_tildeⱼ₊₁ +end + +scatter!(u_tilde_start[1, :], u_tilde_start[2, :]; markersize = 3, markerstrokewidth = 0, + label = raw"$\tilde{u}_{j, start}$") +scatter!(u_tilde_end[1, :], u_tilde_end[2, :]; markersize = 3, markerstrokewidth = 0, + label = raw"$\tilde{u}_{j, end}$") + +origins = zeros(2, n_intervals) + +for j in 1:n_intervals + u_tilde_intⱼ = intersection_points[:, j] + d_tildeⱼ = d_tilde[:, j] + d_tildeⱼ₊₁ = d_tilde[:, j + 1] + inner = dot(d_tildeⱼ, d_tildeⱼ₊₁) + + origins[:, j] = u_tilde_intⱼ + δ[j] / (1 - inner) * (d_tildeⱼ₊₁ - d_tildeⱼ) + + plot!([u_tilde_start[1, j], origins[1, j], u_tilde_end[1, j]], + [u_tilde_start[2, j], origins[2, j], u_tilde_end[2, j]]; + label = (j ==1) ? "radii of circle arc" : "", ls = :dash, c = :gray) + + Rⱼ = δ[j] * sqrt((1 + inner)/(1 - inner)) + v₁ = -δ[j] * (d_tildeⱼ₊₁ - inner * d_tildeⱼ) / (1 - inner) + v₂ = Rⱼ * d_tildeⱼ + Δt = 2 * Rⱼ * atan(δ[j], Rⱼ) + T = range(0, Δt, length = 25) + x = @. origins[1, j] + cos(T/Rⱼ) * v₁[1] + sin(T/Rⱼ) * v₂[1] + y = @. origins[2, j] + cos(T/Rⱼ) * v₁[2] + sin(T/Rⱼ) * v₂[2] + plot!(x,y; c = :green, label = (j == 1) ? "circle arc" : "") +end + +scatter!(origins[1, :], origins[2, :]; label = raw"$\tilde{c}_j$", c= :gray, markerstrokewidth = 0) +``` + +```@example tutorial +p # hide +``` + +That's pretty neat, but this method does not directly generalize to higher dimensional spaces. That is because in general the intersection points $\tilde{u}_{j, \text{int}}$ of the tangent lines do not exist. + +### The higher dimensional case + +Let's try to generalize the method above. The goal is to find a point $\tilde{u}_{j + \frac{1}{2}}$ and unit direction $\tilde{d}_{j + \frac{1}{2}}$ to add to the tangent curve between $\tilde{u}_j$ and $\tilde{u}_{j+1}$ such that: + +- the tangent line intersections $\tilde{u}_{j, \text{int left}}, \tilde{u}_{j, \text{int right}}$ exist. This means that the new line is fixed by these 2 points; +- constructing $\tilde{\gamma}$ including this point gives gives an identical result to constructing $\tilde{\gamma}$ excluding this point if the tangent line intersection already existed. The latter implies that $\tilde{u}_{j + \frac{1}{2}}$ and $\tilde{d}_{j + \frac{1}{2}}$ yield a tangent line to the constructed circle arc. + +Let's assume the tangent line intersection exists, and we define + +```math + \tilde{u}_{j, \text{int left}} = \tilde{u}_{j, \text{int}} - \delta_j^* \tilde{d}_{j}, +``` +```math + \tilde{u}_{j, \text{int right}} = \tilde{u}_{j, \text{int}} + \delta_j^* \tilde{d}_{j+1}. +``` + +It turns out that if we then let + +```math +\delta^*_j = \delta_j \frac{2 - \sqrt{2 + 2 \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle}}{1 - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle}, +``` + +The line between $\tilde{u}_{, \text{int left}}$ and $ \tilde{u}_{, \text{int right}}$ touches the circle arc as constructed before. It follows that + +```math + \tilde{u}_{j + \frac{1}{2}} = \frac{1}{2}\left[\tilde{u}_{j, \text{int left}} + \tilde{u}_{j, \text{int right}}\right], + \qquad + \tilde{d}_{j + \frac{1}{2}} = \frac{\tilde{u}_{j, \text{int right}} - \tilde{u}_{j, \text{int left}}}{\|\tilde{u}_{j, \text{int right}} - \tilde{u}_{j, \text{int left}}\|_2}. +``` + +```@setup tutorial +p, vars = plot_arc_construction(; indicate_delta = false) +xlims!(0.0, 1.3) +ylims!(0.0, 0.8) +δⱼ_star = vars.δⱼ * (2 - sqrt(2 + 2 * vars.inner)) / (1 - vars.inner) +tu_j_int_left = vars.tu_j_int - δⱼ_star * vars.td_j +tu_j_int_right = vars.tu_j_int + δⱼ_star * vars.td_j_plus_1 +tu_j_plus_half = vars.tu_j_int + δⱼ_star / 2 * (vars.td_j_plus_1 - vars.td_j) +td_j_plus_half = (vars.td_j_plus_1 + vars.td_j) / sqrt(2 + 2 * vars.inner) + +scatter!([tu_j_int_left[1], tu_j_plus_half[1], tu_j_int_right[1]], + [tu_j_int_left[2], tu_j_plus_half[2], tu_j_int_right[2]]; color = :black, label = "") +annotate!(tu_j_int_left..., raw"$\tilde{u}_{j, \mathrm{int \; left}}$" * "\n\n") +annotate!(tu_j_int_right..., raw"$\tilde{u}_{j, \mathrm{int \; right}}$" * "\n\n") +annotate!(tu_j_plus_half..., "\n\n" * raw"$\tilde{u}_{j + \frac{1}{2}}$") +annotate!(tu_j_plus_half..., " " * raw"$\tilde{d}_{j + \frac{1}{2}}$" * "\n\n\n") +annotate!((vars.tu_j_int + δⱼ_star / 2 * normalize(vars.tu_j - vars.tu_j_int))..., raw"$\delta^*_j$" * "\n\n") +plot!( + [vars.tu_j_int[1] - δⱼ_star * vars.td_j[1], vars.tu_j_int[1] + δⱼ_star * vars.td_j_plus_1[1]], + [vars.tu_j_int[2] - δⱼ_star * vars.td_j[2], vars.tu_j_int[2] + δⱼ_star * vars.td_j_plus_1[2]]; + color = :black, ls = :dash, label = "") +plot!([tu_j_plus_half[1], tu_j_plus_half[1] + td_j_plus_half[1]/5], + [tu_j_plus_half[2], tu_j_plus_half[2] + td_j_plus_half[2]/5]; + arrow=(:closed, 2.0), color = :black, label = "") +``` + +```@example tutorial +p # hide +``` + +If we generalize the definition of $\tilde{u}_{j, \text{int}}$ then we can compute $\tilde{u}_{j + \frac{1}{2}}$ and $\tilde{d}_{j + \frac{1}{2}}$ as above. Something we can always compute are the points on the tangent lines which are closest together, given by: + +```math + \argmin_{s,\; t \;\in\; \mathbb{R}} \|\tilde{u}_{j+1} + s\tilde{d}_{j+1} - (\tilde{u}_j + t\tilde{d}_j)\|_2. +``` + +This yields + +```math + \tilde{u}_{j, \text{close left}} = \tilde{u}_j + \frac{\langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_j\rangle - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle \langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_{j+1}\rangle}{1 - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle^2}\tilde{d}_j, +``` +```math + \tilde{u}_{j, \text{close right}} = \tilde{u}_{j+1} + \frac{\langle\tilde{d}_j, \tilde{d}_{j+1}\rangle\langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_j\rangle - \langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_{j+1}\rangle}{1 - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle^2}\tilde{d}_{j+1}. +``` + +This is the same as the two expressions for $\tilde{u}_{j, \text{int}}$ from before, except now these expressions aren't necessarily equal. We define $\tilde{u}_{j, \text{int}}$ as the average of these expressions: + +```math + \tilde{u}_{j, \text{int}} = \frac{\tilde{u}_{j, \text{close left}} + \tilde{u}_{j, \text{close right}}}{2}. +``` + +From this $\delta_j$ and $\delta_j^*$ follow, and + +```math + \tilde{u}_{j, \text{int left}} = \tilde{u}_{j, \text{close left}} - \delta_j^* \tilde{d}_{j}, +``` +```math + \tilde{u}_{j, \text{int right}} = \tilde{u}_{j, \text{close right}} + \delta_j^* \tilde{d}_{j+1}. +``` \ No newline at end of file diff --git a/docs/src/assets/Project.toml b/docs/src/assets/Project.toml new file mode 100644 index 00000000..62776428 --- /dev/null +++ b/docs/src/assets/Project.toml @@ -0,0 +1,22 @@ +[deps] +DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" +Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" +ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" +ModelingToolkitStandardLibrary = "16a59e39-deab-5bd0-87e4-056b12336739" +Optim = "429524aa-4258-5aef-a3af-852621145aeb" +OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +RegularizationTools = "29dad682-9a27-4bc3-9c72-016788665182" +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" +Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + +[compat] +Documenter = "1" +ModelingToolkit = "9" +ModelingToolkitStandardLibrary = "2" +Optim = "1" +OrdinaryDiffEq = "6" +Plots = "1" +RegularizationTools = "0.6" +StableRNGs = "1" +Symbolics = "5.29, 6.0" From 58d5e54057a51de034d127a88291f80387539461 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Fri, 21 Mar 2025 09:53:20 -0100 Subject: [PATCH 03/11] Delete arclength_interpolation.ipynb --- arclength_interpolation.ipynb | 421 ---------------------------------- 1 file changed, 421 deletions(-) delete mode 100644 arclength_interpolation.ipynb diff --git a/arclength_interpolation.ipynb b/arclength_interpolation.ipynb deleted file mode 100644 index 59387d90..00000000 --- a/arclength_interpolation.ipynb +++ /dev/null @@ -1,421 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "SmoothArcLengthInterpolation with 31 points\n", - "┌───────────┬─────────────┬──────────┬──────────┐\n", - "│\u001b[1m time \u001b[0m│\u001b[1m u1 \u001b[0m│\u001b[1m u2 \u001b[0m│\u001b[1m u3 \u001b[0m│\n", - "├───────────┼─────────────┼──────────┼──────────┤\n", - "│ 0.0 │ 0.0491718 │ 0.119079 │ 0.393271 │\n", - "│ 0.0703603 │ 0.0269864 │ 0.153539 │ 0.450413 │\n", - "│ 0.137097 │ 0.00971137 │ 0.192336 │ 0.501846 │\n", - "│ 0.203801 │ -0.00355192 │ 0.23671 │ 0.549797 │\n", - "│ 0.270541 │ -0.0125266 │ 0.286242 │ 0.593559 │\n", - "│ 0.337314 │ -0.0172039 │ 0.34013 │ 0.63265 │\n", - "│ 0.407777 │ -0.0175421 │ 0.400798 │ 0.668408 │\n", - "│ 0.478301 │ -0.0138159 │ 0.464221 │ 0.698958 │\n", - "│ ⋮ │ ⋮ │ ⋮ │ ⋮ │\n", - "│ 1.03979 │ 0.204067 │ 0.911244 │ 0.824877 │\n", - "│ 1.09888 │ 0.257848 │ 0.887916 │ 0.826758 │\n", - "│ 1.15943 │ 0.307302 │ 0.853081 │ 0.826189 │\n", - "│ 1.25314 │ 0.372683 │ 0.786276 │ 0.821875 │\n", - "│ 1.34719 │ 0.432338 │ 0.713833 │ 0.815967 │\n", - "│ 1.47879 │ 0.507208 │ 0.606141 │ 0.805672 │\n", - "│ 1.61049 │ 0.577164 │ 0.495155 │ 0.794274 │\n", - "│ 1.78126 │ 0.661425 │ 0.347513 │ 0.778149 │\n", - "└───────────┴─────────────┴──────────┴──────────┘\n", - "\u001b[36m 15 rows omitted\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "using DataInterpolations: SmoothArcLengthInterpolation\n", - "\n", - "Random.seed!(1)\n", - "\n", - "n = 4\n", - "u = rand(3, n)\n", - "A = SmoothArcLengthInterpolation(u; m = 5)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n_eval = 500\n", - "t_eval = range(0, last(A.t), n_eval)\n", - "u_eval = zeros(3, n_eval)\n", - "\n", - "for (i, t) in enumerate(t_eval)\n", - " u_eval[:, i] = A(t)\n", - "end\n", - "\n", - "p = plot(; aspect_ratio = :equal)\n", - "\n", - "plot!(u_eval[1, :], u_eval[2, :], u_eval[3, :]; label = \"Arc-length parameterized curve\")\n", - "scatter!(A.u[1, :], A.u[2, :], A.u[3, :]; label = \"Points defining tangent curve\")\n", - "scatter!(u[1, :], u[2, :], u[3, :]; label = \"Original data\")\n", - "\n", - "p" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It would be nice to have a rigorous proof of $\\tilde{\\gamma}$ converging to the arc-length reparametrization of $\\gamma$ as $m \\rightarrow \\infty$ (and how fast). For now we can look at the convergence of the arc-length of $\\tilde{\\gamma}$ to the arc-length of $\\gamma$ with $m$ for the example above: " - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "M = 5:1000\n", - "E = zeros(length(M))\n", - "\n", - "(; shape_itp) = A\n", - "t_eval = range(0, last(shape_itp.t), length = 1_000_000)\n", - "u_eval = shape_itp.(t_eval)\n", - "l = sum(norm.(diff(u_eval)))\n", - "\n", - "\n", - "for (i, m) in enumerate(M)\n", - " A = SmoothArcLengthInterpolation(u; m)\n", - " E[i] = abs(l - last(A.t))\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p = plot()\n", - "xlabel!(\"m\")\n", - "ylabel!(\"Error\")\n", - "plot!(M, E; xscale = :log10, yscale = :log10, label = \"Curve length error\")\n", - "\n", - "ε = log.(E)\n", - "μ = log.(M)\n", - "k = (dot(ε, μ) - sum(ε)*sum(μ)/length(M))/(dot(μ,μ) - (sum(μ)^2)/length(M))\n", - "C = exp((sum(ε) - k*sum(μ))/length(M))\n", - "\n", - "\n", - "plot!(M, @. C * M^k; label = \"$(round(C, digits = 5)) × m ^ $(round(k, digits = 3))\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 1.11.3", - "language": "julia", - "name": "julia-1.11" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 3bf523f4b51afa2b52bf87542c63829e6cc166f9 Mon Sep 17 00:00:00 2001 From: Christopher Rackauckas Date: Fri, 21 Mar 2025 09:54:27 -0100 Subject: [PATCH 04/11] Update docs/make.jl --- docs/make.jl | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/make.jl b/docs/make.jl index f1ab91d7..8170d953 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -16,10 +16,10 @@ makedocs(modules = [DataInterpolations], canonical = "https://docs.sciml.ai/DataInterpolations/stable/"), pages = [ "index.md", - # "Interpolation methods" => "methods.md", - # "Extrapolation methods" => "extrapolation_methods.md", - # "Interface" => "interface.md", - # "Using with Symbolics/ModelingToolkit" => "symbolics.md", + "Interpolation methods" => "methods.md", + "Extrapolation methods" => "extrapolation_methods.md", + "Interface" => "interface.md", + "Using with Symbolics/ModelingToolkit" => "symbolics.md", "Manual" => "manual.md", "Smooth arc length interpolation" => "arclength_interpolation.md" # "Inverting Integrals" => "inverting_integrals.md"]) ]) From b66509210bb8482fdeffeac4fe2f608ef1ead187 Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Fri, 21 Mar 2025 13:12:40 +0100 Subject: [PATCH 05/11] Add tests --- docs/make.jl | 8 ++++---- docs/src/arclength_interpolation.md | 20 +++++++++++--------- src/derivatives.jl | 15 ++++++++------- src/interpolation_caches.jl | 13 +++++++++---- src/interpolation_methods.jl | 6 ++++-- test/derivative_tests.jl | 24 ++++++++++++++++++++---- test/interpolation_tests.jl | 24 ++++++++++++++++++++++++ 7 files changed, 80 insertions(+), 30 deletions(-) diff --git a/docs/make.jl b/docs/make.jl index 8170d953..743ba4ea 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -16,10 +16,10 @@ makedocs(modules = [DataInterpolations], canonical = "https://docs.sciml.ai/DataInterpolations/stable/"), pages = [ "index.md", - "Interpolation methods" => "methods.md", - "Extrapolation methods" => "extrapolation_methods.md", - "Interface" => "interface.md", - "Using with Symbolics/ModelingToolkit" => "symbolics.md", + "Interpolation methods" => "methods.md", + "Extrapolation methods" => "extrapolation_methods.md", + "Interface" => "interface.md", + "Using with Symbolics/ModelingToolkit" => "symbolics.md", "Manual" => "manual.md", "Smooth arc length interpolation" => "arclength_interpolation.md" # "Inverting Integrals" => "inverting_integrals.md"]) ]) diff --git a/docs/src/arclength_interpolation.md b/docs/src/arclength_interpolation.md index 810fc43d..1e6552f1 100644 --- a/docs/src/arclength_interpolation.md +++ b/docs/src/arclength_interpolation.md @@ -40,7 +40,6 @@ A = SmoothArcLengthInterpolation(hcat(u...)) plot_itp(A) ``` - ## Docstrings To do: add doc strings for the different constructors and add them here @@ -51,7 +50,7 @@ SmoothArcLengthInterpolation ## Method derivation -Say we have an ordered set of points $u_1, \ldots, u_n \in \mathbb{R}^N$ and we want to make a lightweight $C^1$ smooth interpolation by arc-length $\tilde{\gamma}: [0,T] \rightarrow \mathbb{R}^N$ through these points. The first part is easy, just pick your favorite established interpolation method that achieves $C^1$ smoothness. The arc-length part however turns out to be quite [nasty](https://ijpam.eu/contents/2006-31-3/10/10.pdf). Here I propose a method that is quite general and cheap to compute. +Say we have an ordered set of points $u_1, \ldots, u_n \in \mathbb{R}^N$ and we want to make a lightweight $C^1$ smooth interpolation by arc-length $\tilde{\gamma}: [0,T] \rightarrow \mathbb{R}^N$ through these points. The first part is easy, just pick your favorite established interpolation method that achieves $C^1$ smoothness. The arc-length part however turns out to be quite [nasty](https://ijpam.eu/contents/2006-31-3/10/10.pdf). Here I propose a method that is quite general and cheap to compute. ### The 2-dimensional case @@ -61,13 +60,13 @@ Say we have an ordered set of points $u_1, \ldots, u_n \in \mathbb{R}^N$ and we \gamma : [0, T] \rightarrow \mathbb{R}^2 ``` -for which +for which ```math \gamma(t_i) = u_i \quad i = 1, \ldots, n, ``` -given a suitable set of 'time' values +given a suitable set of 'time' values ```math 0 = t_1 < t_2 < \ldots < t_n = T, @@ -404,14 +403,15 @@ That's pretty neat, but this method does not directly generalize to higher dimen Let's try to generalize the method above. The goal is to find a point $\tilde{u}_{j + \frac{1}{2}}$ and unit direction $\tilde{d}_{j + \frac{1}{2}}$ to add to the tangent curve between $\tilde{u}_j$ and $\tilde{u}_{j+1}$ such that: -- the tangent line intersections $\tilde{u}_{j, \text{int left}}, \tilde{u}_{j, \text{int right}}$ exist. This means that the new line is fixed by these 2 points; -- constructing $\tilde{\gamma}$ including this point gives gives an identical result to constructing $\tilde{\gamma}$ excluding this point if the tangent line intersection already existed. The latter implies that $\tilde{u}_{j + \frac{1}{2}}$ and $\tilde{d}_{j + \frac{1}{2}}$ yield a tangent line to the constructed circle arc. + - the tangent line intersections $\tilde{u}_{j, \text{int left}}, \tilde{u}_{j, \text{int right}}$ exist. This means that the new line is fixed by these 2 points; + - constructing $\tilde{\gamma}$ including this point gives gives an identical result to constructing $\tilde{\gamma}$ excluding this point if the tangent line intersection already existed. The latter implies that $\tilde{u}_{j + \frac{1}{2}}$ and $\tilde{d}_{j + \frac{1}{2}}$ yield a tangent line to the constructed circle arc. Let's assume the tangent line intersection exists, and we define ```math \tilde{u}_{j, \text{int left}} = \tilde{u}_{j, \text{int}} - \delta_j^* \tilde{d}_{j}, ``` + ```math \tilde{u}_{j, \text{int right}} = \tilde{u}_{j, \text{int}} + \delta_j^* \tilde{d}_{j+1}. ``` @@ -466,11 +466,12 @@ If we generalize the definition of $\tilde{u}_{j, \text{int}}$ then we can compu \argmin_{s,\; t \;\in\; \mathbb{R}} \|\tilde{u}_{j+1} + s\tilde{d}_{j+1} - (\tilde{u}_j + t\tilde{d}_j)\|_2. ``` -This yields +This yields ```math \tilde{u}_{j, \text{close left}} = \tilde{u}_j + \frac{\langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_j\rangle - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle \langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_{j+1}\rangle}{1 - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle^2}\tilde{d}_j, ``` + ```math \tilde{u}_{j, \text{close right}} = \tilde{u}_{j+1} + \frac{\langle\tilde{d}_j, \tilde{d}_{j+1}\rangle\langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_j\rangle - \langle\tilde{u}_{j+1}-\tilde{u}_j, \tilde{d}_{j+1}\rangle}{1 - \langle\tilde{d}_j, \tilde{d}_{j+1}\rangle^2}\tilde{d}_{j+1}. ``` @@ -481,11 +482,12 @@ This is the same as the two expressions for $\tilde{u}_{j, \text{int}}$ from bef \tilde{u}_{j, \text{int}} = \frac{\tilde{u}_{j, \text{close left}} + \tilde{u}_{j, \text{close right}}}{2}. ``` -From this $\delta_j$ and $\delta_j^*$ follow, and +From this $\delta_j$ and $\delta_j^*$ follow, and ```math \tilde{u}_{j, \text{int left}} = \tilde{u}_{j, \text{close left}} - \delta_j^* \tilde{d}_{j}, ``` + ```math \tilde{u}_{j, \text{int right}} = \tilde{u}_{j, \text{close right}} + \delta_j^* \tilde{d}_{j+1}. -``` \ No newline at end of file +``` diff --git a/src/derivatives.jl b/src/derivatives.jl index f4eeb1f6..4314559e 100644 --- a/src/derivatives.jl +++ b/src/derivatives.jl @@ -315,7 +315,8 @@ function _derivative( end function _derivative(A::SmoothArcLengthInterpolation, t::Number, iguess) - (; out) = A + (; derivative, in_place) = A + derivative = in_place ? derivative : similar(derivative, typeof(t)) idx = get_idx(A, t, iguess) Δt_circ_seg = A.Δt_circle_segment[idx] Δt_line_seg = A.Δt_line_segment[idx] @@ -330,20 +331,20 @@ function _derivative(A::SmoothArcLengthInterpolation, t::Number, iguess) if in_circle_arc t_circle_seg = short_side_left ? Δt : Δt - Δt_line_seg - S, C = sincos(t_circle_seg / A.radius[idx]) + Rⱼ = A.radius[idx] + S, C = sincos(t_circle_seg / Rⱼ) v₁ = view(A.dir_1, :, idx) v₂ = view(A.dir_2, :, idx) - Rⱼ = A.radius[idx] - @. out = (-S * v₁ + C * v₂) / Rⱼ + @. derivative = (-S * v₁ + C * v₂) / Rⱼ else if short_side_left d₁ = view(A.d, :, idx + 1) - @. out = d₁ + @. derivative = d₁ else d₀ = view(A.d, :, idx) - @. out = d₀ + @. derivative = d₀ end end - out + derivative end diff --git a/src/interpolation_caches.jl b/src/interpolation_caches.jl index 78bd170b..d656417b 100644 --- a/src/interpolation_caches.jl +++ b/src/interpolation_caches.jl @@ -1362,18 +1362,20 @@ struct SmoothArcLengthInterpolation{ cache_parameters::Bool linear_lookup::Bool out::Vector{P} + derivative::Vector{P} + in_place::Bool function SmoothArcLengthInterpolation( u, t, d, shape_itp, Δt_circle_segment, Δt_line_segment, center, radius, dir_1, dir_2, short_side_left, I, extrapolation_left, extrapolation_right, - assume_linear_t, out) + assume_linear_t, out, derivative, in_place) linear_lookup = seems_linear(assume_linear_t, t) new{typeof(u), typeof(t), typeof(I), eltype(radius), eltype(d), typeof(shape_itp), eltype(u)}( u, t, d, shape_itp, Δt_circle_segment, Δt_line_segment, center, radius, dir_1, dir_2, short_side_left, I, nothing, extrapolation_left, extrapolation_right, - Guesser(t), false, linear_lookup, out + Guesser(t), false, linear_lookup, out, derivative, in_place ) end end @@ -1509,7 +1511,9 @@ function SmoothArcLengthInterpolation( extrapolation::ExtrapolationType.T = ExtrapolationType.None, extrapolation_left::ExtrapolationType.T = ExtrapolationType.None, extrapolation_right::ExtrapolationType.T = ExtrapolationType.None, - cache_parameters = false, assume_linear_t = 1e-2) + cache_parameters::Bool = false, + assume_linear_t = 1e-2, + in_place::Bool = true) # Note: this method assumes that consecutive tangent lines are coplanar, # which is generally not the case for >2 dimensional points. Use the other constructors # to make sure this is satisfied. @@ -1577,9 +1581,10 @@ function SmoothArcLengthInterpolation( linear_lookup = seems_linear(assume_linear_t, t) out = Vector{P}(undef, N) + derivative = Vector{P}(undef, N) return SmoothArcLengthInterpolation( u, t, d, shape_itp, Δt_circle_segment, Δt_line_segment, center, radius, dir_1, dir_2, short_side_left, - nothing, extrapolation_left, extrapolation_right, linear_lookup, out) + nothing, extrapolation_left, extrapolation_right, linear_lookup, out, derivative, in_place) end diff --git a/src/interpolation_methods.jl b/src/interpolation_methods.jl index 9b50868b..5d0c1e3e 100644 --- a/src/interpolation_methods.jl +++ b/src/interpolation_methods.jl @@ -338,7 +338,8 @@ function _interpolate( end function _interpolate(A::SmoothArcLengthInterpolation, t::Number, iguess) - (; out) = A + (; out, in_place) = A + out = in_place ? out : similar(out, typeof(t)) idx = get_idx(A, t, iguess) Δt_circ_seg = A.Δt_circle_segment[idx] Δt_line_seg = A.Δt_line_segment[idx] @@ -353,7 +354,8 @@ function _interpolate(A::SmoothArcLengthInterpolation, t::Number, iguess) if in_circle_arc t_circle_seg = short_side_left ? Δt : Δt - Δt_line_seg - S, C = sincos(t_circle_seg / A.radius[idx]) + Rⱼ = A.radius[idx] + S, C = sincos(t_circle_seg / Rⱼ) c = view(A.center, :, idx) v₁ = view(A.dir_1, :, idx) v₂ = view(A.dir_2, :, idx) diff --git a/test/derivative_tests.jl b/test/derivative_tests.jl index 376b3310..433e600a 100644 --- a/test/derivative_tests.jl +++ b/test/derivative_tests.jl @@ -7,6 +7,7 @@ using StableRNGs using RegularizationTools using Optim using ForwardDiff +using LinearAlgebra function test_derivatives(method; args = [], kwargs = [], name::String) kwargs_extrapolation = (method == Curvefit) ? @@ -28,10 +29,11 @@ function test_derivatives(method; args = [], kwargs = [], name::String) @test isapprox(cdiff2, adiff2, atol = 1e-8) end + func isa SmoothArcLengthInterpolation && return + # Interpolation time points for _t in t[2:(end - 1)] - if func isa BSplineInterpolation || func isa BSplineApprox || - func isa CubicHermiteSpline + if func isa Union{BSplineInterpolation, BSplineApprox, CubicHermiteSpline} fdiff = forward_fdm(5, 1; geom = true)(func, _t) fdiff2 = forward_fdm(5, 1; geom = true)(t -> derivative(func, t), _t) else @@ -53,7 +55,8 @@ function test_derivatives(method; args = [], kwargs = [], name::String) fdiff = forward_fdm(5, 1; geom = true)(func, t[1]) adiff = derivative(func, t[1]) @test isapprox(fdiff, adiff, atol = 1e-8) - if !(func isa BSplineInterpolation || func isa BSplineApprox) + if !(func isa + Union{BSplineInterpolation, BSplineApprox, SmoothArcLengthInterpolation}) fdiff2 = forward_fdm(5, 1; geom = true)(t -> derivative(func, t), t[1]) adiff2 = derivative(func, t[1], 2) @test isapprox(fdiff2, adiff2, atol = 1e-8) @@ -63,7 +66,8 @@ function test_derivatives(method; args = [], kwargs = [], name::String) fdiff = backward_fdm(5, 1; geom = true)(func, t[end]) adiff = derivative(func, t[end]) @test isapprox(fdiff, adiff, atol = 1e-8) - if !(func isa BSplineInterpolation || func isa BSplineApprox) + if !(func isa + Union{BSplineInterpolation, BSplineApprox, SmoothArcLengthInterpolation}) fdiff2 = backward_fdm(5, 1; geom = true)(t -> derivative(func, t), t[end]) adiff2 = derivative(func, t[end], 2) @test isapprox(fdiff2, adiff2, atol = 1e-8) @@ -262,6 +266,18 @@ end @test derivative(A, 300.0)≈0.0331361 rtol=1e-5 end +@testset "Smooth Arc Length Interpolation" begin + u = [0.3 -1.5 3.1; -0.2 0.2 -1.5; 10.4 -37.2 -5.8] + test_derivatives( + SmoothArcLengthInterpolation, args = [u], kwargs = Pair[ + :m => 5, :in_place => false], + name = "Smooth Arc Length Interpolation") + A = SmoothArcLengthInterpolation(u'; m = 25, in_place = false) + @test all(t -> norm(derivative(A, t)) ≈ 1, range(0, A.t[end]; length = 100)) + @test all( + t_ -> derivative(A, prevfloat(t_)) ≈ derivative(A, nextfloat(t_)), A.t[2:(end - 1)]) +end + @testset "RegularizationSmooth" begin npts = 50 xmin = 0.0 diff --git a/test/interpolation_tests.jl b/test/interpolation_tests.jl index 16e33562..9c058ee8 100644 --- a/test/interpolation_tests.jl +++ b/test/interpolation_tests.jl @@ -4,6 +4,7 @@ using StableRNGs using Optim, ForwardDiff using BenchmarkTools using Unitful +using LinearAlgebra function test_interpolation_type(T) @test T <: DataInterpolations.AbstractInterpolation @@ -910,6 +911,29 @@ end @test @inferred(output_dim(A)) == 0 end +@testset "Smooth Arc Length Interpolation" begin + # Directly from data (assuming line intersections exist) + u = [0.0 0.0 0.0; 1.0 1.0 1.0] + d = [0.0 0.0 1.0; inv(sqrt(2)) inv(sqrt(2)) 0.0] + A = SmoothArcLengthInterpolation(u', d') + @test isnothing(A.shape_itp) + @test only(A.Δt_circle_segment) ≈ π / 2 + @test only(A.Δt_line_segment) ≈ sqrt(2) - 1 + @test A.center ≈ [inv(sqrt(2)), inv(sqrt(2)), 0] + @test only(A.radius) ≈ 1 + @test A.dir_1 ≈ [-inv(sqrt(2)), -inv(sqrt(2)), 0] + @test A.dir_2 ≈ [0.0, 0.0, 1.0] + @test only(A.short_side_left) + + # From interpolation object + u = [0.3 -1.5 3.1; -0.2 0.2 -1.5; 0.0 0.0 0.0] + A = SmoothArcLengthInterpolation(u'; m = 25) + L = sum(norm.(diff(A.shape_itp(range(0, A.shape_itp.t[end]; length = 1_000_000))))) + @test A.t[end]≈L rtol=1e-4 + @test all( + t_ -> A(prevfloat(t_)) ≈ A(nextfloat(t_)), A.t[2:(end - 1)]) +end + @testset "Curvefit" begin # Curvefit Interpolation rng = StableRNG(12345) From 863a2b96ba4ac87dcd580dd241c6949e18d08bd0 Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Fri, 21 Mar 2025 17:13:32 +0100 Subject: [PATCH 06/11] Cleanup code and add docstrings --- docs/make.jl | 4 +- docs/src/arclength_interpolation.md | 11 +- src/interpolation_caches.jl | 259 +++++++++++++++++++--------- src/interpolation_utils.jl | 24 +++ 4 files changed, 205 insertions(+), 93 deletions(-) diff --git a/docs/make.jl b/docs/make.jl index 743ba4ea..70c52097 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -9,9 +9,7 @@ makedocs(modules = [DataInterpolations], sitename = "DataInterpolations.jl", clean = true, doctest = false, - linkcheck = false, - checkdocs = :none, - pagesonly = true, + linkcheck = true, format = Documenter.HTML(assets = ["assets/favicon.ico"], canonical = "https://docs.sciml.ai/DataInterpolations/stable/"), pages = [ diff --git a/docs/src/arclength_interpolation.md b/docs/src/arclength_interpolation.md index 1e6552f1..ffc88936 100644 --- a/docs/src/arclength_interpolation.md +++ b/docs/src/arclength_interpolation.md @@ -4,7 +4,7 @@ Arc length interpolation is interpolation between points using a curve that is p ## Usage -`DataInteprolations.jl` offers an arc length interpolation method that approximates an existing non arc length interpolation by circle and line segments. This can be done by providing an interpolation object: +`DataInteprolations.jl` offers an arc length interpolation method that approximates an existing non arc length interpolation by circle and line segments. This can be done by providing an interpolation object (the shape interpolation): ```@example tutorial using DataInterpolations @@ -35,17 +35,20 @@ plot_itp(A) Here `m` determines how fine the approximation is. It is also possible to just provide the data points, optionally providing `t` and a preferred interpolation type which determines the shape of the curve. ```@example tutorial +using LinearAlgebra + # Example from only u A = SmoothArcLengthInterpolation(hcat(u...)) +@show typeof(A.shape_itp) plot_itp(A) ``` ## Docstrings -To do: add doc strings for the different constructors and add them here - ```@docs -SmoothArcLengthInterpolation +SmoothArcLengthInterpolation(::AbstractMatrix{U}) where {U} +SmoothArcLengthInterpolation(::DataInterpolations.AbstractInterpolation) +SmoothArcLengthInterpolation(::AbstractMatrix, ::AbstractMatrix) ``` ## Method derivation diff --git a/src/interpolation_caches.jl b/src/interpolation_caches.jl index d656417b..2bc29534 100644 --- a/src/interpolation_caches.jl +++ b/src/interpolation_caches.jl @@ -1326,19 +1326,6 @@ function QuinticHermiteSpline( extrapolation_right, cache_parameters, linear_lookup) end -""" - Signature... - -Interpolate in a C¹ smooth way trough the data with unit speed. - -## Arguments - -... - -## Keyword Arguments - -... -""" struct SmoothArcLengthInterpolation{ uType, tType, IType, P, D, S <: Union{AbstractInterpolation, Nothing}, T} <: AbstractInterpolation{T} @@ -1380,6 +1367,44 @@ struct SmoothArcLengthInterpolation{ end end +""" + SmoothArcLengthInterpolation( + u::AbstractMatrix{U}; + t::Union{AbstractVector, Nothing} = nothing, + interpolation_type::Type{<:AbstractInterpolation} = QuadraticSpline, + kwargs...) where {U} + +Interpolate in a C¹ smooth way trough the data with unit speed by approximating +an interpolation (the shape interpolation) with line segments and circle segments. + +## Arguments + + - `u`: The data to be interpolated in matrix form; (ndim, ndata). + +NOTE: With this method it is not possible to pass keyword arguments to the constructor of the shape interpolation. +If you want to do this, construct the shape interpolation yourself and use the +`SmoothArcLengthInterpolation(shape_itp::AbstractInterpolation; kwargs...)` method. + +## Keyword Arguments + + - `t`: The time points of the shape interpolation. By default given by the cumulative sum of the Euclidean + distances between the points `u`. + - `interpolation_type`: The type of the shape interpolation. Defaults to `QuadraticSpline`. Note that + for the `SmoothArcLengthInterpolation` to be C¹ smooth, the `interpolation_type` must be C¹ smooth as well. + - `m`: The number of points at which the shape interpolation is evaluated in each interval between time points. + The `SmoothArcLengthInterpolation` converges to the shape interpolation (in shape) as m → ∞. + - `extrapolation`: The extrapolation type applied left and right of the data. Possible options + are `ExtrapolationType.None` (default), `ExtrapolationType.Constant`, `ExtrapolationType.Linear` + `ExtrapolationType.Extension`, `ExtrapolationType.Periodic` and `ExtrapolationType.Reflective`. + - `extrapolation_left`: The extrapolation type applied left of the data. See `extrapolation` for + the possible options. This keyword is ignored if `extrapolation != Extrapolation.none`. + - `extrapolation_right`: The extrapolation type applied right of the data. See `extrapolation` for + the possible options. This keyword is ignored if `extrapolation != Extrapolation.none`. + - `assume_linear_t`: boolean value to specify a faster index lookup behaviour for + evenly-distributed abscissae. Alternatively, a numerical threshold may be specified + for a test based on the normalized standard deviation of the difference with respect + to the straight line (see [`looks_linear`](@ref)). Defaults to 1e-2. +""" function SmoothArcLengthInterpolation( u::AbstractMatrix{U}; t::Union{AbstractVector, Nothing} = nothing, @@ -1401,8 +1426,38 @@ function SmoothArcLengthInterpolation( SmoothArcLengthInterpolation(shape_itp; kwargs...) end +""" + function SmoothArcLengthInterpolation( + shape_itp::AbstractInterpolation; + m::Integer = 2, + kwargs...) + +Approximate the `shape_itp` with a C¹ unit speed interpolation using line segments and circle segments. + +## Arguments + + - `shape_itp`: The interpolation to be approximated. Note that + for the `SmoothArcLengthInterpolation` to be C¹ smooth, the `shape_itp` must be C¹ smooth as well. + +## Keyword Arguments + + - `m`: The number of points at which the shape interpolation is evaluated in each interval between time points. + The `SmoothArcLengthInterpolation` converges to the shape interpolation (in shape) as m → ∞. + - `extrapolation`: The extrapolation type applied left and right of the data. Possible options + are `ExtrapolationType.None` (default), `ExtrapolationType.Constant`, `ExtrapolationType.Linear` + `ExtrapolationType.Extension`, `ExtrapolationType.Periodic` and `ExtrapolationType.Reflective`. + - `extrapolation_left`: The extrapolation type applied left of the data. See `extrapolation` for + the possible options. This keyword is ignored if `extrapolation != Extrapolation.none`. + - `extrapolation_right`: The extrapolation type applied right of the data. See `extrapolation` for + the possible options. This keyword is ignored if `extrapolation != Extrapolation.none`. + - `assume_linear_t`: boolean value to specify a faster index lookup behaviour for + evenly-distributed abscissae. Alternatively, a numerical threshold may be specified + for a test based on the normalized standard deviation of the difference with respect + to the straight line (see [`looks_linear`](@ref)). Defaults to 1e-2. +""" function SmoothArcLengthInterpolation( - shape_itp::AbstractInterpolation; m::Integer = 2, + shape_itp::AbstractInterpolation; + m::Integer = 2, kwargs... ) (; u, t) = shape_itp @@ -1412,10 +1467,10 @@ function SmoothArcLengthInterpolation( N = length(first(u)) n = length(u) - # Number of points defining the tangent curve of itp + # Number of points defining the tangent curve of shape_itp n_tilde = m * (n - 1) + 1 - # The evaluations of itp + # The evaluations of shape_itp u_tilde = Matrix{T}(undef, N, n_tilde) d_tilde = Matrix{T}(undef, N, n_tilde) @@ -1434,79 +1489,129 @@ function SmoothArcLengthInterpolation( d_tilde[:, end] .= derivative(shape_itp, last(t)) normalize!(view(d_tilde, :, n_tilde)) - # Number of points in the augmented tangent curve of itp - n_hat = 2 * n_tilde - 1 + return SmoothArcLengthInterpolation(u_tilde, d_tilde; shape_itp, kwargs...) +end - # The data defining the augmented tangent curve of itp +""" + function SmoothArcLengthInterpolation( + u::AbstractMatrix, + d::AbstractMatrix + [, make_intersections::Val{<:Bool}]; + shape_itp::Union{AbstractInterpolation, Nothing} = nothing, + extrapolation::ExtrapolationType.T = ExtrapolationType.None, + extrapolation_left::ExtrapolationType.T = ExtrapolationType.None, + extrapolation_right::ExtrapolationType.T = ExtrapolationType.None, + cache_parameters::Bool = false, + assume_linear_t = 1e-2, + in_place::Bool = true) + +Make a C¹ smooth unit speed interpolation through the given data with the given tangents using line +segments and circle segments. + +## Arguments + + - `u`: The data to be interpolated in matrix form; (ndim, ndata). + - `d`: The tangents to the curve in the points `u`. + - `make_intersections`: Whether additional (point, tangent) pairs have to be added in between the provided + data to ensure that the consecutive (tangent) lines intersect. Defaults to `Val(true)`. + +## Keyword Arguments + + - `shape_itp`: The interpolation that is being approximated, if one exists. Note that this + interpolation is not being used; it is just passed along to keep track of where the shape + of the `SmoothArcLengthInterpolation` originated. + - `extrapolation`: The extrapolation type applied left and right of the data. Possible options + are `ExtrapolationType.None` (default), `ExtrapolationType.Constant`, `ExtrapolationType.Linear` + `ExtrapolationType.Extension`, `ExtrapolationType.Periodic` and `ExtrapolationType.Reflective`. + - `extrapolation_left`: The extrapolation type applied left of the data. See `extrapolation` for + the possible options. This keyword is ignored if `extrapolation != Extrapolation.none`. + - `extrapolation_right`: The extrapolation type applied right of the data. See `extrapolation` for + the possible options. This keyword is ignored if `extrapolation != Extrapolation.none`. + - `assume_linear_t`: boolean value to specify a faster index lookup behaviour for + evenly-distributed abscissae. Alternatively, a numerical threshold may be specified + for a test based on the normalized standard deviation of the difference with respect + to the straight line (see [`looks_linear`](@ref)). Defaults to 1e-2. +""" +function SmoothArcLengthInterpolation( + u::AbstractMatrix, + d::AbstractMatrix; + kwargs...) + SmoothArcLengthInterpolation(u, d, Val{true}(); kwargs...) +end + +function SmoothArcLengthInterpolation( + u::AbstractMatrix, + d::AbstractMatrix, + make_intersections::Val{true}; + kwargs...) + N, n = size(u) + + # Number of points in the augmented tangent curve + n_hat = 2 * n - 1 + + # The data defining the augmented tangent curve + T = promote_type(eltype(eltype(u)), eltype(d)) u_hat = Matrix{T}(undef, N, n_hat) d_hat = Matrix{T}(undef, N, n_hat) k = 1 - Δu_tilde = Vector{T}(undef, N) - u_tilde_j_close_left = Vector{T}(undef, N) - u_tilde_j_close_right = Vector{T}(undef, N) - u_tilde_j_int = Vector{T}(undef, N) - u_tilde_j_int_left = Vector{T}(undef, N) - u_tilde_j_int_right = Vector{T}(undef, N) - - for j in 1:(n_tilde - 1) - u_hat[:, k] .= u_tilde[:, j] - d_hat[:, k] .= d_tilde[:, j] - - u_tilde_j = view(u_tilde, :, j) - d_tilde_j = view(d_tilde, :, j) - u_tilde_j_plus_1 = view(u_tilde, :, j + 1) - d_tilde_j_plus_1 = view(d_tilde, :, j + 1) - d_tilde_inner = dot(d_tilde_j, d_tilde_j_plus_1) - - @. Δu_tilde = u_tilde_j_plus_1 - u_tilde_j - - inner_1 = dot(Δu_tilde, d_tilde_j) - inner_2 = dot(Δu_tilde, d_tilde_j_plus_1) - denom = 1 - d_tilde_inner^2 - d_tilde_j_coef = (inner_1 - d_tilde_inner * inner_2) / denom - d_tilde_j_plus_1_coef = (d_tilde_inner * inner_1 - inner_2) / denom - - if !((d_tilde_j_coef >= 0) && (d_tilde_j_plus_1_coef <= 0)) + Δu = Vector{T}(undef, N) + uⱼ_close_left = Vector{T}(undef, N) + uⱼ_close_right = Vector{T}(undef, N) + uⱼ_int = Vector{T}(undef, N) + uⱼ_int_left = Vector{T}(undef, N) + uⱼ_int_right = Vector{T}(undef, N) + + for j in 1:(n - 1) + u_hat[:, k] .= u[:, j] + d_hat[:, k] .= d[:, j] + + uⱼ, uⱼ₊₁, dⱼ, dⱼ₊₁, d_inner = smooth_arc_length_params_1!(Δu, u, d, j) + + inner_1 = dot(Δu, dⱼ) + inner_2 = dot(Δu, dⱼ₊₁) + denom = 1 - d_inner^2 + dⱼ_coef = (inner_1 - d_inner * inner_2) / denom + dⱼ₊₁_coef = (d_inner * inner_1 - inner_2) / denom + + if !((dⱼ_coef >= 0) && (dⱼ₊₁_coef <= 0)) error("Some consecutive tangent lines do not converge, consider increasing m.") end - @. u_tilde_j_close_left = u_tilde_j + d_tilde_j_coef * d_tilde_j - @. u_tilde_j_close_right = u_tilde_j_plus_1 + - d_tilde_j_plus_1_coef * d_tilde_j_plus_1 - @. u_tilde_j_int = (u_tilde_j_close_left + u_tilde_j_close_right) / 2 + @. uⱼ_close_left = uⱼ + dⱼ_coef * dⱼ + @. uⱼ_close_right = uⱼ₊₁ + + dⱼ₊₁_coef * dⱼ₊₁ + @. uⱼ_int = (uⱼ_close_left + uⱼ_close_right) / 2 # compute δ_star - δ_j = min( - euclidean(u_tilde_j_int, u_tilde_j), - euclidean(u_tilde_j_int, u_tilde_j_plus_1) - ) - δ_j_star = δ_j * (2 - sqrt(2 + 2 * d_tilde_inner)) / (1 - d_tilde_inner) + δⱼ, _, _ = smooth_arc_length_params_2(uⱼ_int, uⱼ, uⱼ₊₁) + δⱼ_star = δⱼ * (2 - sqrt(2 + 2 * d_inner)) / (1 - d_inner) # Compute the points whose connecting line defines the tangent curve augmenting point - @. u_tilde_j_int_left = u_tilde_j_close_left - δ_j_star * d_tilde_j - @. u_tilde_j_int_right = u_tilde_j_close_right + δ_j_star * d_tilde_j_plus_1 + @. uⱼ_int_left = uⱼ_close_left - δⱼ_star * dⱼ + @. uⱼ_int_right = uⱼ_close_right + δⱼ_star * dⱼ₊₁ # Compute tangent curve augmenting point - u_tilde_j_plus_half = view(u_hat, :, k + 1) - d_tilde_j_plus_half = view(d_hat, :, k + 1) + uⱼ_plus_half = view(u_hat, :, k + 1) + dⱼ_plus_half = view(d_hat, :, k + 1) - @. u_tilde_j_plus_half = (u_tilde_j_int_left + u_tilde_j_int_right) / 2 - @. d_tilde_j_plus_half = u_tilde_j_int_right - u_tilde_j_int_left - normalize!(d_tilde_j_plus_half) + @. uⱼ_plus_half = (uⱼ_int_left + uⱼ_int_right) / 2 + @. dⱼ_plus_half = uⱼ_int_right - uⱼ_int_left + normalize!(dⱼ_plus_half) k += 2 end - u_hat[:, end] .= u_tilde[:, end] - d_hat[:, end] .= d_tilde[:, end] + u_hat[:, end] .= u[:, end] + d_hat[:, end] .= d[:, end] - return SmoothArcLengthInterpolation(u_hat, d_hat; shape_itp, kwargs...) + return SmoothArcLengthInterpolation(u_hat, d_hat, Val{false}(); kwargs...) end function SmoothArcLengthInterpolation( u::AbstractMatrix, - d::AbstractMatrix; + d::AbstractMatrix, + ::Val{false}; shape_itp::Union{AbstractInterpolation, Nothing} = nothing, extrapolation::ExtrapolationType.T = ExtrapolationType.None, extrapolation_left::ExtrapolationType.T = ExtrapolationType.None, @@ -1514,10 +1619,6 @@ function SmoothArcLengthInterpolation( cache_parameters::Bool = false, assume_linear_t = 1e-2, in_place::Bool = true) - # Note: this method assumes that consecutive tangent lines are coplanar, - # which is generally not the case for >2 dimensional points. Use the other constructors - # to make sure this is satisfied. - N = size(u, 1) n_circle_arcs = size(u, 2) - 1 @@ -1537,26 +1638,13 @@ function SmoothArcLengthInterpolation( # Compute circle segments and line segments for j in 1:n_circle_arcs - uⱼ = view(u, :, j) - uⱼ₊₁ = view(u, :, j + 1) - @. Δu = uⱼ₊₁ - uⱼ - - dⱼ = view(d, :, j) - dⱼ₊₁ = view(d, :, j + 1) - d_inner = dot(dⱼ, dⱼ₊₁) + uⱼ, uⱼ₊₁, dⱼ, dⱼ₊₁, d_inner = smooth_arc_length_params_1!(Δu, u, d, j) dⱼ_coef = (dot(Δu, dⱼ) - d_inner * dot(Δu, dⱼ₊₁)) / (1 - d_inner^2) @. u_int = uⱼ + dⱼ_coef * dⱼ - dist₁ = euclidean(u_int, uⱼ) - dist₂ = euclidean(u_int, uⱼ₊₁) - - δⱼ = if dist₁ < dist₂ - short_side_left[j] = true - dist₁ - else - dist₂ - end + δⱼ, short_side_left_, Δt_line_seg = smooth_arc_length_params_2(u_int, uⱼ, uⱼ₊₁) + short_side_left[j] = short_side_left_ Rⱼ = δⱼ * sqrt((1 + d_inner) / (1 - d_inner)) radius[j] = Rⱼ @@ -1569,7 +1657,6 @@ function SmoothArcLengthInterpolation( @. v₂ = Rⱼ * dⱼ Δt_circle_seg = 2Rⱼ * atan(δⱼ, Rⱼ) - Δt_line_seg = abs(dist₂ - dist₁) Δt_circle_segment[j] = Δt_circle_seg Δt_line_segment[j] = Δt_line_seg diff --git a/src/interpolation_utils.jl b/src/interpolation_utils.jl index b9e6c3bc..bf06a19e 100644 --- a/src/interpolation_utils.jl +++ b/src/interpolation_utils.jl @@ -318,3 +318,27 @@ typed_nan(::AbstractArray{T}) where {T <: Integer} = zero(T) function euclidean(x::AbstractArray, y::AbstractArray) sqrt(mapreduce((xi, yi) -> abs2(yi - xi), +, x, y)) end + +function smooth_arc_length_params_1!(Δu, u, d, j) + uⱼ = view(u, :, j) + uⱼ₊₁ = view(u, :, j + 1) + dⱼ = view(d, :, j) + dⱼ₊₁ = view(d, :, j + 1) + @. Δu = uⱼ₊₁ - uⱼ + d_inner = dot(dⱼ, dⱼ₊₁) + return uⱼ, uⱼ₊₁, dⱼ, dⱼ₊₁, d_inner +end + +function smooth_arc_length_params_2(u_int, uⱼ, uⱼ₊₁) + dist₁ = euclidean(u_int, uⱼ) + dist₂ = euclidean(u_int, uⱼ₊₁) + Δt_line_seg = abs(dist₂ - dist₁) + short_side_left = false + δⱼ = if dist₁ < dist₂ + short_side_left = true + dist₁ + else + dist₂ + end + return δⱼ, short_side_left, Δt_line_seg +end From 0a6d6ff2090c5a9ede3b78593f09b843f43c4451 Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Fri, 21 Mar 2025 17:14:47 +0100 Subject: [PATCH 07/11] Remove project.toml --- docs/Project.toml | 22 ---------------------- 1 file changed, 22 deletions(-) delete mode 100644 docs/Project.toml diff --git a/docs/Project.toml b/docs/Project.toml deleted file mode 100644 index 62776428..00000000 --- a/docs/Project.toml +++ /dev/null @@ -1,22 +0,0 @@ -[deps] -DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" -Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" -ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" -ModelingToolkitStandardLibrary = "16a59e39-deab-5bd0-87e4-056b12336739" -Optim = "429524aa-4258-5aef-a3af-852621145aeb" -OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" -Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" -RegularizationTools = "29dad682-9a27-4bc3-9c72-016788665182" -StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" -Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" - -[compat] -Documenter = "1" -ModelingToolkit = "9" -ModelingToolkitStandardLibrary = "2" -Optim = "1" -OrdinaryDiffEq = "6" -Plots = "1" -RegularizationTools = "0.6" -StableRNGs = "1" -Symbolics = "5.29, 6.0" From 770c2acd8321b5f5b38f320fea8703f2fb0d3d2d Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Fri, 21 Mar 2025 17:15:12 +0100 Subject: [PATCH 08/11] Bring back inverting integrals docs --- docs/make.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/make.jl b/docs/make.jl index 70c52097..a7525bc3 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -19,7 +19,8 @@ makedocs(modules = [DataInterpolations], "Interface" => "interface.md", "Using with Symbolics/ModelingToolkit" => "symbolics.md", "Manual" => "manual.md", - "Smooth arc length interpolation" => "arclength_interpolation.md" # "Inverting Integrals" => "inverting_integrals.md"]) + "Smooth arc length interpolation" => "arclength_interpolation.md", + "Inverting Integrals" => "inverting_integrals.md" ]) deploydocs(repo = "github.com/SciML/DataInterpolations.jl"; push_preview = true) From 5a11494150d95f7393f0179952e32ea12b02d787 Mon Sep 17 00:00:00 2001 From: Bart de Koning <74617371+SouthEndMusic@users.noreply.github.com> Date: Fri, 21 Mar 2025 17:16:52 +0100 Subject: [PATCH 09/11] Update Project.toml --- docs/src/assets/Project.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/src/assets/Project.toml b/docs/src/assets/Project.toml index 62776428..56a44069 100644 --- a/docs/src/assets/Project.toml +++ b/docs/src/assets/Project.toml @@ -1,5 +1,4 @@ [deps] -DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" ModelingToolkitStandardLibrary = "16a59e39-deab-5bd0-87e4-056b12336739" From bef4b1fa1b9051c1a4f5b291b0dbe70d653c8aaa Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Fri, 21 Mar 2025 17:18:33 +0100 Subject: [PATCH 10/11] Move back docs project.toml --- docs/{src/assets => }/Project.toml | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/{src/assets => }/Project.toml (100%) diff --git a/docs/src/assets/Project.toml b/docs/Project.toml similarity index 100% rename from docs/src/assets/Project.toml rename to docs/Project.toml From 4bcd2e6fb6684344cf5c5a555916c6406263e8e9 Mon Sep 17 00:00:00 2001 From: Bart de Koning Date: Fri, 21 Mar 2025 17:24:11 +0100 Subject: [PATCH 11/11] Fix tests --- test/interpolation_tests.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/interpolation_tests.jl b/test/interpolation_tests.jl index 9c058ee8..43eaf659 100644 --- a/test/interpolation_tests.jl +++ b/test/interpolation_tests.jl @@ -915,7 +915,7 @@ end # Directly from data (assuming line intersections exist) u = [0.0 0.0 0.0; 1.0 1.0 1.0] d = [0.0 0.0 1.0; inv(sqrt(2)) inv(sqrt(2)) 0.0] - A = SmoothArcLengthInterpolation(u', d') + A = SmoothArcLengthInterpolation(u', d', Val{false}()) @test isnothing(A.shape_itp) @test only(A.Δt_circle_segment) ≈ π / 2 @test only(A.Δt_line_segment) ≈ sqrt(2) - 1