Repository: hpgem/nanomesh (language: python)

Issue:
Add 'boundary layer' options to the 3D meshing
Similar to what #92, #103 did for 2D meshes, it would be useful to have a method to pad the 3D meshes.


Discussion / hints:

Fix patch:
diff --git a/docs/examples/How to pad a 3D mesh.nblink b/docs/examples/How to pad a 3D mesh.nblink
new file mode 100644
index 00000000..dd764b34
--- /dev/null
+++ b/docs/examples/How to pad a 3D mesh.nblink
@@ -0,0 +1,3 @@
+{
+    "path": "../../notebooks/sample_data/How to pad a 3D mesh.ipynb"
+}
diff --git a/nanomesh/mesh3d.py b/nanomesh/mesh3d.py
index bea12257..026a65e5 100644
--- a/nanomesh/mesh3d.py
+++ b/nanomesh/mesh3d.py
@@ -27,7 +27,8 @@ class BoundingBox:
     zmax: float
 
     @classmethod
-    def from_shape(cls, shape):
+    def from_shape(cls, shape: tuple):
+        """Generate bounding box from data shape."""
         xmin, ymin, zmin = 0, 0, 0
         xmax, ymax, zmax = np.array(shape) - 1
         return cls(xmin=xmin,
@@ -37,6 +38,52 @@ def from_shape(cls, shape):
                    ymax=ymax,
                    zmax=zmax)
 
+    @property
+    def dimensions(self) -> Tuple[float, float, float]:
+        """Return dimensions of bounding box."""
+        return (
+            self.xmax - self.xmin,
+            self.ymax - self.ymin,
+            self.zmax - self.zmin,
+        )
+
+    @classmethod
+    def from_points(cls, points: np.array):
+        """Generate bounding box from set of points or coordinates."""
+        xmax, ymax, zmax = np.max(points, axis=0)
+        xmin, ymin, zmin = np.min(points, axis=0)
+
+        return cls(
+            xmin=xmin,
+            xmax=xmax,
+            ymin=ymin,
+            ymax=ymax,
+            zmin=zmin,
+            zmax=zmax,
+        )
+
+    def to_points(self) -> np.ndarray:
+        """Return (m,3) array with corner points."""
+        return np.array([
+            [self.xmin, self.ymin, self.zmin],
+            [self.xmin, self.ymin, self.zmax],
+            [self.xmin, self.ymax, self.zmin],
+            [self.xmin, self.ymax, self.zmax],
+            [self.xmax, self.ymin, self.zmin],
+            [self.xmax, self.ymin, self.zmax],
+            [self.xmax, self.ymax, self.zmin],
+            [self.xmax, self.ymax, self.zmax],
+        ])
+
+    @property
+    def center(self) -> np.ndarray:
+        """Return center of the bounding box."""
+        return np.array((
+            (self.xmin + self.xmax) / 2,
+            (self.ymin + self.ymax) / 2,
+            (self.zmin + self.zmax) / 2,
+        ))
+
 
 def get_point_in_prop(
         prop: measure._regionprops.RegionProperties) -> np.ndarray:
@@ -114,17 +161,7 @@ def add_corner_points(mesh: TriangleMesh, bbox: BoundingBox) -> None:
     bbox : BoundingBox
         Container for the bounding box coordinates.
     """
-    corners = np.array([
-        [bbox.xmin, bbox.ymin, bbox.zmin],
-        [bbox.xmin, bbox.ymin, bbox.zmax],
-        [bbox.xmin, bbox.ymax, bbox.zmin],
-        [bbox.xmin, bbox.ymax, bbox.zmax],
-        [bbox.xmax, bbox.ymin, bbox.zmin],
-        [bbox.xmax, bbox.ymin, bbox.zmax],
-        [bbox.xmax, bbox.ymax, bbox.zmin],
-        [bbox.xmax, bbox.ymax, bbox.zmax],
-    ])
-
+    corners = bbox.to_points()
     mesh.points = np.vstack([mesh.points, corners])
 
 
@@ -196,7 +233,7 @@ def close_side(mesh, *, side: str, bbox: BoundingBox, ax: plt.Axes = None):
                               np.searchsorted(mapping[0, :], new_cells[mask])]
     new_cells = new_cells.reshape(shape)
 
-    new_labels = np.ones(len(new_cells)) * 123
+    new_labels = np.ones(len(new_cells))
 
     points = all_points
     cells = np.vstack([mesh.cells, new_cells])
@@ -279,6 +316,26 @@ def generate_contour(
 
         self.contour = mesh
 
+    def pad_contour(self, **kwargs):
+        """Pad the contour. See `nanomesh.TriangleMesh.pad3d` for info.
+
+        Parameters
+        ----------
+        **kwargs
+            Keyword arguments for `nanomesh.TriangleMesh.pad3d`.
+        """
+        self.contour = self.contour.pad3d(**kwargs)
+
+    def show_contour(self, **kwargs):
+        """Pad the contour. See `nanomesh.MeshContainer.plot_pyvista` for info.
+
+        Parameters
+        ----------
+        **kwargs
+            Keyword arguments for `nanomesh.MeshContainer.plot_pyvista`.
+        """
+        self.contour.plot_pyvista(**kwargs)
+
     def tetrahedralize(self, generate_region_markers: bool = False, **kwargs):
         """Tetrahedralize a surface contour mesh.
 
diff --git a/nanomesh/mesh_container.py b/nanomesh/mesh_container.py
index 736a4c5a..f3db6715 100644
--- a/nanomesh/mesh_container.py
+++ b/nanomesh/mesh_container.py
@@ -1,4 +1,5 @@
 from pathlib import Path
