Repository: pyxem/kikuchipy (language: python)

Issue:
Average dot product, neighbour dot product matrices, map helper, rework averaging
#### Description of the change

- Average dot product (ADP) map
- Neighbour dot product matrices
- _map_helper: convenient function to create various maps used for both of the above
- Started internal rework of average neighbours

#### Progress of the PR

- [x] [Docstrings for all functions](https://github.com/numpy/numpy/blob/master/doc/example.py)
- [x] Unit tests with pytest for all lines
- [x] Clean code style by [running black via pre-commit](https://kikuchipy.org/en/latest/contributing.html#code-style)

#### Minimal example of the bug fix or new feature

```python
>>> import kikuchipy as kp
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> s = kp.signals.EBSD(np.zeros((10, 10, 10, 10)))
>>> adp = s.get_average_dot_product()
>>> plt.imshow(adp, cmap="inferno")
>>> plt.colorbar(label="ADP")
...
>>> window = kp.filters.Window(window="rectangular", shape=(5, 5))
>>> dp_matrices = s.get_neighbour_dot_product_matrices(window=window)
```

#### For reviewers

<!-- Don't remove the checklist below. -->
- [x] Check that the PR title is short, concise, and will make sense 1 year
  later.
- [x] Check that new functions are imported in corresponding `__init__.py`.
- [x] Check that new features, API changes, and deprecations are mentioned in
      the unreleased section in `doc/changelog.rst`.

IndexError in average_neighbour_patterns() for LazyEBSD
Got this callstack when processing a ~12 GB dataset, which looks like either the pattern chunk array or window sums array is indexed wrongly. Haven't experienced this with other data sets. The dataset `<LazyEBSD, title: Pattern, dimensions: (911, 897|120, 120)>`.

```python
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-7-161ef27179ac> in <module>
      1 #s.save(os.path.join(kpdir, "Pattern_sda.dat"), overwrite=True)
----> 2 s.save(os.path.join(kpdir, "Pattern_sda.h5"))

~/kode/kikuchipy/kikuchipy/signals/ebsd.py in save(self, filename, overwrite, extension, **kwargs)
   1348             basename, _ = os.path.splitext(filename)
   1349             filename = basename + "." + extension
-> 1350         _save(filename, self, overwrite=overwrite, **kwargs)
   1351 
   1352     def get_decomposition_model(

~/kode/kikuchipy/kikuchipy/io/_io.py in _save(filename, signal, overwrite, add_scan, **kwargs)
    384         # Finally, write file
    385         if write:
--> 386             writer.file_writer(filename, signal, **kwargs)
    387             directory, filename = os.path.split(os.path.abspath(filename))
    388             signal.tmp_parameters.set_item("folder", directory)

~/kode/kikuchipy/kikuchipy/io/plugins/h5ebsd.py in file_writer(filename, signal, add_scan, scan_number, **kwargs)
    848     man_pats = manufacturer_pattern_names()
    849     dset_pattern_name = man_pats["kikuchipy"]
--> 850     overwrite_dataset(
    851         scan_group.create_group("EBSD/Data"),
    852         signal.data.reshape(nx * ny, sy, sx),

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/hyperspy/io_plugins/hspy.py in overwrite_dataset(group, data, key, signal_axes, chunks, **kwds)
    581         _logger.info("Chunks used for saving: %s" % str(dset.chunks))
    582         if isinstance(data, da.Array):
--> 583             da.store(data.rechunk(dset.chunks), dset)
    584         elif data.flags.c_contiguous:
    585             dset.write_direct(data)

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/array/core.py in store(sources, targets, lock, regions, compute, return_stored, **kwargs)
    966 
    967         if compute:
--> 968             result.compute(**kwargs)
    969             return None
    970         else:

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/base.py in compute(self, **kwargs)
    165         dask.base.compute
    166         """
--> 167         (result,) = compute(self, traverse=False, **kwargs)
    168         return result
    169 

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/base.py in compute(*args, **kwargs)
    450         postcomputes.append(x.__dask_postcompute__())
    451 
--> 452     results = schedule(dsk, keys, **kwargs)
    453     return repack([f(r, *a) for r, (f, a) in zip(results, postcomputes)])
    454 

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/threaded.py in get(dsk, result, cache, num_workers, pool, **kwargs)
     74                 pools[thread][num_workers] = pool
     75 
---> 76     results = get_async(
     77         pool.apply_async,
     78         len(pool._pool),

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/local.py in get_async(apply_async, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, **kwargs)
    484                         _execute_task(task, data)  # Re-execute locally
    485                     else:
--> 486                         raise_exception(exc, tb)
    487                 res, worker_id = loads(res_info)
    488                 state["cache"][key] = res

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/local.py in reraise(exc, tb)
    314     if exc.__traceback__ is not tb:
    315         raise exc.with_traceback(tb)
--> 316     raise exc
    317 
    318 

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/local.py in execute_task(key, task_info, dumps, loads, get_id, pack_exception)
    220     try:
    221         task, data = loads(task_info)
--> 222         result = _execute_task(task, data)
    223         id = get_id()
    224         result = dumps((result, id))

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/core.py in _execute_task(arg, cache, dsk)
    119         # temporaries by their reference count and can execute certain
    120         # operations in-place.
--> 121         return func(*(_execute_task(a, cache) for a in args))
    122     elif not ishashable(arg):
    123         return arg

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/optimization.py in __call__(self, *args)
    960         if not len(args) == len(self.inkeys):
    961             raise ValueError("Expected %d args, got %d" % (len(self.inkeys), len(args)))
--> 962         return core.get(self.dsk, self.outkey, dict(zip(self.inkeys, args)))
    963 
    964     def __reduce__(self):

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/core.py in get(dsk, out, cache)
    149     for key in toposort(dsk):
    150         task = dsk[key]
--> 151         result = _execute_task(task, cache)
    152         cache[key] = result
    153     result = _execute_task(out, cache)

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/core.py in _execute_task(arg, cache, dsk)
    119         # temporaries by their reference count and can execute certain
    120         # operations in-place.
--> 121         return func(*(_execute_task(a, cache) for a in args))
    122     elif not ishashable(arg):
    123         return arg

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/core.py in <genexpr>(.0)
    119         # temporaries by their reference count and can execute certain
    120         # operations in-place.
--> 121         return func(*(_execute_task(a, cache) for a in args))
    122     elif not ishashable(arg):
    123         return arg

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/core.py in _execute_task(arg, cache, dsk)
    119         # temporaries by their reference count and can execute certain
    120         # operations in-place.
--> 121         return func(*(_execute_task(a, cache) for a in args))
    122     elif not ishashable(arg):
    123         return arg

~/miniconda3/envs/kp-dev/lib/python3.8/site-packages/dask/utils.py in apply(func, args, kwargs)
     27 def apply(func, args, kwargs=None):
     28     if kwargs:
---> 29         return func(*args, **kwargs)
     30     else:
     31         return func(*args)

~/kode/kikuchipy/kikuchipy/pattern/chunk.py in average_neighbour_patterns(patterns, window_sums, window, dtype_out)
    543     for nav_idx in np.ndindex(patterns.shape[:-2]):
    544         averaged_patterns[nav_idx] = (
--> 545             correlated_patterns[nav_idx] / window_sums[nav_idx]
    546         )
    547 

IndexError: index 48 is out of bounds for axis 1 with size 48
```


Discussion / hints:

Fix patch:
diff --git a/README.rst b/README.rst
index 7679ef95..eae568a8 100644
--- a/README.rst
+++ b/README.rst
@@ -37,7 +37,7 @@ kikuchipy is an open-source Python library for processing and analysis of
 electron backscatter diffraction (EBSD) patterns. The library builds on the
 tools for multi-dimensional data analysis provided by the HyperSpy library.
 
-- **User guide and documentation**: https://kikuchipy.org. The guide consists of
+- **User guide and API reference**: https://kikuchipy.org. The guide consists of
   Jupyter Notebooks with many links to detailed explanations of the input
   parameters and output of functions and class methods (the API reference).
   The notebooks can be inspected statically on the web page or via `nbviewer`,
@@ -49,6 +49,7 @@ tools for multi-dimensional data analysis provided by the HyperSpy library.
 - **Contribute**: Do you have a question or want to contribute? Great! Our
   `contributing guide <https://kikuchipy.org/en/latest/contributing.html>`_
   explains how to best do that.
-
-The library is in an alpha stage, so there will be breaking changes with each
-release.
+- The library is in an alpha stage, so there will be breaking changes with each
+  release. Please see
+  `the changelog <https://kikuchipy.org/en/latest/changelog.rst>`_ for all
+  developments.
diff --git a/doc/bibliography.bib b/doc/bibliography.bib
index ed767641..0fd78e33 100644
--- a/doc/bibliography.bib
+++ b/doc/bibliography.bib
@@ -185,3 +185,12 @@ @inproceedings{aanes2020processing
 	volume = {891},
 	year = {2020}
 }
+@article{brewick2019nlpar,
+	author = {Brewick, Patrick T and Wright, Stuart and Rowenhorst, David J},
+	doi = {10.1016/j.ultramic.2019.02.013},
+	journal = {Ultramicroscopy},
+	pages = {50–61},
+	title = {{NLPAR: Non-local smoothing for enhanced EBSD pattern indexing}},
+	volume = {200},
+	year = {2019}
+}
diff --git a/doc/changelog.rst b/doc/changelog.rst
index 2f010079..ce8944d7 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -23,6 +23,8 @@ Contributors
 
 Added
 -----
+- Calculation of an average dot product map, or just the dot product matrices.
+  (`#280 <https://github.com/pyxem/kikuchipy/pull/280>`_)
 - A nice gallery to the documentation with links to each user guide page.
   (`#285 <https://github.com/pyxem/kikuchipy/pull/285>`_)
 - Support for writing/reading an EBSD signal with 1 or 0 navigation axes to/from
@@ -74,6 +76,12 @@ Added
 
 Changed
 -------
+- The feature maps notebook to include how to obtain an average dot product map
+  and dot product matrices for an EBSD signal.
+  (`#280 <https://github.com/pyxem/kikuchipy/pull/280>`_)
+- Averaging EBSD patterns with nearest neighbours now rescales to input data
+  type range, thus loosing relative intensities, to avoid clipping intensities.
+  (`#280 <https://github.com/pyxem/kikuchipy/pull/280>`_)
 - Dependency requirement of diffsims from >= 0.3 to >= 0.4
   (`#282 <https://github.com/pyxem/kikuchipy/pull/282>`_)
 - Name of hemisphere axis in EBSDMasterPattern from "y" to "hemisphere".
@@ -111,6 +119,8 @@ Removed
 
 Fixed
 -----
+- IndexError in neighbour pattern averaging
+  (`#280 <https://github.com/pyxem/kikuchipy/pull/280>`_)
 - Square Lambert projection handles edge case vectors better
   (`#272 <https://github.com/pyxem/kikuchipy/pull/272>`_)
 - Reading of square Lambert projections from EMsoft's master pattern file now
diff --git a/doc/feature_maps.ipynb b/doc/feature_maps.ipynb
index bca0dc7f..dae1c4b6 100644
--- a/doc/feature_maps.ipynb
+++ b/doc/feature_maps.ipynb
@@ -31,6 +31,7 @@
     "# exchange inline for qt5 for interactive plotting from the pyqt package\n",
     "%matplotlib inline\n",
     "\n",
+    "import hyperspy.api as hs\n",
     "import matplotlib.pyplot as plt\n",
     "plt.rcParams[\"font.size\"] = 15\n",
     "import numpy as np\n",
@@ -147,6 +148,50 @@
     "iq = s.get_image_quality(normalize=True)  # Default"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.imshow(iq, cmap=\"gray\")\n",
+    "plt.colorbar(label=r\"Image quality, $Q$\", pad=0.01)\n",
+    "_ = plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we want to use this map to navigate around in when plotting patterns, we can\n",
+    "easily do that as explained in the\n",
+    "[visualizing patterns](visualizing_patterns.rst) guide."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Average dot product\n",
+    "\n",
+    "The average dot product, or normalized cross-correlation when centering each\n",
+    "pattern's intensity about zero and normalizing the intensities to a standard\n",
+    "deviation $\\sigma$ of 1 (which is the default behaviour), between each pattern\n",
+    "and their four nearest neighbours, can be obtained for an\n",
+    "[EBSD](reference.rst#kikuchipy.signals.EBSD) signal with\n",
+    "[get_average_neighbour_dot_product_map()](reference.rst#kikuchipy.signals.EBSD.get_average_neighbour_dot_product_map)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adp = s.get_average_neighbour_dot_product_map()"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -161,8 +206,8 @@
    "outputs": [],
    "source": [
     "plt.figure(figsize=(10, 6))\n",
-    "plt.imshow(iq, cmap=\"gray\")\n",
-    "plt.colorbar(label=r\"Image quality, $Q$\", pad=0.01)\n",
+    "plt.imshow(adp, cmap=\"gray\")\n",
+    "plt.colorbar(label=\"Average dot product\", pad=0.01)\n",
     "_ = plt.axis(\"off\")"
    ]
   },
@@ -170,9 +215,179 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we want to use this map to navigate around in when plotting patterns, we can\n",
-    "easily do that as explained in the\n",
-    "[visualizing patterns](visualizing_patterns.rst) guide."
+    "The map displays how similar each pattern is to its neighbours. Grain\n",
+    "boundaries, and some scratches on the sample, can be clearly seen as pixels with\n",
+    "a lower value, signifying that they are more dissimilar to their neighbouring\n",
+    "pixels, as the ones within grains where the neighbour pixel similarity is high.\n",
+    "\n",
+    "The map above was created by averaging the dot product matrix per map point,\n",
+    "created by calculating the dot product between each pattern and their four\n",
+    "nearest neighbours, which can be seen in the black spots (uneven sample surface)\n",
+    "in the left grains"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w1 = kp.filters.Window()\n",
+    "_ = w1.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We could instead average with e.g. the eight nearest neighbours"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w2 = kp.filters.Window(window=\"rectangular\", shape=(3, 3))\n",
+    "_ = w2.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adp2 = s.get_average_neighbour_dot_product_map(window=w2)\n",
+    "\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.imshow(adp2, cmap=\"gray\")\n",
+    "plt.colorbar(label=\"Average dot product\", pad=0.01)\n",
+    "_ = plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that the window coefficients must be integers.\n",
+    "\n",
+    "We can also control whether pattern intensities should be centered about zero\n",
+    "and/or whether they should be normalized prior to calculating the dot products\n",
+    "by passing `zero_mean=False` and/or `normalize=False`. These are `True` by\n",
+    "default. The data type of the output map, 32-bit floating point by default,\n",
+    "can be set by passing e.g. `dtype_out=np.float64`.\n",
+    "\n",
+    "We can obtain the dot product matrices per map point, that is the matrices\n",
+    "before they are averaged, with\n",
+    "[get_neighbour_dot_product_matrices()](reference.rst#kikuchipy.signals.EBSD.get_neighbour_dot_product_matrices).\n",
+    "Let's see similar a pattern on a grain boundary in map point (x, y) = (50, 19)\n",
+    "is to all its nearest neighbour in a (5, 5) window centered on that point"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w3 = kp.filters.Window(\"rectangular\", shape=(5, 5))\n",
+    "dp_matrices = s.get_neighbour_dot_product_matrices(window=w3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x, y = (50, 19)\n",
+    "s_dp_matrices = hs.signals.Signal2D(dp_matrices)\n",
+    "s_dp_matrices.inav[x, y].plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see that the pattern is more similar to the patterns up to the right,\n",
+    "while it is quite dissimilar to the patterns to the lower left. Let's visualize\n",
+    "this more clearly, as is done e.g. in Fig. 1 by\n",
+    "<cite data-cite=\"brewick2019nlpar\">Brewick et al. (2019)</cite>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_n, x_n = w3.n_neighbours\n",
+    "\n",
+    "s2 = s.inav[x - x_n:x + x_n + 1, y - y_n:y + y_n + 1].deepcopy()\n",
+    "s2.rescale_intensity(percentiles=(0.5, 99.5))  # Stretch the contrast a bit\n",
+    "s3 = s2 * s_dp_matrices.inav[x, y].T  # Signals must have same navigation shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_ = hs.plot.plot_images(\n",
+    "    images=s3,\n",
+    "    per_row=5,\n",
+    "    label=None,\n",
+    "    suptitle=None,\n",
+    "    axes_decor=None,\n",
+    "    colorbar=None,\n",
+    "    vmin=int(s3.data.min()),\n",
+    "    vmax=int(s3.data.max()),\n",
+    "    padding=dict(wspace=0, hspace=-0.05),\n",
+    "    fig=plt.figure(figsize=(10, 10))\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we can pass this dot product matrix directly to\n",
+    "[get_average_neighbour_dot_product_map()](reference.rst#kikuchipy.signals.EBSD.get_average_neighbour_dot_product_map)\n",
+    "via the `dp_matrices` parameter to obtain the average dot product map from these\n",
+    "matrices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adp3 = s.get_average_neighbour_dot_product_map(dp_matrices=dp_matrices)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's plot this and highlight the location of the pattern on the grain boundary\n",
+    "above with a red circle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.imshow(adp3, cmap=\"gray\")\n",
+    "plt.colorbar(label=\"Average dot product\", pad=0.01)\n",
+    "plt.scatter(x=x, y=y, marker=\"o\", c=\"r\", s=50)\n",
+    "_ = plt.axis(\"off\")"
    ]
   }
  ],
diff --git a/doc/pattern_matching.ipynb b/doc/pattern_matching.ipynb
index cacb74bb..3ec77b88 100644
--- a/doc/pattern_matching.ipynb
+++ b/doc/pattern_matching.ipynb
@@ -54,9 +54,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<EBSD, title: patterns Scan 1, dimensions: (75, 55|60, 60)>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# exchange inline for qt5 for interactive plotting from the pyqt package\n",
     "%matplotlib inline\n",
@@ -70,7 +81,7 @@
     "import kikuchipy as kp\n",
     "\n",
     "\n",
-    "s = kp.data.nickel_ebsd_small()  # Use kp.load(\"data.h5\") to load your own data\n",
+    "s = kp.data.nickel_ebsd_large()  # Use kp.load(\"data.h5\") to load your own data\n",
     "s"
    ]
   },
