Various fixes. Ready to be merged

Author: jorgensd

chapter3/demo_smoothed_tv_inpainting.ipynb

@@ -29,15 +29,15 @@
     "- $f = m u_{\\mathrm{true}}$: observed incomplete image\n",
     "- $u$: reconstructed image\n",
     "\n",
-    "We compute $u$ by minimising\n",
+    "We compute $u$ by minimizing\n",
     "\n",
     "$$\n",
     "J(u)= {1 \\over 2}\\beta \\int_\\Omega m(u-f)^2\\,\\mathrm{d}x\n",
     "+ \\alpha \\int_\\Omega \\sqrt{||\\nabla u||^2 + \\varepsilon^2}~\\mathrm{d}x.\n",
     "$$\n",
     "\n",
     "The first term enforces agreement with the known image data, while\n",
-    "the second term is a smoothed total variation regularisation term.\n",
+    "the second term is a smoothed total variation regularization term.\n",
     "It promotes piecewise smooth solution and preserves edges\n",
     "$\\alpha$  and $\\beta$ control the balance between the data fidelity\n",
     "(fit to f) and smoothness.\n",
@@ -106,7 +106,7 @@
    "source": [
     "We use first order Lagrange elements for discretizing the image.\n",
     "In this space, the DOFs are the values of u at mesh vertices\n",
-    "the solution is continous but has piecewise constant gradient"
+    "the solution is continuous but has piecewise constant gradient"
    ]
   },
   {
@@ -175,7 +175,7 @@
     "\n",
     "We construct a mask with random \"holes\" inside the square\n",
     "* small circular regions are removed and set to 0\n",
-    "* everyhere else remains known (1)"
+    "* everywhere else remains known (1)"
    ]
   },
   {
@@ -209,12 +209,14 @@
     "    # number of speckles\n",
     "    num_speckles = 25\n",
     "    # random centers\n",
-    "    generator = np.random.Generator(np.random.MT19937(0))  # random seed for reproducibility\n",
+    "    generator = np.random.Generator(\n",
+    "        np.random.MT19937(0)\n",
+    "    )  # random seed for reproducibility\n",
     "\n",
     "    cx = generator.uniform(0.25, 0.75, num_speckles)\n",
     "    cy = generator.uniform(0.25, 0.75, num_speckles)\n",
     "    # random radii (small + varied)\n",
-    "    radii = generator.uniform(0.012, 0.035,  num_speckles)\n",
+    "    radii = generator.uniform(0.012, 0.035, num_speckles)\n",
     "    # create holes. mask =0 inside circles\n",
     "    for i in range(num_speckles):\n",
     "        r2 = (X - cx[i]) ** 2 + (Y - cy[i]) ** 2\n",
@@ -281,7 +283,7 @@
     "\n",
     "where # $\\varepsilon$ is the smoothing of the TV:\n",
     "* large $\\varepsilon$ smoother more like quadratic diffusion\n",
-    "* small $\\varepsilon$ closer to true TV edge pereserving"
+    "* small $\\varepsilon$ closer to true TV edge preserving"
    ]
   },
   {
@@ -302,12 +304,12 @@
    "metadata": {},
    "source": [
     "Smoothed TV inpainting energy functional.\n",
-    "We define the energy J(u) and use ufl.derivative to obtain\n",
-    "the residual form F.\n",
+    "We define the energy J(u) and use {py:func}`ufl.derivative` to obtain\n",
+    "the residual form $F(u; v)=0 \\quad\\forall v\\in V$:\n",
     "\n",
     "$$\n",
     "J(u) = {1 \\over 2}\\beta\\int_\\Omega m(u-f)^2\\,dx\n",
-    "+ \\alpha\\int_\\Omega \\sqrt{||\\nabla u||^2+\\varepsilon^2}\\,dx\n",
+    "+ \\alpha\\int_\\Omega \\sqrt{||\\nabla u||^2+\\varepsilon^2}~\\mathrm{d}x\n",
     "$$\n",
     "\n",
     "Taking the first variation gives the weak form F(u; v).\n",
@@ -318,7 +320,7 @@
     "+ \\alpha\\int_\\Omega\n",
     "{\\nabla u\\cdot\\nabla v\n",
     "\\over\n",
-    "\\sqrt{||\\nabla u||^2+\\varepsilon^2}}\\,dx\n",
+    "\\sqrt{||\\nabla u||^2+\\varepsilon^2}}~\\mathrm{d}x\n",
     "= 0 \\quad \\forall v\\in V.\n",
     "$$"
    ]
@@ -330,38 +332,22 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "v = ufl.TestFunction(V)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0055665b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "v = ufl.TestFunction(V)\n",
+    "\n",
     "J_energy = (\n",
     "    0.5 * beta * m * (u - f) ** 2 * ufl.dx\n",
     "    + alpha * ufl.sqrt(ufl.inner(ufl.grad(u), ufl.grad(u)) + eps**2) * ufl.dx\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3fbade6e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    ")\n",