+from typing import List, Tuple
 
 import matplotlib.pyplot as plt
 import meshio
@@ -18,6 +19,7 @@ def __init__(self, points: np.ndarray, cells: np.ndarray, **metadata):
 
         self.points = points
         self.cells = cells
+        self.region_markers: List[Tuple[int, np.ndarray]] = []
 
         metadata.setdefault(self._label_key,
                             np.zeros(len(self.cells), dtype=int))
@@ -301,14 +303,14 @@ def subdivide(self, max_edge: int = 10, iters: int = 10) -> 'TriangleMesh':
         return TriangleMesh(points=points, cells=cells)
 
     def tetrahedralize(self,
-                       region_markers: dict = None,
+                       region_markers: List[Tuple[int, np.ndarray]] = None,
                        **kwargs) -> 'TetraMesh':
         """Tetrahedralize a contour.
 
         Parameters
         ----------
-        region_markers : dict, optional
-            Dictionary of region markers. If not defined, automatically
+        region_markers : list, optional
+            List of region markers. If not defined, automatically
             generate regions.
         **kwargs
             Keyword arguments passed to `nanomesh.tetgen.tetrahedralize`.
@@ -320,7 +322,9 @@ def tetrahedralize(self,
         import tempfile
 
         if region_markers is None:
-            region_markers = {}
+            region_markers = []
+
+        region_markers.extend(self.region_markers)
 
         from nanomesh import tetgen
         with tempfile.TemporaryDirectory() as tmp:
@@ -341,6 +345,17 @@ def pad(self, **kwargs) -> 'TriangleMesh':
         from nanomesh.mesh_utils import pad
         return pad(self, **kwargs)
 
+    def pad3d(self, **kwargs) -> 'TriangleMesh':
+        """Pad a 3d mesh.
+
+        Parameters
+        ----------
+        **kwargs
+            Keyword arguments passed to `nanomesh.mesh_utils.pad3d`
+        """
+        from nanomesh.mesh_utils_3d import pad3d
+        return pad3d(self, **kwargs)
+
 
 class TetraMesh(MeshContainer):
     _element_type = 'tetra'
diff --git a/nanomesh/mesh_utils_3d.py b/nanomesh/mesh_utils_3d.py
new file mode 100644
index 00000000..feeac387
--- /dev/null
+++ b/nanomesh/mesh_utils_3d.py
@@ -0,0 +1,148 @@
+import numpy as np
+
+from nanomesh.mesh3d import BoundingBox
+from nanomesh.mesh_container import TriangleMesh
+from nanomesh.utils import pairwise
+
+
+def pad3d(mesh: TriangleMesh,
+          *,
+          side: str,
+          width: int,
+          label: int = None) -> TriangleMesh:
+    """Pad a tetra mesh.
+
+    Parameters
+    ----------
+    mesh : TriangleMesh
+        The mesh to pad.
+    side : str
+        Side to pad, must be one of `left`, `right`, `top`, `bottom`.
+    width : int
+        Width of the padded area.
+    label : int, optional
+        The label to assign to the padded area. If not defined, generates the
+        next unique label based on the existing ones.
+
+    Returns
+    -------
+    new_mesh : TriangleMesh
+        Padded tetrahedral mesh.
+
+    Raises
+    ------
+    ValueError
+        When the value of `side` is invalid.
+    """
+    if label is None:
+        label = mesh.unique_labels.max() + 1
+
+    if width == 0:
+        return mesh
+
+    bbox = BoundingBox.from_points(mesh.points)
+
+    if side == 'top':
+        edge_col = 2
+        edge_value = bbox.zmax
+        extra_coords = np.array([
+            [bbox.xmin, bbox.ymin, bbox.zmax + width],
+            [bbox.xmin, bbox.ymax, bbox.zmax + width],
+            [bbox.xmax, bbox.ymin, bbox.zmax + width],
+            [bbox.xmax, bbox.ymax, bbox.zmax + width],
+        ])
+        column_order = (0, 1, 1, 0)
+    elif side == 'bottom':
+        edge_col = 2
+        edge_value = bbox.zmin
+        extra_coords = np.array([
+            [bbox.xmin, bbox.ymin, bbox.zmin - width],
+            [bbox.xmin, bbox.ymax, bbox.zmin - width],
+            [bbox.xmax, bbox.ymin, bbox.zmin - width],
+            [bbox.xmax, bbox.ymax, bbox.zmin - width],
+        ])
+        column_order = (0, 1, 1, 0)
+    elif side == 'left':
+        edge_col = 1
+        edge_value = bbox.ymin
+        extra_coords = np.array([
+            [bbox.xmin, bbox.ymin - width, bbox.zmin],
+            [bbox.xmin, bbox.ymin - width, bbox.zmax],
+            [bbox.xmax, bbox.ymin - width, bbox.zmin],
+            [bbox.xmax, bbox.ymin - width, bbox.zmax],
+        ])
+        column_order = (0, 2, 2, 0)
+    elif side == 'right':
+        edge_col = 1
+        edge_value = bbox.ymax
+        extra_coords = np.array([
+            [bbox.xmin, bbox.ymax + width, bbox.zmin],
+            [bbox.xmin, bbox.ymax + width, bbox.zmax],
+            [bbox.xmax, bbox.ymax + width, bbox.zmin],
+            [bbox.xmax, bbox.ymax + width, bbox.zmax],
+        ])
+        column_order = (0, 2, 2, 0)
+    elif side == 'front':
+        edge_col = 0
+        edge_value = bbox.xmin
+        extra_coords = np.array([
+            [bbox.xmin - width, bbox.ymin, bbox.zmin],
+            [bbox.xmin - width, bbox.ymin, bbox.zmax],
+            [bbox.xmin - width, bbox.ymax, bbox.zmin],
+            [bbox.xmin - width, bbox.ymax, bbox.zmax],
+        ])
+        column_order = (1, 2, 2, 1)
+    elif side == 'back':
+        edge_col = 0
+        edge_value = bbox.xmax
+        extra_coords = np.array([
+            [bbox.xmax + width, bbox.ymin, bbox.zmin],
+            [bbox.xmax + width, bbox.ymin, bbox.zmax],
+            [bbox.xmax + width, bbox.ymax, bbox.zmin],
+            [bbox.xmax + width, bbox.ymax, bbox.zmax],
+        ])
+        column_order = (1, 2, 2, 1)
+    else:
+        raise ValueError('Side must be one of `right`, `left`, `bottom`'
+                         f'`top`, `front`, `back`. Got {side=}')
+
+    n_points = len(mesh.points)
+    points = np.vstack([mesh.points, extra_coords])
+
+    new_triangles = [
+        np.array((0, 1, 2)) + n_points,
+        np.array((3, 1, 2)) + n_points,
+    ]
+
+    for corner, col in zip(extra_coords, column_order):
+        connect_to = np.argwhere((points[:, edge_col] == edge_value)
+                                 & (points[:, col] == corner[col]))
+
+        additional_points = np.argwhere(
+            extra_coords[:, col] == corner[col]) + n_points
+
+        first, last = additional_points
+        first_point = points[first]
+
+        sorted_by_distance = np.argsort(
+            np.linalg.norm(first_point - points[connect_to].squeeze(), axis=1))
+        connect_to = connect_to[sorted_by_distance]
+        connect_to = np.vstack([connect_to, last]).squeeze()
+
+        for pair in pairwise(connect_to):
+            tri = np.hstack((first, pair))
+            new_triangles.append(tri)
+
+    new_triangles = np.array(new_triangles).squeeze()
+
+    cells = np.vstack([mesh.cells, new_triangles])
+
+    new_mesh = TriangleMesh(points=points, cells=cells)
+
+    center = extra_coords.mean(axis=0)
+    center[col] = (center[col] + edge_value) / 2
+    # Next line introduces a BUG: https://github.com/hpgem/nanomesh/issues/137
+    # new_mesh.region_markers.extend(mesh.region_markers)
+    new_mesh.region_markers.append((label, center))
+
+    return new_mesh
diff --git a/nanomesh/tetgen.py b/nanomesh/tetgen.py
index 30e79977..652d1184 100644
--- a/nanomesh/tetgen.py
+++ b/nanomesh/tetgen.py
@@ -1,13 +1,14 @@
 import os
 from pathlib import Path
-from typing import Any, Tuple
+from typing import Any, Tuple, List
+import numpy as np
 
 from nanomesh.mesh_container import TriangleMesh
 
 
 def write_smesh(filename: os.PathLike,
                 mesh: TriangleMesh,
-                region_markers: dict = None):
+                region_markers: List[Tuple[int, np.ndarray]] = None):
     """Save a mesh to a `.smesh` format (Tetgen). http://wias-
     berlin.de/software/tetgen/1.5/doc/manual/manual006.html#ff_smesh.
 