@@ -87,9 +98,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Removing the static background:\n",
+      "[########################################] | 100% Completed |  1.0s\n",
+      "Removing the dynamic background:\n",
+      "[########################################] | 100% Completed |  2.5s\n"
+     ]
+    }
+   ],
    "source": [
     "s.remove_static_background()\n",
     "s.remove_dynamic_background()"
@@ -106,9 +128,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<EBSDMasterPattern, title: ni_mc_mp_20kv_uint8_gzip_opts9, dimensions: (|401, 401)>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "mp = kp.data.nickel_ebsd_master_pattern_small(projection=\"lambert\", energy=20)\n",
     "mp"
@@ -116,9 +149,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x375.652 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "mp.plot()"
    ]
@@ -134,9 +180,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<name: ni. space group: Fm-3m. point group: m-3m. proper point group: 432. color: tab:blue>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "ni = mp.phase\n",
     "ni"
@@ -144,18 +201,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[28   0.000000 0.000000 0.000000 1.0000]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "ni.structure  # Element, x, y, z, site occupation"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Lattice(a=0.35236, b=0.35236, c=0.35236, alpha=90, beta=90, gamma=90)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "ni.structure.lattice  # nm and degrees"
    ]
@@ -176,12 +255,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Rotation (7467,)\n",
+       "[[ 1.     -0.     -0.     -0.    ]\n",
+       " [ 0.986  -0.1667 -0.     -0.    ]\n",
+       " [ 0.9718 -0.2357 -0.     -0.    ]\n",
+       " ...\n",
+       " [ 0.9538 -0.2887 -0.      0.0834]\n",
+       " [ 0.9392 -0.3333 -0.      0.0822]\n",
+       " [ 0.9244 -0.3727 -0.      0.0809]]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "r = sampling.get_sample_fundamental(\n",
-    "    resolution=5, space_group=ni.space_group.number\n",
+    "    resolution=4, space_group=ni.space_group.number\n",
     ")\n",
     "r"
    ]
@@ -216,9 +313,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "EBSDDetector (60, 60), px_size 1 um, binning 1, tilt 0, pc (0.421, 0.221, 0.505)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "detector = kp.detectors.EBSDDetector(\n",
     "    shape=s.axes_manager.signal_shape[::-1],\n",
@@ -240,9 +348,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "detector.plot(coordinates=\"gnomonic\", pattern=s.inav[0, 0].data)"
    ]