+    "\n",
     "F = ufl.derivative(J_energy, u, v)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "77b7387d",
+   "id": "163eb995",
    "metadata": {},
    "source": [
-    "This formulation is based on total variation (TV) regulaization\n",
+    "This formulation is based on total variation (TV) regularization\n",
     "for image denoising and inpainting\n",
     "{cite:t}`tv-RUDIN1992TV,tv-CHAN2001TV`."
    ]
@@ -423,14 +409,14 @@
    "source": [
     "FEM Metrics\n",
     "Global number of degrees of freedom reports the  size of the\n",
-    "finite element discretisation H1 seminorm error measures the\n",
+    "finite element discretization H1 seminorm error measures the\n",
     "gradient error\n",
     "\n",
     "$$\n",
     "  \\vert\\vert\\nabla(u-u_{true})\\vert\\vert_{L_2 (\\Omega)}\n",
     "$$\n",
     "\n",
-    "This is useful as TV regulization is gradient based.\n",
+    "This is useful as TV regularization is gradient based.\n",
     "Smaller values mean the reconstruction recovers edge structure better"
    ]
   },
@@ -622,7 +608,7 @@
     "$$\n",
     "\n",
     "A decrease in the objective show that the nonlinear optimization\n",
-    "improved the damaged image undeer the smoothed TV model"
+    "improved the damaged image under the smoothed TV model"
    ]
   },
   {
@@ -654,15 +640,22 @@
     "J0 = 0.5 * float(beta) * J0_data + float(alpha) * J0_tv"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "f01dfcb3",
+   "metadata": {},
+   "source": [
+    "Printing statements for validation and metrics\n",
+    "If on main process"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "id": "65e16ee1",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Printing statments for validation and metrics\n",
-    "# If on main process\n",
     "if msh.comm.rank == 0:\n",
     "    print(\"---Smoothed TV inpainting results---\")\n",
     "\n",
@@ -699,7 +692,7 @@
     "We construct fields that allow us to visually asses the quality\n",
     "of the reconstruction\n",
     "$u-u_{true}$ is the global reconstruction error\n",
-    "$(1-m)(u-u_{true})$ is the hole error, restriced to the missing regions"
+    "$(1-m)(u-u_{true})$ is the hole error, restricted to the missing regions"
    ]
   },
   {
@@ -727,7 +720,8 @@
     "To plot in matplotlib\n",
     "1. extract the coordinates of the DOFs\n",
     "2. extract the function-space dofmap connectivity (triangles)\n",
-    "3. build a Triangulation object\n",
+    "3. build a {py:class}`Triangulation<matplotlib.tri.Triangulation>` object\n",
+    "\n",
     "This allows matplotlib to render the piecewise linear FEM solution"
    ]
   },
@@ -739,18 +733,8 @@
    "outputs": [],
    "source": [
     "coords = V.tabulate_dof_coordinates()\n",
-    "x, y = coords[:, 0], coords[:, 1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8a5a2ec4",
-   "metadata": {
-    "lines_to_next_cell": 2
-   },
-   "outputs": [],
-   "source": [
+    "x, y = coords[:, 0], coords[:, 1]\n",
+    "\n",
     "triangles = V.dofmap.list\n",
     "triang = mtri.Triangulation(x, y, triangles)"
    ]
@@ -761,8 +745,8 @@
    "metadata": {},
    "source": [
     "Plotting\n",
-    "We use tripcolor to plot scalar fields defined on a triangulated mesh\n",
-    "shading= \"flat\" shows piecewise constant coloring per triangle\n",
+    "We use {py:func}`matplotlib.pyplot.tripcolor` to plot scalar fields defined on a\n",
+    "triangulated mesh shading= \"flat\" shows piecewise constant coloring per triangle\n",
     "which better reflects the discrete FEM representations"
    ]
   },
@@ -796,7 +780,13 @@
     "lim = np.max(np.abs(u_minus_u_true.x.array))\n",
     "# $u-u_{true}$ is the global reconstruction error\n",
     "plot_field(\n",
-    "    axes[1, 1], u_minus_u_true.x.array, \"u - u_true\", fig, cmap=\"coolwarm\", vmin=-lim, vmax=lim\n",
+    "    axes[1, 1],\n",
+    "    u_minus_u_true.x.array,\n",
+    "    \"u - u_true\",\n",
+    "    fig,\n",
+    "    cmap=\"coolwarm\",\n",
+    "    vmin=-lim,\n",
+    "    vmax=lim,\n",
     ")\n",
     "# Hole only errors\n",
     "lim = np.max(np.abs(hole_error_field.x.array))\n",
@@ -830,6 +820,7 @@
  ],
  "metadata": {
   "jupytext": {
+   "formats": "ipynb,py:light",
    "main_language": "python"
   }
  },