@@ -17,11 +18,11 @@ def write_smesh(filename: os.PathLike,
         Filename to save the data to.
     mesh : TriangleMesh
         Mesh data to be saved.
-    region_markers : dict, optional
+    region_markers : list, optional
         Coordinates of region markers.
     """
     if region_markers is None:
-        region_markers = {}
+        region_markers = []
 
     path = Path(filename)
     with path.open('w') as f:
diff --git a/nanomesh/utils.py b/nanomesh/utils.py
index f21a519a..10bc9e47 100644
--- a/nanomesh/utils.py
+++ b/nanomesh/utils.py
@@ -1,4 +1,5 @@
 import time
+from itertools import tee
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -136,3 +137,11 @@ def show_image(image,
     ax.set_ylabel('y')
 
     return ax
+
+
+# https://docs.python.org/3.8/library/itertools.html#itertools-recipes
+def pairwise(iterable):
+    """s -> (s0,s1), (s1,s2), (s2, s3), ..."""
+    a, b = tee(iterable)
+    next(b, None)
+    return zip(a, b)
diff --git a/notebooks/sample_data/How to pad a 3D mesh.ipynb b/notebooks/sample_data/How to pad a 3D mesh.ipynb
new file mode 100644
index 00000000..7717a8f9
--- /dev/null
+++ b/notebooks/sample_data/How to pad a 3D mesh.ipynb
@@ -0,0 +1,1217 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "957a427f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib notebook"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2348fc8b",
+   "metadata": {},
+   "source": [
+    "## Padding a 3D mesh\n",
+    "\n",
+    "This notebook shows how to pad a 3D mesh. Note that padding a 3d mesh works different than a 2d mesh. The padding is done on the contour (before tetrahedralization), which is computationally much simpler than doing it on the tetrahedral mesh."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "153b43e0",
+   "metadata": {},
+   "source": [
+    "### Generating some data\n",
+    "\n",
+    "This cell generates a simple 3d volume."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "615e2cc7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Jupyter environment detected. Enabling Open3D WebVisualizer.\n",
+      "[Open3D INFO] WebRTC GUI backend enabled.\n",
+      "[Open3D INFO] WebRTCWindowSystem: HTTP handshake server disabled.\n",
+      "(48, 120, 72)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "/* global mpl */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "mpl.get_websocket_type = function () {\n",
+       "    if (typeof WebSocket !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert(\n",
+       "            'Your browser does not have WebSocket support. ' +\n",
+       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "                'Firefox 4 and 5 are also supported but you ' +\n",
+       "                'have to enable WebSockets in about:config.'\n",
+       "        );\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById('mpl-warnings');\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent =\n",
+       "                'This browser does not support binary websocket messages. ' +\n",
+       "                'Performance may be slow.';\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = document.createElement('div');\n",
+       "    this.root.setAttribute('style', 'display: inline-block');\n",
+       "    this._root_extra_style(this.root);\n",
+       "\n",
+       "    parent_element.appendChild(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen = function () {\n",
+       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+       "        fig.send_message('send_image_mode', {});\n",
+       "        if (fig.ratio !== 1) {\n",
+       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
+       "        }\n",
+       "        fig.send_message('refresh', {});\n",
+       "    };\n",
+       "\n",
+       "    this.imageObj.onload = function () {\n",
+       "        if (fig.image_mode === 'full') {\n",
+       "            // Full images could contain transparency (where diff images\n",
+       "            // almost always do), so we need to clear the canvas so that\n",
+       "            // there is no ghosting.\n",
+       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "        }\n",
+       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "    };\n",
+       "\n",
+       "    this.imageObj.onunload = function () {\n",
+       "        fig.ws.close();\n",
+       "    };\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function () {\n",
+       "    var titlebar = document.createElement('div');\n",
+       "    titlebar.classList =\n",
+       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+       "    var titletext = document.createElement('div');\n",
+       "    titletext.classList = 'ui-dialog-title';\n",
+       "    titletext.setAttribute(\n",
+       "        'style',\n",
+       "        'width: 100%; text-align: center; padding: 3px;'\n",
+       "    );\n",
+       "    titlebar.appendChild(titletext);\n",
+       "    this.root.appendChild(titlebar);\n",
+       "    this.header = titletext;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function () {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+       "    canvas_div.setAttribute(\n",
+       "        'style',\n",
+       "        'border: 1px solid #ddd;' +\n",
+       "            'box-sizing: content-box;' +\n",
+       "            'clear: both;' +\n",
+       "            'min-height: 1px;' +\n",
+       "            'min-width: 1px;' +\n",
+       "            'outline: 0;' +\n",
+       "            'overflow: hidden;' +\n",
+       "            'position: relative;' +\n",
+       "            'resize: both;'\n",
+       "    );\n",
+       "\n",
+       "    function on_keyboard_event_closure(name) {\n",
+       "        return function (event) {\n",
+       "            return fig.key_event(event, name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.addEventListener(\n",
+       "        'keydown',\n",
+       "        on_keyboard_event_closure('key_press')\n",
+       "    );\n",
+       "    canvas_div.addEventListener(\n",
+       "        'keyup',\n",
+       "        on_keyboard_event_closure('key_release')\n",
+       "    );\n",
+       "\n",
+       "    this._canvas_extra_style(canvas_div);\n",
+       "    this.root.appendChild(canvas_div);\n",
+       "\n",
+       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+       "    canvas.classList.add('mpl-canvas');\n",
+       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+       "\n",
+       "    this.context = canvas.getContext('2d');\n",
+       "\n",
+       "    var backingStore =\n",
+       "        this.context.backingStorePixelRatio ||\n",
+       "        this.context.webkitBackingStorePixelRatio ||\n",
+       "        this.context.mozBackingStorePixelRatio ||\n",
+       "        this.context.msBackingStorePixelRatio ||\n",
+       "        this.context.oBackingStorePixelRatio ||\n",
+       "        this.context.backingStorePixelRatio ||\n",
+       "        1;\n",
+       "\n",
+       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+       "        'canvas'\n",
+       "    ));\n",
+       "    rubberband_canvas.setAttribute(\n",
+       "        'style',\n",
+       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+       "    );\n",
+       "\n",
+       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+       "    if (this.ResizeObserver === undefined) {\n",
+       "        if (window.ResizeObserver !== undefined) {\n",
+       "            this.ResizeObserver = window.ResizeObserver;\n",
+       "        } else {\n",
+       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+       "            this.ResizeObserver = obs.ResizeObserver;\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+       "        var nentries = entries.length;\n",
+       "        for (var i = 0; i < nentries; i++) {\n",
+       "            var entry = entries[i];\n",
+       "            var width, height;\n",
+       "            if (entry.contentBoxSize) {\n",
+       "                if (entry.contentBoxSize instanceof Array) {\n",
+       "                    // Chrome 84 implements new version of spec.\n",
+       "                    width = entry.contentBoxSize[0].inlineSize;\n",
+       "                    height = entry.contentBoxSize[0].blockSize;\n",
+       "                } else {\n",
+       "                    // Firefox implements old version of spec.\n",
+       "                    width = entry.contentBoxSize.inlineSize;\n",
+       "                    height = entry.contentBoxSize.blockSize;\n",
+       "                }\n",
+       "            } else {\n",
+       "                // Chrome <84 implements even older version of spec.\n",
+       "                width = entry.contentRect.width;\n",
+       "                height = entry.contentRect.height;\n",
+       "            }\n",
+       "\n",
+       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+       "            // the canvas container.\n",
+       "            if (entry.devicePixelContentBoxSize) {\n",
+       "                // Chrome 84 implements new version of spec.\n",
+       "                canvas.setAttribute(\n",
+       "                    'width',\n",
+       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+       "                );\n",
+       "                canvas.setAttribute(\n",
+       "                    'height',\n",
+       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+       "                );\n",
+       "            } else {\n",
+       "                canvas.setAttribute('width', width * fig.ratio);\n",
+       "                canvas.setAttribute('height', height * fig.ratio);\n",
+       "            }\n",
+       "            canvas.setAttribute(\n",
+       "                'style',\n",
+       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+       "            );\n",
+       "\n",
+       "            rubberband_canvas.setAttribute('width', width);\n",
+       "            rubberband_canvas.setAttribute('height', height);\n",
+       "\n",
+       "            // And update the size in Python. We ignore the initial 0/0 size\n",
+       "            // that occurs as the element is placed into the DOM, which should\n",
+       "            // otherwise not happen due to the minimum size styling.\n",
+       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+       "                fig.request_resize(width, height);\n",
+       "            }\n",
+       "        }\n",
+       "    });\n",
+       "    this.resizeObserverInstance.observe(canvas_div);\n",
+       "\n",
+       "    function on_mouse_event_closure(name) {\n",
+       "        return function (event) {\n",
+       "            return fig.mouse_event(event, name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mousedown',\n",
+       "        on_mouse_event_closure('button_press')\n",
+       "    );\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mouseup',\n",
+       "        on_mouse_event_closure('button_release')\n",
+       "    );\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'dblclick',\n",
+       "        on_mouse_event_closure('dblclick')\n",
+       "    );\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mousemove',\n",
+       "        on_mouse_event_closure('motion_notify')\n",
+       "    );\n",
+       "\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mouseenter',\n",
+       "        on_mouse_event_closure('figure_enter')\n",
+       "    );\n",
+       "    rubberband_canvas.addEventListener(\n",
+       "        'mouseleave',\n",
+       "        on_mouse_event_closure('figure_leave')\n",
+       "    );\n",
+       "\n",
+       "    canvas_div.addEventListener('wheel', function (event) {\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        on_mouse_event_closure('scroll')(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.appendChild(canvas);\n",
+       "    canvas_div.appendChild(rubberband_canvas);\n",
+       "\n",
+       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+       "    this.rubberband_context.strokeStyle = '#000000';\n",
+       "\n",
+       "    this._resize_canvas = function (width, height, forward) {\n",
+       "        if (forward) {\n",
+       "            canvas_div.style.width = width + 'px';\n",
+       "            canvas_div.style.height = height + 'px';\n",
+       "        }\n",
+       "    };\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+       "        event.preventDefault();\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus() {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function () {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var toolbar = document.createElement('div');\n",
+       "    toolbar.classList = 'mpl-toolbar';\n",
+       "    this.root.appendChild(toolbar);\n",
+       "\n",
+       "    function on_click_closure(name) {\n",
+       "        return function (_event) {\n",
+       "            return fig.toolbar_button_onclick(name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    function on_mouseover_closure(tooltip) {\n",
+       "        return function (event) {\n",
+       "            if (!event.currentTarget.disabled) {\n",
+       "                return fig.toolbar_button_onmouseover(tooltip);\n",
+       "            }\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    fig.buttons = {};\n",
+       "    var buttonGroup = document.createElement('div');\n",
+       "    buttonGroup.classList = 'mpl-button-group';\n",
+       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            /* Instead of a spacer, we start a new button group. */\n",
+       "            if (buttonGroup.hasChildNodes()) {\n",
+       "                toolbar.appendChild(buttonGroup);\n",
+       "            }\n",
+       "            buttonGroup = document.createElement('div');\n",
+       "            buttonGroup.classList = 'mpl-button-group';\n",
+       "            continue;\n",
+       "        }\n",
+       "\n",
+       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+       "        button.classList = 'mpl-widget';\n",
+       "        button.setAttribute('role', 'button');\n",
+       "        button.setAttribute('aria-disabled', 'false');\n",
+       "        button.addEventListener('click', on_click_closure(method_name));\n",
+       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+       "\n",
+       "        var icon_img = document.createElement('img');\n",
+       "        icon_img.src = '_images/' + image + '.png';\n",
+       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+       "        icon_img.alt = tooltip;\n",
+       "        button.appendChild(icon_img);\n",
+       "\n",
+       "        buttonGroup.appendChild(button);\n",
+       "    }\n",
+       "\n",
+       "    if (buttonGroup.hasChildNodes()) {\n",
+       "        toolbar.appendChild(buttonGroup);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker = document.createElement('select');\n",
+       "    fmt_picker.classList = 'mpl-widget';\n",
+       "    toolbar.appendChild(fmt_picker);\n",
+       "    this.format_dropdown = fmt_picker;\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = document.createElement('option');\n",
+       "        option.selected = fmt === mpl.default_extension;\n",
+       "        option.innerHTML = fmt;\n",
+       "        fmt_picker.appendChild(option);\n",
+       "    }\n",
+       "\n",
+       "    var status_bar = document.createElement('span');\n",
+       "    status_bar.classList = 'mpl-message';\n",
+       "    toolbar.appendChild(status_bar);\n",
+       "    this.message = status_bar;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function (type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function () {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+       "        fig.send_message('refresh', {});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+       "    var x0 = msg['x0'] / fig.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+       "    var x1 = msg['x1'] / fig.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0,\n",
+       "        0,\n",
+       "        fig.canvas.width / fig.ratio,\n",
+       "        fig.canvas.height / fig.ratio\n",
+       "    );\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch (cursor) {\n",
+       "        case 0:\n",
+       "            cursor = 'pointer';\n",
+       "            break;\n",
+       "        case 1:\n",
+       "            cursor = 'default';\n",
+       "            break;\n",
+       "        case 2:\n",
+       "            cursor = 'crosshair';\n",
+       "            break;\n",
+       "        case 3:\n",
+       "            cursor = 'move';\n",
+       "            break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+       "    for (var key in msg) {\n",
+       "        if (!(key in fig.buttons)) {\n",
+       "            continue;\n",
+       "        }\n",
+       "        fig.buttons[key].disabled = !msg[key];\n",
+       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+       "    if (msg['mode'] === 'PAN') {\n",
+       "        fig.buttons['Pan'].classList.add('active');\n",
+       "        fig.buttons['Zoom'].classList.remove('active');\n",
+       "    } else if (msg['mode'] === 'ZOOM') {\n",
+       "        fig.buttons['Pan'].classList.remove('active');\n",
+       "        fig.buttons['Zoom'].classList.add('active');\n",
+       "    } else {\n",
+       "        fig.buttons['Pan'].classList.remove('active');\n",
+       "        fig.buttons['Zoom'].classList.remove('active');\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function () {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message('ack', {});\n",
+       "};\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            var img = evt.data;\n",
+       "            if (img.type !== 'image/png') {\n",
+       "                /* FIXME: We get \"Resource interpreted as Image but\n",
+       "                 * transferred with MIME type text/plain:\" errors on\n",
+       "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "                 * to be part of the websocket stream */\n",
+       "                img.type = 'image/png';\n",
+       "            }\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src\n",
+       "                );\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                img\n",
+       "            );\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        } else if (\n",
+       "            typeof evt.data === 'string' &&\n",
+       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+       "        ) {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig['handle_' + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\n",
+       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+       "                msg\n",
+       "            );\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\n",
+       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+       "                    e,\n",
+       "                    e.stack,\n",
+       "                    msg\n",
+       "                );\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "};\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function (e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e) {\n",
+       "        e = window.event;\n",
+       "    }\n",
+       "    if (e.target) {\n",
+       "        targ = e.target;\n",
+       "    } else if (e.srcElement) {\n",
+       "        targ = e.srcElement;\n",
+       "    }\n",
+       "    if (targ.nodeType === 3) {\n",
+       "        // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "    }\n",
+       "\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    var boundingRect = targ.getBoundingClientRect();\n",
+       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+       "\n",
+       "    return { x: x, y: y };\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys(original) {\n",
+       "    return Object.keys(original).reduce(function (obj, key) {\n",
+       "        if (typeof original[key] !== 'object') {\n",
+       "            obj[key] = original[key];\n",
+       "        }\n",
+       "        return obj;\n",
+       "    }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event);\n",
+       "\n",
+       "    if (name === 'button_press') {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * this.ratio;\n",
+       "    var y = canvas_pos.y * this.ratio;\n",
+       "\n",
+       "    this.send_message(name, {\n",
+       "        x: x,\n",
+       "        y: y,\n",
+       "        button: event.button,\n",
+       "        step: event.step,\n",
+       "        guiEvent: simpleKeys(event),\n",
+       "    });\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function (event, name) {\n",
+       "    // Prevent repeat events\n",
+       "    if (name === 'key_press') {\n",
+       "        if (event.key === this._key) {\n",
+       "            return;\n",
+       "        } else {\n",
+       "            this._key = event.key;\n",
+       "        }\n",
+       "    }\n",
+       "    if (name === 'key_release') {\n",
+       "        this._key = null;\n",
+       "    }\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.key !== 'Control') {\n",
+       "        value += 'ctrl+';\n",
+       "    }\n",
+       "    else if (event.altKey && event.key !== 'Alt') {\n",
+       "        value += 'alt+';\n",
+       "    }\n",
+       "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+       "        value += 'shift+';\n",
+       "    }\n",
+       "\n",
+       "    value += 'k' + event.key;\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+       "    return false;\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+       "    if (name === 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message('toolbar_button', { name: name });\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "\n",
+       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+       "// prettier-ignore\n",
+       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";/* global mpl */\n",
+       "\n",
+       "var comm_websocket_adapter = function (comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+       "    ws.readyState = comm.kernel.ws.readyState;\n",
+       "    function updateReadyState(_event) {\n",
+       "        if (comm.kernel.ws) {\n",
+       "            ws.readyState = comm.kernel.ws.readyState;\n",
+       "        } else {\n",
+       "            ws.readyState = 3; // Closed state.\n",
+       "        }\n",
+       "    }\n",
+       "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+       "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+       "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+       "\n",
+       "    ws.close = function () {\n",
+       "        comm.close();\n",
+       "    };\n",
+       "    ws.send = function (m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function (msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        var data = msg['content']['data'];\n",
+       "        if (data['blob'] !== undefined) {\n",
+       "            data = {\n",
+       "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+       "            };\n",
+       "        }\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(data);\n",
+       "    });\n",
+       "    return ws;\n",
+       "};\n",
+       "\n",
+       "mpl.mpl_figure_comm = function (comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = document.getElementById(id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm);\n",
+       "\n",
+       "    function ondownload(figure, _format) {\n",
+       "        window.open(figure.canvas.toDataURL());\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element;\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error('Failed to find cell for figure', id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "    fig.cell_info[0].output_area.element.on(\n",
+       "        'cleared',\n",
+       "        { fig: fig },\n",
+       "        fig._remove_fig_handler\n",
+       "    );\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+       "    var width = fig.canvas.width / fig.ratio;\n",
+       "    fig.cell_info[0].output_area.element.off(\n",
+       "        'cleared',\n",
+       "        fig._remove_fig_handler\n",
+       "    );\n",
+       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable();\n",
+       "    fig.parent_element.innerHTML =\n",
+       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "    fig.close_ws(fig, msg);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width / this.ratio;\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] =\n",
+       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function () {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message('ack', {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () {\n",
+       "        fig.push_to_output();\n",
+       "    }, 1000);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function () {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var toolbar = document.createElement('div');\n",
+       "    toolbar.classList = 'btn-toolbar';\n",
+       "    this.root.appendChild(toolbar);\n",
+       "\n",
+       "    function on_click_closure(name) {\n",
+       "        return function (_event) {\n",
+       "            return fig.toolbar_button_onclick(name);\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    function on_mouseover_closure(tooltip) {\n",
+       "        return function (event) {\n",
+       "            if (!event.currentTarget.disabled) {\n",
+       "                return fig.toolbar_button_onmouseover(tooltip);\n",
+       "            }\n",
+       "        };\n",
+       "    }\n",
+       "\n",
+       "    fig.buttons = {};\n",
+       "    var buttonGroup = document.createElement('div');\n",
+       "    buttonGroup.classList = 'btn-group';\n",
+       "    var button;\n",
+       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            /* Instead of a spacer, we start a new button group. */\n",
+       "            if (buttonGroup.hasChildNodes()) {\n",
+       "                toolbar.appendChild(buttonGroup);\n",
+       "            }\n",
+       "            buttonGroup = document.createElement('div');\n",
+       "            buttonGroup.classList = 'btn-group';\n",
+       "            continue;\n",
+       "        }\n",
+       "\n",
+       "        button = fig.buttons[name] = document.createElement('button');\n",
+       "        button.classList = 'btn btn-default';\n",
+       "        button.href = '#';\n",
+       "        button.title = name;\n",
+       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+       "        button.addEventListener('click', on_click_closure(method_name));\n",
+       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+       "        buttonGroup.appendChild(button);\n",
+       "    }\n",
+       "\n",
+       "    if (buttonGroup.hasChildNodes()) {\n",
+       "        toolbar.appendChild(buttonGroup);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = document.createElement('span');\n",
+       "    status_bar.classList = 'mpl-message pull-right';\n",
+       "    toolbar.appendChild(status_bar);\n",
+       "    this.message = status_bar;\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = document.createElement('div');\n",
+       "    buttongrp.classList = 'btn-group inline pull-right';\n",
+       "    button = document.createElement('button');\n",
+       "    button.classList = 'btn btn-mini btn-primary';\n",
+       "    button.href = '#';\n",
+       "    button.title = 'Stop Interaction';\n",
+       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+       "    button.addEventListener('click', function (_evt) {\n",
+       "        fig.handle_close(fig, {});\n",
+       "    });\n",
+       "    button.addEventListener(\n",
+       "        'mouseover',\n",
+       "        on_mouseover_closure('Stop Interaction')\n",
+       "    );\n",
+       "    buttongrp.appendChild(button);\n",
+       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+       "    var fig = event.data.fig;\n",
+       "    if (event.target !== this) {\n",
+       "        // Ignore bubbled events from children.\n",
+       "        return;\n",
+       "    }\n",
+       "    fig.close_ws(fig, {});\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function (el) {\n",
+       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.setAttribute('tabindex', 0);\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    } else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager) {\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "    }\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which === 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        // select the cell after this one\n",
+       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+       "        IPython.notebook.select(index + 1);\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "};\n",
+       "\n",
+       "mpl.find_output_cell = function (html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i = 0; i < ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code') {\n",
+       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] === html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel !== null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target(\n",
+       "        'matplotlib',\n",
+       "        mpl.mpl_figure_comm\n",
+       "    );\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"640\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6a91dc0a25394f96baa3c87020c33991",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(IntSlider(value=35, description='index', max=71), RadioButtons(description='along', opti…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<nanomesh.utils.SliceViewer at 0x1db8b1a69d0>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from nanomesh import Volume\n",
+    "\n",
+    "n = 24\n",
+    "m = 12\n",
+    "\n",
+    "data = np.ones([2*n, 5*n, 3*n], dtype=int)\n",
+    "data[m:3*m, m:3*m, 0:3*n] = 0\n",
+    "\n",
+    "print(data.shape)\n",
+    "\n",
+    "vol = Volume(data)\n",
+    "vol.show_slice()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c335d378",
+   "metadata": {},
+   "source": [
+    "### Generating the contour"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3364b246",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated contour with 14028 cells\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1024x768 at 0x1DBA1C3ED90>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from nanomesh.mesh3d import Mesher3D\n",
+    "\n",
+    "mesher = Mesher3D(vol)\n",
+    "mesher.generate_contour()\n",
+    "mesher.show_contour(jupyter_backend='static', show_edges=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a5d14b0",
+   "metadata": {},
+   "source": [
+    "### Padding different sides\n",
+    "\n",
+    "The mesh can be padded using a similar API as 2d meshes. Each side (top/bottom, left/right, front/back) can be padded. A width must be specified. The label is optional."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "57beef2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1024x768 at 0x1DBA315D220>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "mesher.pad_contour(side='front', width=20, label=2)\n",
+    "mesher.pad_contour(side='left', width=30, label=3)\n",
+    "mesher.pad_contour(side='right', width=40, label=4)\n",
+    "mesher.pad_contour(side='back', width=50, label=5)\n",
+    "mesher.show_contour(jupyter_backend='static', show_edges=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4b7f49f",
+   "metadata": {},
+   "source": [
+    "### Generate tetrahedral mesh\n",
+    "\n",
+    "Finally, generate the tetrahedral mesh."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ca13c7b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1024x768 at 0x1DB8B5E2550>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "tetras = mesher.tetrahedralize(opts='-pAq1.2 -a10000', generate_region_markers=True)\n",
+    "tetras.metadata['labels'] = tetras.metadata['tetgenRef']\n",
+    "tetras.plot_pyvista(jupyter_backend='static', show_edges=True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "nanomesh",
+   "language": "python",
+   "name": "nanomesh"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}


Test patch:
diff --git a/tests/test_mesh3d.py b/tests/test_mesh3d.py
index 1f09c82f..62f9aa71 100644
--- a/tests/test_mesh3d.py
+++ b/tests/test_mesh3d.py
@@ -5,7 +5,7 @@
 import numpy as np
 import pytest
 
-from nanomesh.mesh3d import generate_3d_mesh, get_region_markers
+from nanomesh.mesh3d import BoundingBox, generate_3d_mesh, get_region_markers
 
 TETGEN_NOT_AVAILABLE = shutil.which('tetgen') is None
 
@@ -61,3 +61,38 @@ def test_generate_3d_mesh_region_markers(segmented_image):
     tetra_mesh = generate_3d_mesh(segmented_image,
                                   region_markers=region_markers)
     compare_mesh_results(tetra_mesh, expected_fn)
+
+
+def test_BoundingBox_center():
+    """Test BoundingBox init / center."""
+    bbox = BoundingBox(
+        xmin=0.0,
+        xmax=10.0,
+        ymin=20.0,
+        ymax=30.0,
+        zmin=40.0,
+        zmax=50.0,
+    )
+    np.testing.assert_equal(bbox.center, (5, 25, 45))
+
+
+def test_BoundingBox_from_shape():
+    """Test BoundingBox .from_shape / .dimensions."""
+    shape = np.array((10, 20, 30))
+    bbox = BoundingBox.from_shape(shape)
+    np.testing.assert_equal(bbox.dimensions, shape - 1)
+
+
+def test_BoundingBox_from_points():
+    """Test BoundingBox .from_points / to_points."""
+    points = np.array([
+        (10, 20, 30),
+        (5, 5, 0),
+        (0, 0, 5),
+    ])
+    bbox = BoundingBox.from_points(points)
+    corners = bbox.to_points()
+    expected = ([0, 0, 0], [0, 0, 30], [0, 20, 0], [0, 20, 30], [10, 0, 0],
+                [10, 0, 30], [10, 20, 0], [10, 20, 30])
+
+    np.testing.assert_equal(corners, expected)
diff --git a/tests/test_mesh_utils_3d.py b/tests/test_mesh_utils_3d.py
new file mode 100644
index 00000000..3178e3b9
--- /dev/null
+++ b/tests/test_mesh_utils_3d.py
@@ -0,0 +1,64 @@
+import numpy as np
+import pytest
+
+from nanomesh.mesh3d import BoundingBox
+from nanomesh.mesh_container import TriangleMesh
+from nanomesh.mesh_utils_3d import pad3d
+
+
+@pytest.fixture
+def mesh():
+    """Box triangle mesh."""
+    points = np.array([[0., 0., 0.], [10., 0., 0.], [0., 20., 0.],
+                       [10., 20., 0.], [0., 0., 30.], [10., 0., 30.],
+                       [0., 20., 30.], [10., 20., 30.]])
+    cells = np.array([[0, 4, 6], [0, 6, 2], [5, 1, 3], [5, 3, 7], [0, 1, 5],
+                      [0, 5, 4], [6, 7, 3], [6, 3, 2], [1, 0, 2], [1, 2, 3],
+                      [4, 5, 7], [4, 7, 6]])
+
+    return TriangleMesh(points=points, cells=cells)
+
+
+@pytest.mark.parametrize('side,width, expected_bbox', (
+    ('top', 5,
+     BoundingBox(xmin=0.0, xmax=10.0, ymin=0.0, ymax=20.0, zmin=0.0,
+                 zmax=35.0)),
+    ('bottom', 5,
+     BoundingBox(
+         xmin=0.0, xmax=10.0, ymin=0.0, ymax=20.0, zmin=-5.0, zmax=30.0)),
+    ('left', 10,
+     BoundingBox(
+         xmin=0.0, xmax=10.0, ymin=-10.0, ymax=20.0, zmin=0.0, zmax=30.0)),
+    ('right', np.pi,
+     BoundingBox(
+         xmin=0.0, xmax=10.0, ymin=0.0, ymax=20 + np.pi, zmin=0.0, zmax=30.0)),
+    ('front', 0.1,
+     BoundingBox(
+         xmin=-0.1, xmax=10.0, ymin=0.0, ymax=20.0, zmin=0.0, zmax=30.0)),
+    ('back', 123,
+     BoundingBox(
+         xmin=0.0, xmax=133.0, ymin=0.0, ymax=20.0, zmin=0.0, zmax=30.0)),
+))
+def test_pad3d(mesh, side, width, expected_bbox):
+    """Test pad3d function."""
+    out = pad3d(mesh, side=side, width=width)
+
+    assert len(out.points) == len(mesh.points) + 4
+    assert len(out.cells) == len(mesh.cells) + 10
+
+    bbox = BoundingBox.from_points(out.points)
+
+    assert bbox == expected_bbox
+
+
+def test_pad3d_no_width(mesh):
+    """Test early return when width==0."""
+    out = pad3d(mesh, side='top', width=0)
+
+    assert out is mesh
+
+
+def test_pad3d_invalid_side(mesh):
+    """Test invalide keyword argument."""
+    with pytest.raises(ValueError):
+        _ = pad3d(mesh, side='FAIL', width=123)
diff --git a/tests/test_utils.py b/tests/test_utils.py
index f448cc31..c8d3f7c1 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -121,3 +121,11 @@ def test_pad_label(simple_mesh, label, expected_labels):
     assert isinstance(res, TriangleMesh)
 
     np.testing.assert_equal(res.labels, expected_labels)
+
+
+def test_pairwise():
+    """Test pairwise function."""
+    from nanomesh.utils import pairwise
+    inp = range(3)
+    out = pairwise(inp)
+    assert list(out) == [(0, 1), (1, 2)]