@@ -261,9 +382,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Creating a dictionary of (7467,) simulated patterns:\n",
+      "[########################################] | 100% Completed | 16.4s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<EBSD, title: , dimensions: (7467|60, 60)>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "sim = mp.get_patterns(\n",
     "    rotations=r,\n",
@@ -284,9 +424,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1296x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "#sim.plot()  # Plot the patterns with a navigator for easy inspection\n",
     "fig, ax = plt.subplots(ncols=3, figsize=(18, 6))\n",
@@ -321,9 +474,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Matching ni patterns: 100%|██████████| 10/10 [00:08<00:00,  1.12slice/s, mem=48.7%]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Phase  Orientations  Name  Space group  Point group  Proper point group     Color\n",
+       "    0  4125 (100.0%)    ni        Fm-3m         m-3m                 432  tab:blue\n",
+       "Properties: scores, simulation_indices\n",
+       "Scan unit: um"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "xmap = s.match_patterns(sim, n_slices=10, keep_n=10)\n",
     "xmap"
@@ -338,9 +512,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/hakon/miniconda3/envs/kp-dev/lib/python3.8/site-packages/orix/quaternion/rotation.py:309: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  np.divide(b * d - a * c, chi), np.divide(-a * b - c * d, chi)\n",
+      "/home/hakon/miniconda3/envs/kp-dev/lib/python3.8/site-packages/orix/quaternion/rotation.py:313: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  np.divide(a * c + b * d, chi), np.divide(c * d - a * b, chi)\n"
+     ]
+    }
+   ],
    "source": [
     "temp_dir = tempfile.mkdtemp()\n",
     "xmap_file = temp_dir + \"ni.h5\"\n",
@@ -357,9 +542,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "fig, ax = plt.subplots(subplot_kw=dict(projection=\"plot_map\"))\n",
     "ax.plot_map(xmap, xmap.scores[:, 0], scalebar=False)\n",
@@ -377,9 +575,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<EBSD, title: , dimensions: (75, 55|60, 60)>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "best_patterns = sim.data[xmap.simulation_indices[:, 0]].reshape(s.data.shape)\n",
     "s_best = kp.signals.EBSD(best_patterns)\n",
@@ -400,9 +609,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x275.478 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x375.652 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x375.652 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "ncc_navigator = hs.signals.Signal2D(xmap.get_map_data(xmap.scores[:, 0]))\n",
     "hs.plot.plot_signals([s, s_best], navigator=hs.signals.Signal2D(ncc_navigator))"
@@ -417,7 +663,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {
     "nbsphinx-thumbnail": {
      "tooltip": "Crystal orientation determination by comparing experimental EBSD patterns to a dictionary of simulated patterns obtained from a master pattern"
@@ -426,7 +672,20 @@
      "nbsphinx-thumbnail"
     ]
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "fig, ax = plt.subplots(ncols=2, nrows=2, figsize=(10, 10))\n",
     "ax[0, 0].imshow(s.inav[0, 0].data, cmap=\"gray\")\n",
@@ -442,7 +701,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {
     "nbsphinx": "hidden"
    },
diff --git a/doc/reference.rst b/doc/reference.rst
index 93a13f9d..bced7ce4 100644
--- a/doc/reference.rst
+++ b/doc/reference.rst
@@ -464,9 +464,11 @@ All methods listed here are also available to
     average_neighbour_patterns
     match_patterns
     fft_filter
+    get_average_neighbour_dot_product_map
     get_decomposition_model
     get_dynamic_background
     get_image_quality
+    get_neighbour_dot_product_matrices
     get_virtual_bse_intensity
     match_patterns
     normalize_intensity
diff --git a/kikuchipy/filters/window.py b/kikuchipy/filters/window.py
index 830e95ec..0f5ca88d 100644
--- a/kikuchipy/filters/window.py
+++ b/kikuchipy/filters/window.py
@@ -227,6 +227,13 @@ def distance_to_origin(self) -> np.ndarray:
         """Radial distance to the window origin."""
         return distance_to_origin(self.shape, self.origin)
 
+    @property
+    def n_neighbours(self) -> tuple:
+        """Maximum number of nearest neighbours in each navigation axis
+        to the origin.
+        """
+        return tuple(np.subtract(self.shape, self.origin) - 1)
+
     def make_circular(self):
         """Make window circular.
 
diff --git a/kikuchipy/indexing/similarity_metrics.py b/kikuchipy/indexing/similarity_metrics.py
index 9573803f..a4b2121a 100644
--- a/kikuchipy/indexing/similarity_metrics.py
+++ b/kikuchipy/indexing/similarity_metrics.py
@@ -24,6 +24,8 @@
 import dask.array as da
 import numpy as np
 
+from kikuchipy.pattern._pattern import _normalize, _zero_mean
+
 
 class MetricScope(Enum):
     """Describes the input parameters for a similarity metric. See
@@ -204,9 +206,9 @@ def __call__(
         experimental = experimental.astype(dtype)
         simulated = simulated.astype(dtype)
         if isinstance(experimental, da.Array):
-            experimental = experimental.rechunk()
+            experimental = _rechunk(experimental)
         if isinstance(simulated, da.Array):
-            simulated = simulated.rechunk()
+            simulated = _rechunk(simulated)
         if self._make_compatible_to_lower_scopes:
             experimental, simulated = self._expand_dims_to_match_scope(
                 experimental, simulated
@@ -307,6 +309,15 @@ def _measure(
         return self._metric_func(experimental, simulated)
 
 
+def _rechunk(dask_array: da.Array):
+    ndim_to_chunks = {
+        2: {0: -1, 1: -1},
+        3: {0: "auto", 1: -1, 2: -1},
+        4: {0: "auto", 1: "auto", 2: -1, 3: -1},
+    }
+    return dask_array.rechunk(ndim_to_chunks[dask_array.ndim])
+
+
 def _get_nav_shape(expt):
     return {2: (), 3: (expt.shape[0],), 4: (expt.shape[:2])}[expt.ndim]
 
@@ -354,7 +365,7 @@ def _expand_dims_to_many_to_many(
     return expt, sim
 
 
-def _zero_mean(
+def _zero_mean_expt_sim(
     expt: Union[np.ndarray, da.Array],
     sim: Union[np.ndarray, da.Array],
     flat: bool = False,
@@ -369,7 +380,7 @@ def _zero_mean(
     sim : np.ndarray or da.Array
         Simulated.
     flat : bool, optional
-        Whether `p` and `t` are flattened, by default False.
+        Whether `expt` and `sim` are flattened, by default False.
 
     Returns
     -------
@@ -378,21 +389,17 @@ def _zero_mean(
     sim
         Simulated data with mean subtracted.
     """
-    squeeze = 1 not in expt.shape + sim.shape
-    expt, sim = _expand_dims_to_many_to_many(expt, sim, flat)
-    # Always take the mean along the last two axes (signal axes)
-    expt_mean_axis = 1 if flat else (-2, -1)
-    sim_mean_axis = 1 if flat else (-2, -1)
-    expt -= expt.mean(axis=expt_mean_axis, keepdims=True)
-    sim -= sim.mean(axis=sim_mean_axis, keepdims=True)
-
-    if squeeze:
-        return expt.squeeze(), sim.squeeze()
-    else:
-        return expt, sim
+    expt_expanded, sim_expanded = _expand_dims_to_many_to_many(expt, sim, flat)
+    mean_axis = 1 if flat else (-2, -1)
+    expt_mean_sub = _zero_mean(patterns=expt_expanded, axis=mean_axis)
+    sim_mean_sub = _zero_mean(patterns=sim_expanded, axis=mean_axis)
+    if 1 not in expt.shape + sim.shape:
+        expt_mean_sub = expt_mean_sub.squeeze()
+        sim_mean_sub = sim_mean_sub.squeeze()
+    return expt_mean_sub, sim_mean_sub
 
 
-def _normalize(
+def _normalize_expt_sim(
     expt: Union[np.ndarray, da.Array],
     sim: Union[np.ndarray, da.Array],
     flat: bool = False,
@@ -415,26 +422,22 @@ def _normalize(
     sim : numpy.ndarray or dask.array.Array
         Simulated patterns divided by their L2 norms.
     """
-    squeeze = 1 not in expt.shape + sim.shape
-    expt, sim = _expand_dims_to_many_to_many(expt, sim, flat)
-    # Always take the sum along the last two axes (signal axes)
-    expt_sum_axis = 1 if flat else (-2, -1)
-    sim_sum_axis = 1 if flat else (-2, -1)
-    expt /= (expt ** 2).sum(axis=expt_sum_axis, keepdims=True) ** 0.5
-    sim /= (sim ** 2).sum(axis=sim_sum_axis, keepdims=True) ** 0.5
-
-    if squeeze:
-        return expt.squeeze(), sim.squeeze()
-    else:
-        return expt, sim
+    expt_expanded, sim_expanded = _expand_dims_to_many_to_many(expt, sim, flat)
+    sum_axis = 1 if flat else (-2, -1)
+    expt_normalized = _normalize(patterns=expt_expanded, axis=sum_axis)
+    sim_normalized = _normalize(patterns=sim_expanded, axis=sum_axis)
+    if 1 not in expt.shape + sim.shape:
+        expt_normalized = expt_normalized.squeeze()
+        sim_normalized = sim_normalized.squeeze()
+    return expt_normalized, sim_normalized
 
 
 def _zncc_einsum(
     experimental: Union[da.Array, np.ndarray],
     simulated: Union[da.Array, np.ndarray],
 ) -> Union[np.ndarray, da.Array]:
-    experimental, simulated = _zero_mean(experimental, simulated)
-    experimental, simulated = _normalize(experimental, simulated)
+    experimental, simulated = _zero_mean_expt_sim(experimental, simulated)
+    experimental, simulated = _normalize_expt_sim(experimental, simulated)
     r = da.einsum("ijkl,mkl->ijm", experimental, simulated, optimize=True)
     if isinstance(experimental, np.ndarray) and isinstance(
         simulated, np.ndarray
@@ -448,7 +451,7 @@ def _ndp_einsum(
     experimental: Union[da.Array, np.ndarray],
     simulated: Union[da.Array, np.ndarray],
 ) -> Union[np.ndarray, da.Array]:
-    experimental, simulated = _normalize(experimental, simulated)
+    experimental, simulated = _normalize_expt_sim(experimental, simulated)
     rho = da.einsum("ijkl,mkl->ijm", experimental, simulated, optimize=True)
     if isinstance(experimental, np.ndarray) and isinstance(
         simulated, np.ndarray
diff --git a/kikuchipy/pattern/_pattern.py b/kikuchipy/pattern/_pattern.py
index 49af020b..64d8bfeb 100644
--- a/kikuchipy/pattern/_pattern.py
+++ b/kikuchipy/pattern/_pattern.py
@@ -580,3 +580,15 @@ def fft_frequency_vectors(shape: Tuple[int, int]) -> np.ndarray:
         frequency_vectors[i] = liney[i] ** 2 + linex ** 2 - 1
 
     return frequency_vectors
+
+
+def _zero_mean(patterns: np.ndarray, axis: Tuple[int, tuple]) -> np.ndarray:
+    patterns_mean = patterns.mean(axis=axis, keepdims=True)
+    return patterns - patterns_mean
+
+
+def _normalize(patterns: np.ndarray, axis: Tuple[int, tuple]) -> np.ndarray:
+    patterns_squared = patterns ** 2
+    patterns_norm = patterns_squared.sum(axis=axis, keepdims=True)
+    patterns_norm_squared = patterns_norm ** 0.5
+    return patterns / patterns_norm_squared
diff --git a/kikuchipy/pattern/chunk.py b/kikuchipy/pattern/chunk.py
index 53cebf2c..756ae5c3 100644
--- a/kikuchipy/pattern/chunk.py
+++ b/kikuchipy/pattern/chunk.py
@@ -507,12 +507,15 @@ def average_neighbour_patterns(
     patterns: np.ndarray,
     window_sums: np.ndarray,
     window: Union[np.ndarray, Window],
-    dtype_out: Union[
-        None, np.dtype, Tuple[int, int], Tuple[float, float]
-    ] = None,
+    dtype_out: Optional[np.dtype] = None,
 ) -> np.ndarray:
     """Average a chunk of patterns with its neighbours within a window.
 
+    The amount of averaging is specified by the window coefficients.
+    All patterns are averaged with the same window. Map borders are
+    extended with zeros. Resulting pattern intensities are rescaled
+    to fill the input patterns' data type range individually.
+
     Parameters
     ----------
     patterns
@@ -541,8 +544,9 @@ def average_neighbour_patterns(
     # Divide convolved patterns by number of neighbours averaged with
     averaged_patterns = np.empty_like(correlated_patterns, dtype=dtype_out)
     for nav_idx in np.ndindex(patterns.shape[:-2]):
-        averaged_patterns[nav_idx] = (
-            correlated_patterns[nav_idx] / window_sums[nav_idx]
+        averaged_patterns[nav_idx] = pattern_processing.rescale_intensity(
+            pattern=correlated_patterns[nav_idx] / window_sums[nav_idx],
+            dtype_out=dtype_out,
         )
 
     return averaged_patterns
diff --git a/kikuchipy/signals/ebsd.py b/kikuchipy/signals/ebsd.py
index 6940447a..249aceef 100644
--- a/kikuchipy/signals/ebsd.py
+++ b/kikuchipy/signals/ebsd.py
@@ -61,9 +61,15 @@
 )
 from kikuchipy.signals.util._dask import (
     get_dask_array,
+    get_chunking,
+    _get_chunk_overlap_depth,
     _rechunk_learning_results,
     _update_learning_results,
 )
+from kikuchipy.signals.util._map_helper import (
+    _get_neighbour_dot_product_matrices,
+    _get_average_dot_product_map,
+)
 from kikuchipy.signals.virtual_bse_image import VirtualBSEImage
 from kikuchipy.signals._common_image import CommonImage
 from kikuchipy.detectors import EBSDDetector
@@ -552,7 +558,7 @@ def remove_dynamic_background(
         The removal is performed by subtracting or dividing by a
         Gaussian blurred version of each pattern. Resulting pattern
         intensities are rescaled to fill the input patterns' data type
-        range.
+        range individually.
 
         Parameters
         ----------
@@ -797,7 +803,7 @@ def adaptive_histogram_equalization(
           only *after* static and dynamic background corrections,
           otherwise some unwanted darkening towards the edges might
           occur.
-        * The default window size might not fit all image sizes, so it
+        * The default window size might not fit all pattern sizes, so it
           may be necessary to search for the optimal window size.
         """
         # Determine window size (shape of contextual region)
@@ -1065,6 +1071,198 @@ def fft_filter(
         else:
             self.data = filtered_patterns
 
+    def get_neighbour_dot_product_matrices(
+        self,
+        window: Optional[Window] = None,
+        zero_mean: bool = True,
+        normalize: bool = True,
+        dtype_out: np.dtype = np.float32,
+    ) -> Union[np.ndarray, da.Array]:
+        """Get an array with dot products of a pattern and its
+        neighbours within a window.
+
+        Parameters
+        ----------
+        window
+            Window with integer coefficients defining the neighbours to
+            calculate the dot products with. If None (default), the four
+            nearest neighbours are used. Must have the same number of
+            dimensions as signal navigation dimensions.
+        zero_mean
+            Whether to subtract the mean of each pattern individually to
+            center the intensities about zero before calculating the
+            dot products. Default is True.
+        normalize
+            Whether to normalize the pattern intensities to a standard
+            deviation of 1 before calculating the dot products. This
+            operation is performed after centering the intensities if
+            `zero_mean` is True. Default is True.
+        dtype_out
+            Data type of the output map. Default is
+            :class:`numpy.float32`.
+
+        Returns
+        -------
+        """
+        if self.axes_manager.navigation_dimension == 0:
+            raise ValueError(
+                "Signal must have at least one navigation dimension"
+            )
+
+        # Create dask array of signal patterns and do processing on this
+        dask_array = get_dask_array(signal=self)
+
+        # Default to the nearest neighbours
+        nav_dim = self.axes_manager.navigation_dimension
+        if window is None:
+            window = Window(window="circular", shape=(3, 3)[:nav_dim])
+
+        # Set overlap depth between navigation chunks equal to the max.
+        # number of nearest neighbours in each navigation axis
+        overlap_depth = _get_chunk_overlap_depth(
+            window=window,
+            axes_manager=self.axes_manager,
+            chunksize=dask_array.chunksize,
+        )
+
+        window_shape = window.shape
+        window_dim = window.ndim
+        chunks = get_chunking(
+            data_shape=self.axes_manager.navigation_shape[::-1] + window_shape,
+            nav_dim=nav_dim,
+            sig_dim=window_dim,
+            dtype=dtype_out,
+        )
+        dp_matrices = dask_array.map_overlap(
+            _get_neighbour_dot_product_matrices,
+            window=window,
+            sig_dim=self.axes_manager.signal_dimension,
+            sig_size=self.axes_manager.signal_size,
+            zero_mean=zero_mean,
+            normalize=normalize,
+            dtype_out=dtype_out,
+            drop_axis=self.axes_manager.signal_indices_in_array,
+            new_axis=tuple(np.arange(window_dim) + nav_dim)[::-1],
+            dtype=dtype_out,
+            depth=overlap_depth,
+            boundary="none",
+            chunks=chunks,
+        )
+
+        if not self._lazy:
+            with ProgressBar():
+                print(
+                    "Calculating neighbour dot product matrices:",
+                    file=sys.stdout,
+                )
+                dp_matrices = dp_matrices.compute()
+
+        return dp_matrices
+
+    def get_average_neighbour_dot_product_map(
+        self,
+        window: Optional[Window] = None,
+        zero_mean: bool = True,
+        normalize: bool = True,
+        dtype_out: np.dtype = np.float32,
+        dp_matrices: Optional[np.ndarray] = None,
+    ) -> Union[np.ndarray, da.Array]:
+        """Get a map of the average dot product between patterns and
+        their neighbours within an averaging window.
+
+        Parameters
+        ----------
+        window
+            Window with integer coefficients defining the neighbours to
+            calculate the average with. If None (default), the four
+            nearest neighbours are used. Must have the same number of
+            dimensions as signal navigation dimensions.
+        zero_mean
+            Whether to subtract the mean of each pattern individually to
+            center the intensities about zero before calculating the
+            dot products. Default is True.
+        normalize
+            Whether to normalize the pattern intensities to a standard
+            deviation of 1 before calculating the dot products. This
+            operation is performed after centering the intensities if
+            `zero_mean` is True. Default is True.
+        dtype_out
+            Data type of the output map. Default is
+            :class:`numpy.float32`.
+        dp_matrices
+            Optional pre-calculated dot product matrices, by default
+            None. If an array is passed, the average dot product map
+            is calculated from this array. The `dp_matrices` array can
+            be obtained from :meth:`get_neighbour_dot_product_matrices`.
+            It's shape must correspond to the signal's navigation shape
+            and the window's shape.
+
+        Returns
+        -------
+        """
+        if self.axes_manager.navigation_dimension == 0:
+            raise ValueError(
+                "Signal must have at least one navigation dimension"
+            )
+
+        # Default to the nearest neighbours
+        nav_dim = self.axes_manager.navigation_dimension
+        if window is None:
+            window = Window(window="circular", shape=(3, 3)[:nav_dim])
+
+        if dp_matrices is not None:
+            nan_slices = [slice(None) for _ in range(nav_dim)]
+            nan_slices += [slice(i, i + 1) for i in window.origin]
+            dp_matrices2 = dp_matrices.copy()
+            dp_matrices2[tuple(nan_slices)] = np.nan
+            if nav_dim == 1:
+                mean_axis = 1
+            else:  # == 2
+                mean_axis = (2, 3)
+            return np.nanmean(dp_matrices2, axis=mean_axis)
+
+        # Create dask array of signal data and do processing on this
+        dask_array = get_dask_array(signal=self)
+
+        # Set overlap depth between navigation chunks equal to the max.
+        # number of nearest neighbours in each navigation axis
+        overlap_depth = _get_chunk_overlap_depth(
+            window=window,
+            axes_manager=self.axes_manager,
+            chunksize=dask_array.chunksize,
+        )
+
+        chunks = get_chunking(
+            data_shape=self.axes_manager.navigation_shape[::-1],
+            nav_dim=nav_dim,
+            sig_dim=0,
+            dtype=dtype_out,
+        )
+        adp = dask_array.map_overlap(
+            _get_average_dot_product_map,
+            window=window,
+            sig_dim=self.axes_manager.signal_dimension,
+            sig_size=self.axes_manager.signal_size,
+            zero_mean=zero_mean,
+            normalize=normalize,
+            dtype_out=dtype_out,
+            drop_axis=self.axes_manager.signal_indices_in_array,
+            dtype=dtype_out,
+            depth=overlap_depth,
+            boundary="none",
+            chunks=chunks,
+        )
+
+        if not self._lazy:
+            with ProgressBar():
+                print(
+                    "Calculating average neighbour dot product map:",
+                    file=sys.stdout,
+                )
+                adp = adp.compute()
+
+        return adp
+
     def average_neighbour_patterns(
         self,
         window: Union[str, np.ndarray, da.Array, Window] = "circular",
@@ -1076,7 +1274,8 @@ def average_neighbour_patterns(
 
         The amount of averaging is specified by the window coefficients.
         All patterns are averaged with the same window. Map borders are
-        extended with zeros.
+        extended with zeros. Resulting pattern intensities are rescaled
+        to fill the input patterns' data type range individually.
 
         Averaging is accomplished by correlating the window with the
         extended array of patterns using
@@ -1109,50 +1308,6 @@ def average_neighbour_patterns(
         ~kikuchipy.filters.window.Window
         :func:`scipy.signal.windows.get_window`
         :func:`scipy.ndimage.correlate`
-
-        Examples
-        --------
-        >>> import numpy as np
-        >>> import kikuchipy as kp
-        >>> s = kp.signals.EBSD(np.ones((4, 4, 1, 1)))
-        >>> k = 1
-        >>> for i in range(4):
-        ...     for j in range(4):
-        ...         s.inav[j, i].data *= k
-        ...         k += 1
-        >>> s.data[:, :, 0, 0]
-        array([[ 1.,  2.,  3.,  4.],
-               [ 5.,  6.,  7.,  8.],
-               [ 9., 10., 11., 12.],
-               [13., 14., 15., 16.]])
-        >>> s2 = s.deepcopy()  # For use below
-        >>> s.average_neighbour_patterns(
-        ...     window="circular", shape=(3, 3))
-        >>> s.data[:, :, 0, 0]
-        array([[ 2.66666667,  3.        ,  4.        ,  5.        ],
-               [ 5.25      ,  6.        ,  7.        ,  7.75      ],
-               [ 9.25      , 10.        , 11.        , 11.75      ],
-               [12.        , 13.        , 14.        , 14.33333333]])
-
-        A window object can also be passed
-
-        >>> w = kp.filters.Window(window="gaussian", std=2)
-        >>> w
-        Window (3, 3) gaussian
-        [[0.7788 0.8825 0.7788]
-         [0.8825 1.     0.8825]
-         [0.7788 0.8825 0.7788]]
-        >>> s2.average_neighbour_patterns(w)
-        >>> s2.data[:, :, 0, 0]
-        array([[ 3.34395304,  3.87516243,  4.87516264,  5.40637176],
-               [ 5.46879047,  5.99999985,  6.99999991,  7.53120901],
-               [ 9.46879095,  9.99999959, 11.00000015, 11.53120913],
-               [11.59362845, 12.12483732, 13.1248368 , 13.65604717]])
-
-        This window can subsequently be plotted and saved
-
-        >>> figure, image, colorbar = w.plot()
-        >>> figure.savefig('averaging_window.png')
         """
         if isinstance(window, Window) and window.is_valid():
             averaging_window = copy.copy(window)
@@ -1176,7 +1331,7 @@ def average_neighbour_patterns(
         # Get sum of window data for each pattern, to normalize with
         # after correlation
         window_sums = correlate(
-            input=np.ones(self.axes_manager.navigation_shape[::-1]),
+            input=np.ones(self.axes_manager.navigation_shape[::-1], dtype=int),
             weights=averaging_window,
             mode="constant",
             cval=0,
@@ -1188,7 +1343,6 @@ def average_neighbour_patterns(
         averaging_window = averaging_window.reshape(
             averaging_window.shape + (1,) * sig_dim
         )
-        #        averaging_window._add_axes(self.axes_manager.signal_dimension)
 
         # Create dask array of signal patterns and do processing on this
         dask_array = get_dask_array(signal=self)
@@ -1198,7 +1352,7 @@ def average_neighbour_patterns(
         for i in range(sig_dim):
             window_sums = np.expand_dims(window_sums, axis=window_sums.ndim)
         window_sums = da.from_array(
-            window_sums, chunks=dask_array.chunksize[:nav_dim] + (1,) * sig_dim
+            window_sums, chunks=dask_array.chunks[:nav_dim] + (1,) * sig_dim
         )
 
         # Create overlap between chunks to enable correlation with the window
@@ -1206,11 +1360,14 @@ def average_neighbour_patterns(
         data_dim = len(self.axes_manager.shape)
         overlap_depth = {}
         for i in range(data_dim):
-            if i < len(window_shape):
+            if (
+                i < len(window_shape)
+                and dask_array.chunks[i][0] < dask_array.shape[i]
+            ):
                 overlap_depth[i] = window_shape[i] // 2
             else:
                 overlap_depth[i] = 0
-        overlap_boundary = {i: "none" for i in range(data_dim)}
+        overlap_boundary = "none"
         overlapped_dask_array = da.overlap.overlap(
             dask_array, depth=overlap_depth, boundary=overlap_boundary,
         )
@@ -1542,6 +1699,7 @@ def __init__(self, *args, **kwargs):
     def compute(self, *args, **kwargs):
         xmap = self.xmap
         super().compute(*args, **kwargs)
+        gc.collect()  # Don't sink
         self._xmap = xmap
 
     def get_decomposition_model_write(
diff --git a/kikuchipy/signals/util/_dask.py b/kikuchipy/signals/util/_dask.py
index 00a4ab1d..7e5becc7 100644
--- a/kikuchipy/signals/util/_dask.py
+++ b/kikuchipy/signals/util/_dask.py
@@ -16,7 +16,7 @@
 # You should have received a copy of the GNU General Public License
 # along with kikuchipy. If not, see <http://www.gnu.org/licenses/>.
 
-from typing import Optional, Union
+from typing import List, Optional, Tuple, Union
 
 import dask.array as da
 import numpy as np
@@ -29,7 +29,7 @@ def get_chunking(
     sig_dim: Optional[int] = None,
     chunk_shape: Optional[int] = None,
     chunk_bytes: Union[int, float, str, None] = 30e6,
-    dtype: Optional[type] = None,
+    dtype: Optional[np.dtype] = None,
 ) -> tuple:
     """Get a chunk tuple based on the shape of the signal data.
 
@@ -97,7 +97,9 @@ def get_chunking(
     return chunks
 
 
-def get_dask_array(signal, dtype=None, **kwargs) -> da.Array:
+def get_dask_array(
+    signal, dtype: Optional[np.dtype] = None, **kwargs
+) -> da.Array:
     """Return dask array of patterns with appropriate chunking.
 
     Parameters
@@ -105,7 +107,7 @@ def get_dask_array(signal, dtype=None, **kwargs) -> da.Array:
     signal : :class:`~kikuchipy.signals.ebsd.EBSD` or\
             :class:`~kikuchipy.signals.ebsd.LazyEBSD`
         Signal with data to return dask array from.
-    dtype : :class:`numpy.dtype`, optional
+    dtype
         Data type of returned dask array. This is also passed on to
         :func:`~kikuchipy.signals.util.get_chunking`.
     kwargs
@@ -116,7 +118,7 @@ def get_dask_array(signal, dtype=None, **kwargs) -> da.Array:
 
     Returns
     -------
-    dask_array : :class:`dask.array.Array`
+    dask_array
         Dask array with signal data with appropriate chunking and data
         type.
     """
@@ -135,7 +137,32 @@ def get_dask_array(signal, dtype=None, **kwargs) -> da.Array:
     return dask_array.astype(dtype)
 
 
-def _rechunk_learning_results(factors, loadings, mbytes_chunk=100):
+def _get_chunk_overlap_depth(window, axes_manager, chunksize: tuple) -> dict:
+    """Return overlap depth between navigation chunks equal to the max.
+    number of nearest neighbours in each navigation axis.
+
+    Parameters
+    ----------
+    window : kikuchipy.filters.window.Window
+    axes_manager : hyperspy.axes.AxesManager
+    chunksize
+
+    Returns
+    -------
+    overlap_depth
+    """
+    sig_dim = axes_manager.signal_dimension
+    nav_shape = axes_manager.navigation_shape[::-1]
+    is_chunked = ~np.equal(chunksize[:-sig_dim], nav_shape)
+    overlap_depth = {
+        i: n for i, n in enumerate(window.n_neighbours) if is_chunked[i]
+    }
+    return overlap_depth
+
+
+def _rechunk_learning_results(
+    factors: np.ndarray, loadings: np.ndarray, mbytes_chunk: int = 100
+) -> list:
     """Return suggested data chunks for learning results.
 
     It is assumed that the loadings are not transposed. The last axes of
@@ -145,11 +172,15 @@ def _rechunk_learning_results(factors, loadings, mbytes_chunk=100):
 
     Parameters
     ----------
-    factors : :attr:`hyperspy.learn.mva.LearningResults.factors`
-        Component patterns in learning results.
-    loadings : :attr:`hyperspy.learn.mva.LearningResults.loadings`
-        Component loadings in learning results.
-    mbytes_chunk : int, optional
+    factors
+        Component patterns
+        :attr:`hyperspy.learn.mva.LearningResults.factors` in learning
+        results.
+    loadings
+        Component loadings
+        :attr:`hyperspy.learn.mva.LearningResults.loadings` in learning
+        results.
+    mbytes_chunk
         Size of chunks in MB, default is 100 MB as suggested in the Dask
         documentation.
 
@@ -157,13 +188,12 @@ def _rechunk_learning_results(factors, loadings, mbytes_chunk=100):
     -------
     List of two tuples :
         The first/second tuple are suggested chunks to pass to
-        :func:`dask.array.rechunk` for factors/loadings,
-        respectively.
+        :func:`dask.array.rechunk` for factors/loadings, respectively.
     """
     # Make sure the last factors/loading axes have the same shapes
     if factors.shape[-1] != loadings.shape[-1]:
         raise ValueError(
-            "The last dimensions in factors and loadings are not the same."
+            "The last dimensions in factors and loadings are not the same"
         )
 
     # Get shape of learning results
@@ -194,7 +224,11 @@ def _rechunk_learning_results(factors, loadings, mbytes_chunk=100):
     return chunks
 
 
-def _update_learning_results(learning_results, components, dtype_out):
+def _update_learning_results(
+    learning_results,
+    components: Union[None, int, List[int]],
+    dtype_out: np.dtype,
+) -> Tuple[np.ndarray, np.ndarray]:
     """Update learning results before calling
     :meth:`hyperspy.learn.mva.MVA.get_decomposition_model` by
     changing data type, keeping only desired components and rechunking
@@ -204,19 +238,19 @@ def _update_learning_results(learning_results, components, dtype_out):
     ----------
     learning_results : hyperspy.learn.mva.LearningResults
         Learning results with component patterns and loadings.
-    components : None, int or list of ints
-        If ``None``, rebuilds the signal from all ``components``. If
-        ``int``, rebuilds signal from ``components`` in range 0-given
-        ``int``. If list of ``int``, rebuilds signal from only
-        ``components`` in given list.
-    dtype_out : numpy.float16, numpy.float32 or numpy.float64
-        Data type to cast learning results to.
+    components
+        If None, rebuilds the signal from all `components`. If `int`,
+        rebuilds signal from `components` in range 0-given `int`. If
+        list of `int`, rebuilds signal from only `components` in given
+        list.
+    dtype_out
+        Floating data type to cast learning results to.
 
     Returns
     -------
-    factors : :attr:`hyperspy.learn.mva.LearningResults.factors`
+    factors
         Updated component patterns in learning results.
-    loadings : :attr:`hyperspy.learn.mva.LearningResults.loadings`
+    loadings
         Updated component loadings in learning results.
     """
     # Change data type
diff --git a/kikuchipy/signals/util/_map_helper.py b/kikuchipy/signals/util/_map_helper.py
new file mode 100644
index 00000000..18a9cbba
--- /dev/null
+++ b/kikuchipy/signals/util/_map_helper.py
@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+# Copyright 2019-2020 The kikuchipy developers
+#
+# This file is part of kikuchipy.
+#
+# kikuchipy is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# kikuchipy is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with kikuchipy. If not, see <http://www.gnu.org/licenses/>.
+
+"""Private functions for calculating dot products between EBSD patterns
+and their neighbours in a map of a 1D or 2D navigation shape.
+"""
+
+from typing import Callable, Optional, Tuple, Union
+
+import numpy as np
+from scipy.ndimage import generic_filter
+
+from kikuchipy.filters import Window
+from kikuchipy.pattern._pattern import _normalize, _zero_mean
+
+
+# This private module is tested indirectly via the EBSD methods
+# get_average_neighbour_dot_product_map() and
+# get_neighbour_dot_product_matrices()
+
+
+def _map_helper(
+    patterns: np.ndarray,
+    map_function: Callable,
+    window: Window,
+    nav_shape: tuple,
+    dtype_out: np.dtype = np.float32,
+    **kwargs,
+) -> np.ndarray:
+    """Return output of :func:`scipy.ndimage.generic_filter` after
+    wrapping the `map_function` to apply at each element of
+    `flat_index_map`.
+    
+    The generic filter function will be applied at each navigation
+    point.
+    
+    Parameters
+    ----------
+    patterns
+        Pattern chunk.
+    map_function
+        :func:`_neighbour_dot_products`.
+    window
+        Window defining the pattern neighbours to calculate the dot
+        product with.
+    nav_shape
+        Navigation shape of pattern chunk.
+    dtype_out
+        Output array data dtype.
+    kwargs
+        Keyword arguments passed to `map_function`.
+
+    Returns
+    -------
+    numpy.ndarray
+        The generic filter output.
+    """
+    # Array in the original navigation shape of indices into the
+    # flattened navigation axis
+    flat_index_map = np.arange(np.prod(nav_shape)).reshape(nav_shape)
+
+    def wrapped_map_function(indices):
+        # `indices` contain the indices to be picked out with window
+        # from `flat_index_map`
+        return map_function(
+            patterns=patterns,
+            indices=indices.astype(np.int),
+            nav_shape=nav_shape,
+            dtype_out=dtype_out,
+            **kwargs,
+        )
+
+    return generic_filter(
+        flat_index_map,
+        wrapped_map_function,
+        footprint=window,
+        mode="constant",
+        cval=-1,
+        output=None if "output" in kwargs else dtype_out,
+    )
+
+
+def _neighbour_dot_products(
+    patterns: np.ndarray,
+    indices: np.ndarray,
+    nav_shape: tuple,
+    sig_size: int,
+    dtype_out: np.dtype,
+    center_index: int,
+    zero_mean: bool,
+    normalize: bool,
+    flat_window_truthy_indices: Optional[np.ndarray] = None,
+    output: Optional[np.ndarray] = None,
+) -> Union[float, int]:
+    """Return either an average of a dot product matrix between a
+    pattern and it's neighbours, or the matrix.
+    
+    Parameters
+    ----------
+    patterns
+        Pattern chunk.
+    indices
+        Flat array of indices into `patterns`.
+    nav_shape
+        Navigation shape of `patterns`.
+    sig_size
+        Size of the signal, i.e. pattern or detector pixels.
+    dtype_out
+        Data type of the output dot product matrix and also of the
+        patterns prior to dot product calculation.
+    center_index
+        Index into `patterns` for the current pattern to calculate the
+        dot products for.
+    zero_mean
+        Whether to center the pattern intensities by subtracting the 
+        mean intensity to get an average intensity of zero,
+        individually.
+    normalize
+        Whether to normalize the pattern intensities to a standard
+        deviation of 1 before calculating the dot products. This
+        operation is performed after centering the intensities if
+        `zero_mean` is True.
+    flat_window_truthy_indices
+        Flat array of indices into `patterns` for the navigation points
+        to calculate dot products with. If None (default), the function
+        assumes that both `output` and this parameter is None, and that
+        the `output` array of dot products is to be updated inplace.
+    output
+        A continually, inplace updated 4D array containing the dot
+        product matrices.
+    """
+    # Flat navigation index corresponding to the origin of the window,
+    # i.e. into `patterns`, i.e. the current navigation point for which
+    # to calculate the dot product with it's neighbours
+    pat_idx = indices[center_index]
+
+    # Indices into `indices` of neighbours to compute dot product with,
+    # excluding neighbours outside the map and itself
+    neighbour_idx = np.where((indices != pat_idx) & (indices != -1))[0]
+    neighbours = indices[neighbour_idx]
+    neighbours = np.unravel_index(neighbours, nav_shape)
+    # Flat array of neighbour patterns
+    neighbour_patterns = patterns[neighbours].astype(dtype_out)
+    neighbour_patterns = neighbour_patterns.reshape((-1, sig_size))
+
+    # Flat pattern corresponding to the window origin, i.e. the current
+    # navigation point to average
+    pattern = patterns[np.unravel_index(pat_idx, nav_shape)]
+    pattern = pattern.squeeze().flatten().astype(dtype_out)
+
+    # Pre-process pattern intensities
+    if zero_mean:
+        pattern = _zero_mean(pattern, axis=0)
+        neighbour_patterns = _zero_mean(neighbour_patterns, axis=1)
+    if normalize:
+        pattern = _normalize(pattern, axis=0)
+        neighbour_patterns = _normalize(neighbour_patterns, axis=1)
+
+    # Calculate the dot products
+    dot_products = neighbour_patterns @ pattern
+
+    if output is None:
+        return np.mean(dot_products)
+    else:
+        center_value = (pattern ** 2).sum()
+        output[pat_idx][flat_window_truthy_indices[center_index]] = center_value
+        output[pat_idx][
+            flat_window_truthy_indices[neighbour_idx]
+        ] = dot_products
+        # Output variable is modified in place, but `_map_helper()`
+        # expects a (in this case discarded) returned value
+        return 1
+
+
+def _get_neighbour_dot_product_matrices(
+    patterns: np.ndarray,
+    window: Window,
+    sig_dim: int,
+    sig_size: int,
+    zero_mean: bool,
+    normalize: bool,
+    dtype_out: np.dtype,
+) -> np.ndarray:
+    """Return  a 4D array of a pattern chunk's navigation shape, and a
+    matrix of dot products between a pattern and its neighbours within a
+    window in each navigation point in that chunk.
+
+    Parameters
+    ----------
+    patterns
+        Pattern chunk.
+    window
+        Window defining the neighbours to calculate the average with.
+    sig_dim
+        Number of signal dimensions.
+    sig_size
+        Number of pattern pixels.
+    zero_mean
+        Whether to subtract the mean of each pattern individually to
+        center the intensities about zero before calculating the
+        dot products.
+    normalize
+        Whether to normalize the pattern intensities to a standard
+        deviation of 1 before calculating the dot products. This
+        operation is performed after centering the intensities if
+        `zero_mean` is True.
+    dtype_out
+        Data type of output map.
+
+    Returns
+    -------
+    adp
+        Map of the average dot product between each pattern and its
+        neighbours in a chunk of patterns.
+    """
+    # Get a flat boolean window, a boolean array with True for True
+    # window coefficients, and the index of this window's origin
+    (
+        boolean_window,
+        flat_window_truthy_indices,
+        center_index,
+    ) = _setup_window_indices(window=window)
+
+    nav_shape = patterns.shape[:-sig_dim]
+    output = np.empty((np.prod(nav_shape), window.size), dtype=dtype_out)
+    output[:] = np.nan
+
+    _map_helper(
+        patterns,
+        _neighbour_dot_products,
+        window=boolean_window,
+        nav_shape=nav_shape,
+        sig_size=sig_size,
+        center_index=center_index,
+        flat_window_truthy_indices=flat_window_truthy_indices,
+        zero_mean=zero_mean,
+        normalize=normalize,
+        output=output,
+    )
+
+    output = output.reshape(nav_shape + window.shape)
+
+    return output
+
+
+def _get_average_dot_product_map(
+    patterns: np.ndarray,
+    window: Window,
+    sig_dim: int,
+    sig_size: int,
+    zero_mean: bool,
+    normalize: bool,
+    dtype_out: np.dtype,
+) -> np.ndarray:
+    """Return the average dot product map for a chunk of patterns.
+
+    Parameters
+    ----------
+    patterns
+        Pattern chunk.
+    window
+        Window defining the neighbours to calculate the average with.
+    sig_dim
+        Number of signal dimensions.
+    sig_size
+        Number of pattern pixels.
+    zero_mean
+        Whether to subtract the mean of each pattern individually to
+        center the intensities about zero before calculating the
+        dot products.
+    normalize
+        Whether to normalize the pattern intensities to a standard
+        deviation of 1 before calculating the dot products. This
+        operation is performed after centering the intensities if
+        `zero_mean` is True.
+    dtype_out
+        Data type of output map.
+
+    Returns
+    -------
+    adp
+        Average dot product map for the chunk of patterns.
+    """
+    # Get a flat boolean window and the index of this window's origin
+    boolean_window, _, center_index = _setup_window_indices(window=window)
+
+    adp = _map_helper(
+        patterns,
+        _neighbour_dot_products,
+        window=boolean_window,
+        nav_shape=patterns.shape[:-sig_dim],
+        sig_size=sig_size,
+        dtype_out=dtype_out,
+        center_index=center_index,
+        zero_mean=zero_mean,
+        normalize=normalize,
+    )
+
+    return adp
+
+
+def _setup_window_indices(window: Window) -> Tuple[np.ndarray, np.ndarray, int]:
+    # Index of window origin in flattened window
+    flat_window_origin = np.ravel_multi_index(window.origin, window.shape)
+
+    # Make window flat with boolean values
+    boolean_window = window.copy().astype(bool)
+    flat_window = boolean_window.flatten()
+
+    # Index of window origin in boolean array with only True values
+    flat_window_truthy_indices = np.nonzero(flat_window)[0]
+    center_index = np.where(flat_window_truthy_indices == flat_window_origin)
+    center_index = center_index[0][0]
+
+    return boolean_window, flat_window_truthy_indices, center_index


Test patch:
diff --git a/kikuchipy/filters/tests/test_window.py b/kikuchipy/filters/tests/test_window.py
index 7df95e64..0afed038 100644
--- a/kikuchipy/filters/tests/test_window.py
+++ b/kikuchipy/filters/tests/test_window.py
@@ -468,3 +468,16 @@ def test_gaussian(self, std, shape, answer):
         w = w / np.sum(w)
 
         assert np.allclose(w, answer)
+
+    @pytest.mark.parametrize(
+        "shape, desired_n_neighbours",
+        [
+            ((3, 3), (1, 1)),
+            ((3,), (1,)),
+            ((7, 5), (3, 2),),
+            ((6, 5), (2, 2)),
+            ((5, 7), (2, 3)),
+        ],
+    )
+    def test_n_neighbours(self, shape, desired_n_neighbours):
+        assert Window(shape=shape).n_neighbours == desired_n_neighbours
diff --git a/kikuchipy/pattern/tests/test_chunk.py b/kikuchipy/pattern/tests/test_chunk.py
index 27e71f79..2f79f4f1 100644
--- a/kikuchipy/pattern/tests/test_chunk.py
+++ b/kikuchipy/pattern/tests/test_chunk.py
@@ -35,20 +35,6 @@
 
 
 # Expected output intensities from various image processing methods
-RESCALED_UINT8 = np.array(
-    [[182, 218, 182], [255, 218, 182], [218, 36, 0]], dtype=np.uint8
-)
-RESCALED_FLOAT32 = np.array(
-    [
-        [0.714286, 0.857143, 0.714286],
-        [1.0, 0.857143, 0.714286],
-        [0.857143, 0.142857, 0.0],
-    ],
-    dtype=np.float32,
-)
-RESCALED_UINT8_0100 = np.array(
-    [[71, 85, 71], [100, 85, 71], [85, 14, 0]], dtype=np.uint8
-)
 STATIC_SUB_UINT8 = np.array(
     [[127, 212, 127], [255, 255, 170], [212, 0, 0]], dtype=np.uint8
 )
@@ -608,20 +594,21 @@ def test_average_neighbour_patterns_chunk(self, dummy_signal, dtype_in):
         # Get sum of window data for each image
         nav_shape = dummy_signal.axes_manager.navigation_shape
         w_sums = convolve(
-            input=np.ones(nav_shape[::-1]),
+            input=np.ones(nav_shape[::-1], dtype=int),
             weights=w.data,
             mode="constant",
             cval=0,
         )
 
-        for i in range(dummy_signal.axes_manager.signal_dimension):
+        # Add signal dimensions to arrays to enable their use with
+        # Dask's map_blocks()
+        sig_dim = dummy_signal.axes_manager.signal_dimension
+        nav_dim = dummy_signal.axes_manager.navigation_dimension
+        for _ in range(sig_dim):
             w_sums = np.expand_dims(w_sums, axis=w_sums.ndim)
-        w_sums = da.from_array(w_sums, chunks=dask_array.chunksize)
-
-        # Add signal dimensions to window array to enable its use with Dask's
-        # map_blocks()
-        w = w.reshape(
-            w.shape + (1,) * dummy_signal.axes_manager.signal_dimension
+            w = np.expand_dims(w, axis=w.ndim)
+        w_sums = da.from_array(
+            w_sums, chunks=dask_array.chunks[:nav_dim] + (1,) * sig_dim
         )
 
         averaged_patterns = dask_array.map_blocks(
@@ -632,9 +619,9 @@ def test_average_neighbour_patterns_chunk(self, dummy_signal, dtype_in):
             dtype=dtype_out,
         )
 
-        answer = np.array([7, 4, 6, 6, 3, 7, 7, 3, 2], dtype=np.uint8).reshape(
-            (3, 3)
-        )
+        answer = np.array(
+            [255, 109, 218, 218, 36, 236, 255, 36, 0], dtype=np.uint8
+        ).reshape((3, 3))
 
         # Check for correct data type and gives expected output intensities
         assert averaged_patterns.dtype == dtype_out
diff --git a/kikuchipy/signals/tests/test_ebsd.py b/kikuchipy/signals/tests/test_ebsd.py
index 83f653a7..8b57262b 100644
--- a/kikuchipy/signals/tests/test_ebsd.py
+++ b/kikuchipy/signals/tests/test_ebsd.py
@@ -32,6 +32,7 @@
 from skimage.exposure import rescale_intensity
 
 from kikuchipy import load
+from kikuchipy.data import nickel_ebsd_small
 from kikuchipy.filters.window import Window
 from kikuchipy.pattern._pattern import fft_spectrum
 from kikuchipy.signals.ebsd import EBSD, LazyEBSD
@@ -639,12 +640,13 @@ class TestAverageNeighbourPatternsEBSD:
                 # fmt: off
                 np.array(
                     [
-                        7, 4, 6, 6, 3, 7, 7, 3, 2, 4, 4, 6, 4, 2, 5, 4, 3, 5, 5,
-                        5, 3, 5, 3, 8, 6, 5, 5, 5, 2, 6, 4, 3, 3, 4, 1, 1, 6, 4,
-                        6, 4, 3, 4, 5, 5, 3, 5, 3, 3, 3, 3, 5, 3, 4, 5, 5, 3, 7,
-                        4, 4, 2, 3, 4, 1, 5, 3, 6, 3, 4, 1, 1, 4, 4, 7, 6, 3, 4,
-                        6, 4, 3, 6, 3,
-                    ],
+                        255, 109, 218, 218, 36, 236, 255, 36, 0, 143, 111, 255,
+                        159, 0, 207, 159, 63, 175, 136, 118, 33, 118, 0, 255,
+                        153, 118, 102, 182, 24, 255, 121, 109, 85, 133, 0, 12,
+                        255, 107, 228, 80, 40, 107, 161, 147, 0, 204, 0, 51, 51,
+                        51, 229, 25, 76, 255, 195, 104, 255, 135, 150, 59, 104,
+                        120, 0, 204, 102, 255, 89, 127, 0, 12, 140, 127, 255,
+                        185, 0, 69, 162, 46, 0, 208, 0                    ],
                 ),
                 # fmt: on
                 None,
@@ -656,11 +658,13 @@ class TestAverageNeighbourPatternsEBSD:
                 # fmt: off
                 np.array(
                     [
-                        7, 6, 6, 7, 3, 6, 7, 4, 3, 4, 5, 5, 6, 2, 7, 5, 3, 5, 4,
-                        5, 5, 6, 1, 8, 5, 5, 7, 6, 3, 7, 5, 2, 5, 6, 3, 3, 5, 3,
-                        5, 4, 3, 6, 5, 3, 3, 5, 4, 5, 4, 2, 6, 5, 4, 5, 5, 2, 7,
-                        3, 3, 2, 3, 3, 2, 6, 3, 5, 3, 4, 3, 3, 4, 3, 6, 4, 5, 3,
-                        4, 3, 3, 5, 4,
+                        255, 223, 223, 255, 0, 223, 255, 63, 0, 109, 145, 145,
+                        200, 0, 255, 163, 54, 127, 119, 136, 153, 170, 0, 255,
+                        153, 136, 221, 212, 42, 255, 127, 0, 141, 184, 14, 28,
+                        210, 44, 179, 134, 0, 255, 210, 14, 29, 200, 109, 182,
+                        109, 0, 255, 182, 145, 182, 150, 34, 255, 57, 81, 0, 57,
+                        69, 11, 255, 38, 191, 63, 114, 38, 50, 89, 0, 255, 117,
+                        137, 19, 117, 0, 0, 176, 58
                     ],
                 ),
                 # fmt: on
@@ -673,11 +677,13 @@ class TestAverageNeighbourPatternsEBSD:
                 # fmt: off
                 np.array(
                     [
-                        6, 3, 7, 5, 2, 5, 6, 2, 3, 5, 3, 5, 4, 3, 6, 5, 3, 3, 5,
-                        4, 4, 4, 2, 6, 5, 4, 5, 5, 3, 7, 4, 3, 3, 4, 3, 2, 5, 4,
-                        5, 4, 3, 4, 4, 4, 3, 5, 4, 4, 4, 3, 5, 4, 5, 5, 5, 2, 7,
-                        3, 3, 1, 3, 3, 2, 6, 3, 5, 3, 4, 3, 3, 4, 3, 6, 4, 4, 3,
-                        4, 3, 3, 5, 4,
+                        218, 46, 255, 139, 0, 150, 194, 3, 11, 211, 63, 196,
+                        145, 0, 255, 211, 33, 55, 175, 105, 155, 110, 0, 255,
+                        169, 135, 177, 184, 72, 255, 112, 59, 62, 115, 55, 0,
+                        255, 51, 225, 107, 21, 122, 85, 47, 0, 255, 129, 152,
+                        77, 0, 169, 48, 187, 170, 153, 36, 255, 63, 86, 0, 57,
+                        69, 4, 255, 45, 206, 58, 115, 16, 33, 98, 0, 255, 121,
+                        117, 32, 121, 14, 0, 174, 66
                     ],
                 ),
                 # fmt: on
@@ -719,8 +725,8 @@ def test_average_neighbour_patterns_one_nav_dim(self, dummy_signal):
         # fmt: off
         answer = np.array(
             [
-                7, 6, 6, 7, 3, 6, 7, 4, 3, 4, 5, 5, 6, 2, 7, 5, 3, 5, 4, 5, 5,
-                6, 1, 8, 5, 5, 7,
+                255, 223, 223, 255, 0, 223, 255, 63, 0, 109, 145, 145, 200, 0,
+                255, 163, 54, 127, 119, 136, 153, 170, 0, 255, 153, 136, 221
             ],
             dtype=np.uint8
         ).reshape(dummy_signal_1d.axes_manager.shape)
@@ -733,10 +739,12 @@ def test_average_neighbour_patterns_window_1d(self, dummy_signal):
         # fmt: off
         answer = np.array(
             [
-                6, 3, 6, 6, 5, 6, 7, 1, 1, 6, 3, 8, 3, 0, 4, 5, 4, 5, 4, 4, 1,
-                4, 4, 8, 5, 4, 4, 5, 2, 6, 5, 4, 4, 5, 1, 0, 6, 5, 8, 3, 2, 2,
-                4, 6, 4, 5, 4, 2, 5, 4, 7, 4, 4, 6, 6, 1, 6, 4, 4, 4, 4, 1, 1,
-                4, 4, 8, 2, 3, 0, 2, 5, 3, 8, 5, 1, 5, 6, 6, 4, 5, 4,
+                233, 106, 212, 233, 170, 233, 255, 21, 0, 191, 95, 255, 95, 0,
+                111, 143, 127, 159, 98, 117, 0, 117, 117, 255, 137, 117, 117,
+                239, 95, 255, 223, 191, 175, 207, 31, 0, 155, 127, 255, 56, 0,
+                14, 70, 155, 84, 175, 111, 0, 143, 127, 255, 95, 127, 191, 231,
+                0, 255, 162, 139, 139, 162, 23, 0, 135, 135, 255, 60, 105, 0,
+                60, 165, 105, 255, 127, 0, 127, 163, 182, 109, 145, 109
             ],
             dtype=np.uint8
         ).reshape(dummy_signal.axes_manager.shape)
@@ -750,10 +758,12 @@ def test_average_neighbour_patterns_pass_window(self, dummy_signal):
         # fmt: off
         answer = np.array(
             [
-                7, 4, 6, 6, 3, 7, 7, 3, 2, 4, 4, 6, 4, 2, 5, 4, 3, 5, 5, 5, 3,
-                5, 3, 8, 6, 5, 5, 5, 2, 6, 4, 3, 3, 4, 1, 1, 6, 4, 6, 4, 3, 4,
-                5, 5, 3, 5, 3, 3, 3, 3, 5, 3, 4, 5, 5, 3, 7, 4, 4, 2, 3, 4, 1,
-                5, 3, 6, 3, 4, 1, 1, 4, 4, 7, 6, 3, 4, 6, 4, 3, 6, 3,
+                255, 109, 218, 218, 36, 236, 255, 36, 0, 143, 111, 255, 159, 0,
+                207, 159, 63, 175, 136, 118, 33, 118, 0, 255, 153, 118, 102,
+                182, 24, 255, 121, 109, 85, 133, 0, 12, 255, 107, 228, 80, 40,
+                107, 161, 147, 0, 204, 0, 51, 51, 51, 229, 25, 76, 255, 195,
+                104, 255, 135, 150, 59, 104, 120, 0, 204, 102, 255, 89, 127, 0,
+                12, 140, 127, 255, 185, 0, 69, 162, 46, 0, 208, 0
             ],
             dtype=np.uint8
         ).reshape(dummy_signal.axes_manager.shape)
@@ -761,6 +771,18 @@ def test_average_neighbour_patterns_pass_window(self, dummy_signal):
         assert np.allclose(dummy_signal.data, answer)
         assert dummy_signal.data.dtype == answer.dtype
 
+    def test_average_neighbour_patterns_lazy(self):
+        """Fixes https://github.com/pyxem/kikuchipy/issues/230."""
+        chunks = (
+            (3, 3, 4, 3, 4, 3, 4, 3, 3, 4, 3, 4, 3, 4, 3, 4),
+            (75,),
+            (6,),
+            (6,),
+        )
+        s = LazyEBSD(da.zeros((55, 75, 6, 6), chunks=chunks, dtype=np.uint8))
+        s.average_neighbour_patterns()
+        s.compute()
+
 
 class TestRebin:
     def test_rebin(self, dummy_signal):
@@ -1231,3 +1253,315 @@ def test_match_patterns(self, dummy_signal):
         xmap = dummy_signal.match_patterns(s_dict)
 
         assert np.allclose(xmap.scores[:, 0], 1)
+
+
+class TestAverageNeighbourDotProductMap:
+    def test_adp_0d(self):
+        s = nickel_ebsd_small().inav[0, 0]
+        with pytest.raises(ValueError, match="Signal must have at least one"):
+            _ = s.get_average_neighbour_dot_product_map()
+
+    def test_adp_1d(self):
+        s = nickel_ebsd_small().inav[0]
+        adp = s.get_average_neighbour_dot_product_map()
+        assert np.allclose(adp, [0.997470, 0.997457, 0.99744], atol=1e-5)
+
+    def test_adp_2d(self):
+        s = nickel_ebsd_small()
+        adp = s.get_average_neighbour_dot_product_map()
+        assert np.allclose(
+            adp,
+            [
+                [0.995679, 0.996117, 0.997220],
+                [0.996363, 0.996561, 0.997252],
+                [0.995731, 0.996134, 0.997048],
+            ],
+            atol=1e-5,
+        )
+        assert adp.dtype == np.float32
+
+    @pytest.mark.parametrize(
+        "window, desired_adp_map",
+        [
+            (
+                "rectangular",
+                [
+                    [0.995135, 0.995891, 0.997144],
+                    [0.995425, 0.996032, 0.997245],
+                    [0.995160, 0.995959, 0.997019],
+                ],
+            ),
+            (
+                "circular",
+                [
+                    [0.995679, 0.996117, 0.997220],
+                    [0.996363, 0.996561, 0.997252],
+                    [0.995731, 0.996134, 0.997048],
+                ],
+            ),
+        ],
+    )
+    def test_adp_window(self, window, desired_adp_map):
+        s = nickel_ebsd_small()
+        w = Window(window=window)
+        adp = s.get_average_neighbour_dot_product_map(window=w)
+        assert np.allclose(adp, desired_adp_map, atol=1e-5)
+
+    @pytest.mark.parametrize(
+        "zero_mean, desired_adp_map",
+        [
+            (
+                True,
+                [
+                    [0.995679, 0.996117, 0.997220],
+                    [0.996363, 0.996561, 0.997252],
+                    [0.995731, 0.996134, 0.997048],
+                ],
+            ),
+            (
+                False,
+                [
+                    [0.999663, 0.999699, 0.999785],
+                    [0.999717, 0.999733, 0.999786],
+                    [0.999666, 0.999698, 0.999769],
+                ],
+            ),
+        ],
+    )
+    def test_adp_zero_mean(self, zero_mean, desired_adp_map):
+        s = nickel_ebsd_small()
+        adp = s.get_average_neighbour_dot_product_map(zero_mean=zero_mean)
+        assert np.allclose(adp, desired_adp_map, atol=1e-5)
+
+    @pytest.mark.parametrize(
+        "normalize, desired_adp_map",
+        [
+            (
+                True,
+                [
+                    [0.995679, 0.996117, 0.997220],
+                    [0.996363, 0.996561, 0.997252],
+                    [0.995731, 0.996134, 0.997048],
+                ],
+            ),
+            (
+                False,
+                [
+                    [6402544, 6398041.5, 6434939.5],
+                    [6411949.5, 6409170, 6464348],
+                    [6451061, 6456555.5, 6489456],
+                ],
+            ),
+        ],
+    )
+    def test_adp_normalize(self, normalize, desired_adp_map):
+        s = nickel_ebsd_small()
+        adp = s.get_average_neighbour_dot_product_map(normalize=normalize)
+        assert np.allclose(adp, desired_adp_map, atol=1e-5)
+
+    def test_adp_dtype_out(self):
+        s = nickel_ebsd_small()
+        dtype1 = np.float32
+        adp1 = s.get_average_neighbour_dot_product_map(normalize=False)
+        assert adp1.dtype == dtype1
+        dtype2 = np.int32
+        adp2 = s.get_average_neighbour_dot_product_map(
+            normalize=True, dtype_out=dtype2
+        )
+        assert adp2.dtype == dtype2
+
+    def test_adp_lazy(self):
+        s = nickel_ebsd_small(lazy=True)
+        adp = s.get_average_neighbour_dot_product_map()
+
+        assert np.allclose(
+            adp.compute(),
+            [
+                [0.995679, 0.996117, 0.997220],
+                [0.996363, 0.996561, 0.997252],
+                [0.995731, 0.996134, 0.997048],
+            ],
+            atol=1e-5,
+        )
+        assert adp.dtype == np.float32
+
+    @pytest.mark.parametrize(
+        "window",
+        [
+            Window(window="circular", shape=(3, 3)),
+            Window(window="rectangular", shape=(3, 2)),
+            Window(window="rectangular", shape=(2, 3)),
+        ],
+    )
+    def test_adp_dp_matrices(self, window):
+        s = nickel_ebsd_small()
+        dp_matrices = s.get_neighbour_dot_product_matrices(window=window)
+        adp1 = s.get_average_neighbour_dot_product_map(window=window)
+        adp2 = s.get_average_neighbour_dot_product_map(dp_matrices=dp_matrices)
+
+        assert np.allclose(adp1, adp2)
+
+    @pytest.mark.parametrize("slices", [(0,), (slice(0, 1), slice(None))])
+    def test_adp_dp_matrices_shapes(self, slices):
+        s = nickel_ebsd_small().inav[slices]
+        dp_matrices = s.get_neighbour_dot_product_matrices()
+        adp1 = s.get_average_neighbour_dot_product_map()
+        adp2 = s.get_average_neighbour_dot_product_map(dp_matrices=dp_matrices)
+
+        assert np.allclose(adp1, adp2)
+
+
+class TestNeighbourDotProductMatrices:
+    def test_dp_matrices_0d(self):
+        s = nickel_ebsd_small().inav[0, 0]
+        with pytest.raises(ValueError, match="Signal must have at least one"):
+            _ = s.get_neighbour_dot_product_matrices()
+
+    def test_dp_matrices_1d(self):
+        s = nickel_ebsd_small().inav[0]
+        dp_matrices = s.get_neighbour_dot_product_matrices()
+
+        assert dp_matrices.shape == s.axes_manager.navigation_shape + (3,)
+        assert dp_matrices.dtype == np.float32
+        assert np.allclose(
+            dp_matrices,
+            [
+                [np.nan, 1, 0.997470],
+                [0.997470, 1, 0.997444],
+                [0.997444, 1, np.nan],
+            ],
+            atol=1e-5,
+            equal_nan=True,
+        )
+
+    def test_dp_matrices_2d(self):
+        s = nickel_ebsd_small()
+        dp_matrices = s.get_neighbour_dot_product_matrices()
+
+        assert dp_matrices.shape == s.axes_manager.navigation_shape + (3, 3)
+        assert dp_matrices.dtype == np.float32
+        assert np.allclose(
+            dp_matrices[1, 1],
+            [
+                [np.nan, 0.997347, np.nan],
+                [0.994177, 1, 0.997358],
+                [np.nan, 0.997360, np.nan],
+            ],
+            atol=1e-5,
+            equal_nan=True,
+        )
+
+    def test_dp_matrices_lazy(self):
+        s = nickel_ebsd_small()
+        s_lazy = s.as_lazy()
+        dp_matrices = s.get_neighbour_dot_product_matrices()
+        dp_matrices_lazy = s_lazy.get_neighbour_dot_product_matrices()
+
+        assert dp_matrices.shape == dp_matrices_lazy.shape
+        assert dp_matrices.dtype == dp_matrices_lazy.dtype
+        assert np.allclose(dp_matrices, dp_matrices_lazy, equal_nan=True)
+
+    @pytest.mark.parametrize(
+        "window, desired_dp_matrices_11",
+        [
+            (
+                Window(window="circular", shape=(3, 3)),
+                [
+                    [np.nan, 0.997347, np.nan],
+                    [0.994177, 1, 0.997358],
+                    [np.nan, 0.997360, np.nan],
+                ],
+            ),
+            (
+                Window(window="rectangular", shape=(3, 3)),
+                [
+                    [0.994048, 0.997347, 0.996990],
+                    [0.994177, 1, 0.997358],
+                    [0.994017, 0.997360, 0.996960],
+                ],
+            ),
+            (
+                Window(window="rectangular", shape=(3, 2)),
+                [[0.994048, 0.997347], [0.994177, 1], [0.994017, 0.997360]],
+            ),
+            (
+                Window(window="rectangular", shape=(2, 3)),
+                [[0.994048, 0.997347, 0.996990], [0.994177, 1, 0.997358]],
+            ),
+        ],
+    )
+    def test_dp_matrices_window(self, window, desired_dp_matrices_11):
+        s = nickel_ebsd_small()
+        dp_matrices = s.get_neighbour_dot_product_matrices(window=window)
+
+        assert np.allclose(
+            dp_matrices[1, 1],
+            desired_dp_matrices_11,
+            atol=1e-5,
+            equal_nan=True,
+        )
+
+    @pytest.mark.parametrize("dtype_out", [np.float16, np.float32, np.float64])
+    def test_dp_matrices_dtype_out(self, dtype_out):
+        s = nickel_ebsd_small()
+        dp_matrices = s.get_neighbour_dot_product_matrices(dtype_out=dtype_out)
+
+        assert dp_matrices.dtype == dtype_out
+
+    @pytest.mark.parametrize(
+        "zero_mean, desired_dp_matrices11",
+        [
+            (
+                True,
+                [
+                    [np.nan, 0.997347, np.nan],
+                    [0.994177, 1, 0.997358],
+                    [np.nan, 0.997360, np.nan],
+                ],
+            ),
+            (
+                False,
+                [
+                    [np.nan, 0.999796, np.nan],
+                    [0.999547, 1, 0.999794],
+                    [np.nan, 0.999796, np.nan],
+                ],
+            ),
+        ],
+    )
+    def test_dp_matrices_zero_mean(self, zero_mean, desired_dp_matrices11):
+        s = nickel_ebsd_small()
+        dp_matrices = s.get_neighbour_dot_product_matrices(zero_mean=zero_mean)
+
+        assert np.allclose(
+            dp_matrices[1, 1], desired_dp_matrices11, atol=1e-5, equal_nan=True,
+        )
+
+    @pytest.mark.parametrize(
+        "normalize, desired_dp_matrices11",
+        [
+            (
+                True,
+                [
+                    [np.nan, 0.997347, np.nan],
+                    [0.994177, 1, 0.997358],
+                    [np.nan, 0.997360, np.nan],
+                ],
+            ),
+            (
+                False,
+                [
+                    [np.nan, 6393165.5, np.nan],
+                    [6375199, 6403340, 6439387],
+                    [np.nan, 6428928, np.nan],
+                ],
+            ),
+        ],
+    )
+    def test_dp_matrices_normalize(self, normalize, desired_dp_matrices11):
+        s = nickel_ebsd_small()
+        dp_matrices = s.get_neighbour_dot_product_matrices(normalize=normalize)
+
+        assert np.allclose(
+            dp_matrices[1, 1], desired_dp_matrices11, atol=1e-5, equal_nan=True,
+        )