Add files using upload-large-folder tool

envs/kitoverlay/skimage/_shared/_dependency_checks.py

@@ -0,0 +1,7 @@
+from .version_requirements import is_installed
+import sys
+import platform
+
+has_mpl = is_installed("matplotlib", ">=3.3")
+
+is_wasm = (sys.platform == "emscripten") or (platform.machine() in ["wasm32", "wasm64"])

envs/kitoverlay/skimage/_shared/_warnings.py

@@ -0,0 +1,149 @@
+from contextlib import contextmanager
+import sys
+import warnings
+import re
+import functools
+import os
+
+__all__ = ['all_warnings', 'expected_warnings', 'warn']
+
+
+# A version of `warnings.warn` with a default stacklevel of 2.
+# functool is used so as not to increase the call stack accidentally
+warn = functools.partial(warnings.warn, stacklevel=2)
+
+
+@contextmanager
+def all_warnings():
+    """
+    Context for use in testing to ensure that all warnings are raised.
+
+    Examples
+    --------
+    >>> import warnings
+    >>> def foo():
+    ...     warnings.warn(RuntimeWarning("bar"), stacklevel=2)
+
+    We raise the warning once, while the warning filter is set to "once".
+    Hereafter, the warning is invisible, even with custom filters:
+
+    >>> with warnings.catch_warnings():
+    ...     warnings.simplefilter('once')
+    ...     foo()                         # doctest: +SKIP
+
+    We can now run ``foo()`` without a warning being raised:
+
+    >>> from numpy.testing import assert_warns
+    >>> foo()                             # doctest: +SKIP
+
+    To catch the warning, we call in the help of ``all_warnings``:
+
+    >>> with all_warnings():
+    ...     assert_warns(RuntimeWarning, foo)
+    """
+    # _warnings.py is on the critical import path.
+    # Since this is a testing only function, we lazy import inspect.
+    import inspect
+
+    # Whenever a warning is triggered, Python adds a __warningregistry__
+    # member to the *calling* module.  The exercise here is to find
+    # and eradicate all those breadcrumbs that were left lying around.
+    #
+    # We proceed by first searching all parent calling frames and explicitly
+    # clearing their warning registries (necessary for the doctests above to
+    # pass).  Then, we search for all submodules of skimage and clear theirs
+    # as well (necessary for the skimage test suite to pass).
+
+    frame = inspect.currentframe()
+    if frame:
+        for f in inspect.getouterframes(frame):
+            f[0].f_locals['__warningregistry__'] = {}
+    del frame
+
+    for mod_name, mod in list(sys.modules.items()):
+        try:
+            mod.__warningregistry__.clear()
+        except AttributeError:
+            pass
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        yield w
+
+
+@contextmanager
+def expected_warnings(matching):
+    r"""Context for use in testing to catch known warnings matching regexes
+
+    Parameters
+    ----------
+    matching : None or a list of strings or compiled regexes
+        Regexes for the desired warning to catch
+        If matching is None, this behaves as a no-op.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> rng = np.random.default_rng()
+    >>> image = rng.integers(0, 2**16, size=(100, 100), dtype=np.uint16)
+    >>> # rank filters are slow when bit-depth exceeds 10 bits
+    >>> from skimage import filters
+    >>> with expected_warnings(['Bad rank filter performance']):
+    ...     median_filtered = filters.rank.median(image)
+
+    Notes
+    -----
+    Uses `all_warnings` to ensure all warnings are raised.
+    Upon exiting, it checks the recorded warnings for the desired matching
+    pattern(s).
+    Raises a ValueError if any match was not found or an unexpected
+    warning was raised.
+    Allows for three types of behaviors: `and`, `or`, and `optional` matches.
+    This is done to accommodate different build environments or loop conditions
+    that may produce different warnings.  The behaviors can be combined.
+    If you pass multiple patterns, you get an orderless `and`, where all of the
+    warnings must be raised.
+    If you use the `|` operator in a pattern, you can catch one of several
+    warnings.
+    Finally, you can use `|\A\Z` in a pattern to signify it as optional.
+
+    """
+    if isinstance(matching, str):
+        raise ValueError(
+            '``matching`` should be a list of strings and not a string itself.'
+        )
+
+    # Special case for disabling the context manager
+    if matching is None:
+        yield None
+        return
+
+    strict_warnings = os.environ.get('SKIMAGE_TEST_STRICT_WARNINGS', '1')
+    if strict_warnings.lower() == 'true':
+        strict_warnings = True
+    elif strict_warnings.lower() == 'false':
+        strict_warnings = False
+    else:
+        strict_warnings = bool(int(strict_warnings))
+
+    with all_warnings() as w:
+        # enter context
+        yield w
+        # exited user context, check the recorded warnings
+        # Allow users to provide None
+        while None in matching:
+            matching.remove(None)
+        remaining = [m for m in matching if r'\A\Z' not in m.split('|')]
+        for warn in w:
+            found = False
+            for match in matching:
+                if re.search(match, str(warn.message)) is not None:
+                    found = True
+                    if match in remaining:
+                        remaining.remove(match)
+            if strict_warnings and not found:
+                raise ValueError(f'Unexpected warning: {str(warn.message)}')
+        if strict_warnings and (len(remaining) > 0):
+            newline = "\n"
+            msg = f"No warning raised matching:{newline}{newline.join(remaining)}"
+            raise ValueError(msg)

envs/kitoverlay/skimage/_shared/compat.py

@@ -0,0 +1,32 @@
+"""Compatibility helpers for dependencies."""
+
+from packaging.version import parse
+
+import numpy as np
+import scipy as sp
+
+
+__all__ = [
+    "NP_COPY_IF_NEEDED",
+    "SCIPY_CG_TOL_PARAM_NAME",
+]
+
+
+NUMPY_LT_2_0_0 = parse(np.__version__) < parse('2.0.0.dev0')
+
+# With NumPy 2.0.0, `copy=False` now raises a ValueError if the copy cannot be
+# made. The previous behavior to only copy if needed is provided with `copy=None`.
+# During the transition period, use this symbol instead.
+# Remove once NumPy 2.0.0 is the minimal required version.
+# https://numpy.org/devdocs/release/2.0.0-notes.html#new-copy-keyword-meaning-for-array-and-asarray-constructors
+# https://github.com/numpy/numpy/pull/25168
+NP_COPY_IF_NEEDED = False if NUMPY_LT_2_0_0 else None
+
+
+SCIPY_LT_1_12 = parse(sp.__version__) < parse('1.12')
+
+# Starting in SciPy v1.12, 'scipy.sparse.linalg.cg' keyword argument `tol` is
+# deprecated in favor of `rtol`.
+SCIPY_CG_TOL_PARAM_NAME = "tol" if SCIPY_LT_1_12 else "rtol"
+
+SCIPY_GE_1_17_0_DEV0 = parse('1.17.0.dev0') <= parse(sp.__version__)

envs/kitoverlay/skimage/_shared/dtype.py

@@ -0,0 +1,73 @@
+import numpy as np
+
+# Define classes of supported dtypes and Python scalar types
+# Variables ending in `_dtypes` only contain numpy.dtypes of the respective
+# class; variables ending in `_types` additionally include Python scalar types.
+signed_integer_dtypes = {np.int8, np.int16, np.int32, np.int64}
+signed_integer_types = signed_integer_dtypes | {int}
+
+unsigned_integer_dtypes = {np.uint8, np.uint16, np.uint32, np.uint64}
+
+integer_dtypes = signed_integer_dtypes | unsigned_integer_dtypes
+integer_types = signed_integer_types | unsigned_integer_dtypes
+
+floating_dtypes = {np.float16, np.float32, np.float64}
+floating_types = floating_dtypes | {float}
+
+complex_dtypes = {np.complex64, np.complex128}
+complex_types = complex_dtypes | {complex}
+
+inexact_dtypes = floating_dtypes | complex_dtypes
+inexact_types = floating_types | complex_types
+
+bool_types = {np.dtype(bool), bool}
+
+numeric_dtypes = integer_dtypes | inexact_dtypes | {np.bool_}
+numeric_types = integer_types | inexact_types | bool_types
+
+
+def numeric_dtype_min_max(dtype):
+    """Return minimum and maximum representable value for a given dtype.
+
+    A convenient wrapper around `numpy.finfo` and `numpy.iinfo` that
+    additionally supports numpy.bool as well.
+
+    Parameters
+    ----------
+    dtype : numpy.dtype
+        The dtype. Tries to convert Python "types" such as int or float, to
+        the corresponding NumPy dtype.
+
+    Returns
+    -------
+    min, max : number
+        Minimum and maximum of the given `dtype`. These scalars are themselves
+        of the given `dtype`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> numeric_dtype_min_max(np.uint8)
+    (0, 255)
+    >>> numeric_dtype_min_max(bool)
+    (False, True)
+    >>> numeric_dtype_min_max(np.float64)
+    (-1.7976931348623157e+308, 1.7976931348623157e+308)
+    >>> numeric_dtype_min_max(int)
+    (-9223372036854775808, 9223372036854775807)
+    """
+    dtype = np.dtype(dtype)
+    if np.issubdtype(dtype, np.integer):
+        info = np.iinfo(dtype)
+        min_ = dtype.type(info.min)
+        max_ = dtype.type(info.max)
+    elif np.issubdtype(dtype, np.inexact):
+        info = np.finfo(dtype)
+        min_ = info.min
+        max_ = info.max
+    elif np.issubdtype(dtype, np.dtype(bool)):
+        min_ = dtype.type(False)
+        max_ = dtype.type(True)
+    else:
+        raise ValueError(f"unsupported dtype {dtype!r}")
+    return min_, max_

envs/kitoverlay/skimage/_shared/fast_exp.h

@@ -0,0 +1,47 @@
+/* A fast approximation of the exponential function.
+ * Reference [1]: https://schraudolph.org/pubs/Schraudolph99.pdf
+ * Reference [2]: https://doi.org/10.1162/089976600300015033
+ * Additional improvements by Leonid Bloch. */
+
+#include <stdint.h>
+
+/* use just EXP_A = 1512775 for integer version, to avoid FP calculations */
+#define EXP_A (1512775.3951951856938)  /* 2^20/ln2 */
+/* For min. RMS error */
+#define EXP_BC 1072632447              /* 1023*2^20 - 60801 */
+/* For min. max. relative error */
+/* #define EXP_BC 1072647449 */        /* 1023*2^20 - 45799 */
+/* For min. mean relative error */
+/* #define EXP_BC 1072625005 */        /* 1023*2^20 - 68243 */
+
+__inline double _fast_exp (double y)
+{
+    union
+    {
+        double d;
+        struct { int32_t i, j; } n;
+        char t[8];
+    } _eco;
+
+    _eco.n.i = 1;
+
+    switch(_eco.t[0]) {
+        case 1:
+            /* Little endian */
+            _eco.n.j = (int32_t)(EXP_A*(y)) + EXP_BC;
+            _eco.n.i = 0;
+            break;
+        case 0:
+            /* Big endian */
+            _eco.n.i = (int32_t)(EXP_A*(y)) + EXP_BC;
+            _eco.n.j = 0;
+            break;
+    }
+
+    return _eco.d;
+}
+
+__inline float _fast_expf (float y)
+{
+  return (float)_fast_exp((double)y);
+}

envs/kitoverlay/skimage/_shared/filters.py

@@ -0,0 +1,136 @@
+"""Filters used across multiple skimage submodules.
+
+These are defined here to avoid circular imports.
+
+The unit tests remain under skimage/filters/tests/
+"""
+
+from collections.abc import Iterable
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from .._shared.utils import (
+    _supported_float_type,
+    convert_to_float,
+)
+
+
+def gaussian(
+    image,
+    sigma=1.0,
+    *,
+    mode='nearest',
+    cval=0,
+    preserve_range=False,
+    truncate=4.0,
+    channel_axis=None,
+    out=None,
+):
+    """Multi-dimensional Gaussian filter.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image (grayscale or color) to filter.
+    sigma : scalar or sequence of scalars, optional
+        Standard deviation for Gaussian kernel. The standard
+        deviations of the Gaussian filter are given for each axis as a
+        sequence, or as a single number, in which case it is equal for
+        all axes.
+    mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional
+        The ``mode`` parameter determines how the array borders are
+        handled, where ``cval`` is the value when mode is equal to
+        'constant'. Default is 'nearest'.
+    cval : scalar, optional
+        Value to fill past edges of input if ``mode`` is 'constant'. Default
+        is 0.0
+    preserve_range : bool, optional
+        If True, keep the original range of values. Otherwise, the input
+        ``image`` is converted according to the conventions of ``img_as_float``
+        (Normalized first to values [-1.0 ; 1.0] or [0 ; 1.0] depending on
+        dtype of input)
+
+        For more information, see:
+        https://scikit-image.org/docs/dev/user_guide/data_types.html
+    truncate : float, optional
+        Truncate the filter at this many standard deviations.
+    channel_axis : int or None, optional
+        If None, the image is assumed to be a grayscale (single channel) image.
+        Otherwise, this parameter indicates which axis of the array corresponds
+        to channels.
+
+        .. versionadded:: 0.19
+           `channel_axis` was added in 0.19.
+    out : ndarray, optional
+        If given, the filtered image will be stored in this array.
+
+        .. versionadded:: 0.23
+            `out` was added in 0.23.
+
+    Returns
+    -------
+    filtered_image : ndarray
+        the filtered array
+
+    Notes
+    -----
+    This function is a wrapper around :func:`scipy.ndimage.gaussian_filter`.
+
+    Integer arrays are converted to float.
+
+    `out` should be of floating-point data type since `gaussian` converts the
+    input `image` to float. If `out` is not provided, another array
+    will be allocated and returned as the result.
+
+    The multi-dimensional filter is implemented as a sequence of
+    one-dimensional convolution filters. The intermediate arrays are
+    stored in the same data type as the output. Therefore, for output
+    types with a limited precision, the results may be imprecise
+    because intermediate results may be stored with insufficient
+    precision.
+
+    Examples
+    --------
+    >>> import skimage as ski
+    >>> a = np.zeros((3, 3))
+    >>> a[1, 1] = 1
+    >>> a
+    array([[0., 0., 0.],
+           [0., 1., 0.],
+           [0., 0., 0.]])
+    >>> ski.filters.gaussian(a, sigma=0.4)  # mild smoothing
+    array([[0.00163116, 0.03712502, 0.00163116],
+           [0.03712502, 0.84496158, 0.03712502],
+           [0.00163116, 0.03712502, 0.00163116]])
+    >>> ski.filters.gaussian(a, sigma=1)  # more smoothing
+    array([[0.05855018, 0.09653293, 0.05855018],
+           [0.09653293, 0.15915589, 0.09653293],
+           [0.05855018, 0.09653293, 0.05855018]])
+    >>> # Several modes are possible for handling boundaries
+    >>> ski.filters.gaussian(a, sigma=1, mode='reflect')
+    array([[0.08767308, 0.12075024, 0.08767308],
+           [0.12075024, 0.16630671, 0.12075024],
+           [0.08767308, 0.12075024, 0.08767308]])
+    >>> # For RGB images, each is filtered separately
+    >>> image = ski.data.astronaut()
+    >>> filtered_img = ski.filters.gaussian(image, sigma=1, channel_axis=-1)
+
+    """
+    if np.any(np.asarray(sigma) < 0.0):
+        raise ValueError("Sigma values less than zero are not valid")
+    if channel_axis is not None:
+        # do not filter across channels
+        if not isinstance(sigma, Iterable):
+            sigma = [sigma] * (image.ndim - 1)
+        if len(sigma) == image.ndim - 1:
+            sigma = list(sigma)
+            sigma.insert(channel_axis % image.ndim, 0)
+    image = convert_to_float(image, preserve_range)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+    if (out is not None) and (not np.issubdtype(out.dtype, np.floating)):
+        raise ValueError(f"dtype of `out` must be float; got {out.dtype!r}.")
+    return ndi.gaussian_filter(
+        image, sigma, output=out, mode=mode, cval=cval, truncate=truncate
+    )

envs/kitoverlay/skimage/_shared/testing.py

@@ -0,0 +1,327 @@
+"""
+Testing utilities.
+"""
+
+import os
+import platform
+import re
+import struct
+import sys
+import functools
+import inspect
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+from numpy import testing
+from numpy.testing import (
+    TestCase,
+    assert_,
+    assert_warns,
+    assert_no_warnings,
+    assert_equal,
+    assert_almost_equal,
+    assert_array_equal,
+    assert_allclose,
+    assert_array_almost_equal,
+    assert_array_almost_equal_nulp,
+    assert_array_less,
+)
+
+from .. import data, io
+from ..data._fetchers import _fetch
+from ..util import img_as_uint, img_as_float, img_as_int, img_as_ubyte
+from ._warnings import expected_warnings
+from ._dependency_checks import is_wasm
+
+import pytest
+
+
+skipif = pytest.mark.skipif
+xfail = pytest.mark.xfail
+parametrize = pytest.mark.parametrize
+raises = pytest.raises
+fixture = pytest.fixture
+
+SKIP_RE = re.compile(r"(\s*>>>.*?)(\s*)#\s*skip\s+if\s+(.*)$")
+
+# true if python is running in 32bit mode
+# Calculate the size of a void * pointer in bits
+# https://docs.python.org/3/library/struct.html
+arch32 = struct.calcsize("P") * 8 == 32
+
+
+def assert_less(a, b, msg=None):
+    message = f"{a!r} is not lower than {b!r}"
+    if msg is not None:
+        message += ": " + msg
+    assert a < b, message
+
+
+def assert_greater(a, b, msg=None):
+    message = f"{a!r} is not greater than {b!r}"
+    if msg is not None:
+        message += ": " + msg
+    assert a > b, message
+
+
+def doctest_skip_parser(func):
+    """Decorator replaces custom skip test markup in doctests
+
+    Say a function has a docstring::
+
+        >>> something, HAVE_AMODULE, HAVE_BMODULE = 0, False, False
+        >>> something # skip if not HAVE_AMODULE
+        0
+        >>> something # skip if HAVE_BMODULE
+        0
+
+    This decorator will evaluate the expression after ``skip if``.  If this
+    evaluates to True, then the comment is replaced by ``# doctest: +SKIP``. If
+    False, then the comment is just removed. The expression is evaluated in the
+    ``globals`` scope of `func`.
+
+    For example, if the module global ``HAVE_AMODULE`` is False, and module
+    global ``HAVE_BMODULE`` is False, the returned function will have docstring::
+
+        >>> something # doctest: +SKIP
+        >>> something + else # doctest: +SKIP
+        >>> something # doctest: +SKIP
+
+    """
+    lines = func.__doc__.split('\n')
+    new_lines = []
+    for line in lines:
+        match = SKIP_RE.match(line)
+        if match is None:
+            new_lines.append(line)
+            continue
+        code, space, expr = match.groups()
+
+        try:
+            # Works as a function decorator
+            if eval(expr, func.__globals__):
+                code = code + space + "# doctest: +SKIP"
+        except AttributeError:
+            # Works as a class decorator
+            if eval(expr, func.__init__.__globals__):
+                code = code + space + "# doctest: +SKIP"
+
+        new_lines.append(code)
+    func.__doc__ = "\n".join(new_lines)
+    return func
+
+
+def roundtrip(image, plugin, suffix):
+    """Save and read an image using a specified plugin"""
+    if '.' not in suffix:
+        suffix = '.' + suffix
+    with NamedTemporaryFile(suffix=suffix, delete=False) as temp_file:
+        fname = temp_file.name
+    io.imsave(fname, image, plugin=plugin)
+    new = io.imread(fname, plugin=plugin)
+    try:
+        os.remove(fname)
+    except Exception:
+        pass
+    return new
+
+
+def color_check(plugin, fmt='png'):
+    """Check roundtrip behavior for color images.
+
+    All major input types should be handled as ubytes and read
+    back correctly.
+    """
+    img = img_as_ubyte(data.chelsea())
+    r1 = roundtrip(img, plugin, fmt)
+    testing.assert_allclose(img, r1)
+
+    img2 = img > 128
+    r2 = roundtrip(img2, plugin, fmt)
+    testing.assert_allclose(img2, r2.astype(bool))
+
+    img3 = img_as_float(img)
+    r3 = roundtrip(img3, plugin, fmt)
+    testing.assert_allclose(r3, img)
+
+    img4 = img_as_int(img)
+    if fmt.lower() in (('tif', 'tiff')):
+        img4 -= 100
+        r4 = roundtrip(img4, plugin, fmt)
+        testing.assert_allclose(r4, img4)
+    else:
+        r4 = roundtrip(img4, plugin, fmt)
+        testing.assert_allclose(r4, img_as_ubyte(img4))
+
+    img5 = img_as_uint(img)
+    r5 = roundtrip(img5, plugin, fmt)
+    testing.assert_allclose(r5, img)
+
+
+def mono_check(plugin, fmt='png'):
+    """Check the roundtrip behavior for images that support most types.
+
+    All major input types should be handled.
+    """
+
+    img = img_as_ubyte(data.moon())
+    r1 = roundtrip(img, plugin, fmt)
+    testing.assert_allclose(img, r1)
+
+    img2 = img > 128
+    r2 = roundtrip(img2, plugin, fmt)
+    testing.assert_allclose(img2, r2.astype(bool))
+
+    img3 = img_as_float(img)
+    r3 = roundtrip(img3, plugin, fmt)
+    if r3.dtype.kind == 'f':
+        testing.assert_allclose(img3, r3)
+    else:
+        testing.assert_allclose(r3, img_as_uint(img))
+
+    img4 = img_as_int(img)
+    if fmt.lower() in (('tif', 'tiff')):
+        img4 -= 100
+        r4 = roundtrip(img4, plugin, fmt)
+        testing.assert_allclose(r4, img4)
+    else:
+        r4 = roundtrip(img4, plugin, fmt)
+        testing.assert_allclose(r4, img_as_uint(img4))
+
+    img5 = img_as_uint(img)
+    r5 = roundtrip(img5, plugin, fmt)
+    testing.assert_allclose(r5, img5)
+
+
+def fetch(data_filename, prefix=None):
+    """Attempt to fetch data, but if unavailable, skip the tests.
+
+    Parameters
+    ----------
+    data_filename : str
+        File path in the scikit-image repo tree, e.g.,
+        'restoration/camera_rl.npy', possibly pointing to a remote location.
+
+    prefix : str, optional
+        If None, `data_filename` is prefixed by 'src/skimage'
+        If 'tests', `data_filename` is prefixed by 'tests/skimage'.
+
+    Returns
+    -------
+    file_path : str
+        Path of the local file, possibly pointing to a remote location.
+
+    """
+    try:
+        return _fetch(data_filename, prefix=prefix)
+    except (ConnectionError, ModuleNotFoundError):
+        pytest.skip(f'Unable to download {data_filename}', allow_module_level=True)
+
+
+# Ref: about the lack of threading support in WASM, please see
+# https://github.com/pyodide/pyodide/issues/237
+def run_in_parallel(workers=2, warnings_matching=None):
+    """Decorator to run the same function multiple times in parallel.
+
+    This decorator is useful to ensure that separate threads execute
+    concurrently and correctly while releasing the GIL.
+
+    It is currently skipped when running on WASM-based platforms, as
+    the threading module is not supported.
+
+    Parameters
+    ----------
+    workers : int, optional
+        The number of times the function is run in parallel.
+    warnings_matching : list or None
+        This parameter is passed on to `expected_warnings` so as not to have
+        race conditions with the warnings filters. A single
+        `expected_warnings` context manager is used for all threads.
+        If None, then no warnings are checked.
+
+    """
+
+    assert workers > 0
+
+    def wrapper(func):
+        if is_wasm:
+            # Threading isn't supported on WASM, return early
+            return func
+
+        import threading
+
+        @functools.wraps(func)
+        def inner(*args, **kwargs):
+            with expected_warnings(warnings_matching):
+                threads = []
+                for i in range(workers - 1):
+                    thread = threading.Thread(target=func, args=args, kwargs=kwargs)
+                    threads.append(thread)
+                for thread in threads:
+                    thread.start()
+
+                func(*args, **kwargs)
+
+                for thread in threads:
+                    thread.join()
+
+        return inner
+
+    return wrapper
+
+
+def assert_stacklevel(warnings, *, offset=-1):
+    """Assert correct stacklevel of captured warnings.
+
+    When scikit-image raises warnings, the stacklevel should ideally be set
+    so that the origin of the warnings will point to the public function
+    that was called by the user and not necessarily the very place where the
+    warnings were emitted (which may be inside some internal function).
+    This utility function helps with checking that
+    the stacklevel was set correctly on warnings captured by `pytest.warns`.
+
+    Parameters
+    ----------
+    warnings : collections.abc.Iterable[warning.WarningMessage]
+        Warnings that were captured by `pytest.warns`.
+    offset : int, optional
+        Offset from the line this function is called to the line were the
+        warning is supposed to originate from. For multiline calls, the
+        first line is relevant. Defaults to -1 which corresponds to the line
+        right above the one where this function is called.
+
+    Raises
+    ------
+    AssertionError
+        If a warning in `warnings` does not match the expected line number or
+        file name.
+
+    Examples
+    --------
+    >>> def test_something():
+    ...     with pytest.warns(UserWarning, match="some message") as record:
+    ...         something_raising_a_warning()
+    ...     assert_stacklevel(record)
+    ...
+    >>> def test_another_thing():
+    ...     with pytest.warns(UserWarning, match="some message") as record:
+    ...         iam_raising_many_warnings(
+    ...             "A long argument that forces the call to wrap."
+    ...         )
+    ...     assert_stacklevel(record, offset=-3)
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+
+    frame = inspect.stack()[1].frame  # 0 is current frame, 1 is outer frame
+    line_number = frame.f_lineno + offset
+    filename = frame.f_code.co_filename
+    expected = f"{filename}:{line_number}"
+    for warning in warnings:
+        actual = f"{warning.filename}:{warning.lineno}"
+        msg = (
+            "Warning with wrong stacklevel:\n"
+            f"  Expected: {expected}\n"
+            f"  Actual: {actual}\n"
+            f"  {warning.category.__name__}: {warning.message}"
+        )
+        assert actual == expected, msg

envs/kitoverlay/skimage/_shared/utils.py

@@ -0,0 +1,1099 @@
+import functools
+import inspect
+import sys
+import warnings
+from contextlib import contextmanager
+
+import numpy as np
+
+from ._warnings import all_warnings, warn
+
+__all__ = [
+    'deprecate_func',
+    'get_bound_method_class',
+    'all_warnings',
+    'safe_as_int',
+    'check_shape_equality',
+    'check_nD',
+    'warn',
+    'reshape_nd',
+    'identity',
+    'slice_at_axis',
+    "deprecate_parameter",
+    "DEPRECATED",
+]
+
+
+def count_inner_wrappers(func):
+    """Count the number of inner wrappers by unpacking ``__wrapped__``.
+
+    If a wrapped function wraps another wrapped function, then we refer to the
+    wrapping of the second function as an *inner wrapper*.
+
+    For example, consider this code fragment:
+
+    .. code-block:: python
+        @wrap_outer
+        @wrap_inner
+        def foo():
+            pass
+
+    Here ``@wrap_inner`` applies a wrapper to ``foo``, and ``@wrap_outer``
+    applies a wrapper to the result.
+
+    Parameters
+    ----------
+    func : callable
+        The callable of which to determine the number of inner wrappers.
+
+    Returns
+    -------
+    count : int
+        The number of times `func` has been wrapped.
+
+    See Also
+    --------
+    count_global_wrappers
+    """
+    unwrapped = func
+    count = 0
+    while hasattr(unwrapped, "__wrapped__"):
+        unwrapped = unwrapped.__wrapped__
+        count += 1
+    return count
+
+
+def _warning_stacklevel(func):
+    """Find stacklevel of `func` relative to its global representation.
+
+    Determine automatically with which stacklevel a warning should be raised.
+
+    Parameters
+    ----------
+    func : Callable
+        Tries to find the global version of `func` and counts the number of
+        additional wrappers around `func`.
+
+    Returns
+    -------
+    stacklevel : int
+        The stacklevel. Minimum of 2.
+    """
+    # Count number of wrappers around `func`
+    inner_wrapped_count = count_inner_wrappers(func)
+    global_wrapped_count = count_global_wrappers(func)
+
+    stacklevel = global_wrapped_count - inner_wrapped_count + 1
+    return max(stacklevel, 2)
+
+
+def count_global_wrappers(func):
+    """Count the total number of times a function as been wrapped globally.
+
+    Similar to :func:`count_inner_wrappers`, this counts the number of times
+    `func` has been wrapped. However, this function doesn't start counting
+    from `func` but instead tries to access the "global representation" of
+    `func`. This means that you could use this function from inside a wrapper
+    that was applied first, and still count wrappers that were applied on
+    top of it afterwards.
+
+    E.g., `func` might be wrapped by multiple decorators that emit
+    warnings. In that case, calling this function in the inner-most decorator
+    will still return the total count of wrappers.
+
+    Parameters
+    ----------
+    func : callable
+        The callable of which to determine the number of wrappers. Can be a
+        function or method of a class.
+
+    Returns
+    -------
+    count : int
+        The number of times `func` has been wrapped.
+
+    See Also
+    --------
+    count_inner_wrappers
+    """
+    if "<locals>" in func.__qualname__:
+        msg = (
+            "Cannot determine stacklevel of a function defined in another "
+            "function's local namespace. Set the stacklevel manually."
+        )
+        raise ValueError(msg)
+
+    first_name, *other = func.__qualname__.split(".")
+    global_func = func.__globals__.get(first_name, func)
+
+    # Account for `func` being a method, in which case it's an attribute of
+    # what we got from `func.__globals__`
+    for part in other:
+        global_func = getattr(global_func, part, global_func)
+
+    count = count_inner_wrappers(global_func)
+    assert count >= 0
+    return count
+
+
+class change_default_value:
+    """Decorator for changing the default value of an argument.
+
+    Parameters
+    ----------
+    arg_name : str
+        The name of the argument to be updated.
+    new_value : any
+        The argument new value.
+    changed_version : str
+        The package version in which the change will be introduced.
+    warning_msg : str
+        Optional warning message. If None, a generic warning message
+        is used.
+    stacklevel : {None, int}, optional
+        If None, the decorator attempts to detect the appropriate stacklevel for the
+        deprecation warning automatically. This can fail, e.g., due to
+        decorating a closure, in which case you can set the stacklevel manually
+        here. The outermost decorator should have stacklevel 2, the next inner
+        one stacklevel 3, etc.
+    """
+
+    def __init__(
+        self, arg_name, *, new_value, changed_version, warning_msg=None, stacklevel=None
+    ):
+        self.arg_name = arg_name
+        self.new_value = new_value
+        self.warning_msg = warning_msg
+        self.changed_version = changed_version
+        self.stacklevel = stacklevel
+
+    def __call__(self, func):
+        parameters = inspect.signature(func).parameters
+        arg_idx = list(parameters.keys()).index(self.arg_name)
+        old_value = parameters[self.arg_name].default
+
+        if self.warning_msg is None:
+            self.warning_msg = (
+                f'The new recommended value for {self.arg_name} is '
+                f'{self.new_value}. Until version {self.changed_version}, '
+                f'the default {self.arg_name} value is {old_value}. '
+                f'From version {self.changed_version}, the {self.arg_name} '
+                f'default value will be {self.new_value}. To avoid '
+                f'this warning, please explicitly set {self.arg_name} value.'
+            )
+
+        @functools.wraps(func)
+        def fixed_func(*args, **kwargs):
+            if len(args) < arg_idx + 1 and self.arg_name not in kwargs.keys():
+                stacklevel = (
+                    self.stacklevel
+                    if self.stacklevel is not None
+                    else _warning_stacklevel(func)
+                )
+                # warn that arg_name default value changed:
+                warnings.warn(self.warning_msg, FutureWarning, stacklevel=stacklevel)
+            return func(*args, **kwargs)
+
+        return fixed_func
+
+
+class PatchClassRepr(type):
+    """Control class representations in rendered signatures."""
+
+    def __repr__(cls):
+        return f"<{cls.__name__}>"
+
+
+class DEPRECATED(metaclass=PatchClassRepr):
+    """Signal value to help with deprecating parameters that use None.
+
+    This is a proxy object, used to signal that a parameter has not been set.
+    This is useful if ``None`` is already used for a different purpose or just
+    to highlight a deprecated parameter in the signature.
+    """
+
+
+class deprecate_parameter:
+    """Deprecate a parameter of a function.
+
+    Parameters
+    ----------
+    deprecated_name : str
+        The name of the deprecated parameter.
+    start_version : str
+        The package version in which the warning was introduced.
+    stop_version : str
+        The package version in which the warning will be replaced by
+        an error / the deprecation is completed.
+    template : str, optional
+        If given, this message template is used instead of the default one.
+    new_name : str, optional
+        If given, the default message will recommend the new parameter name and an
+        error will be raised if the user uses both old and new names for the
+        same parameter.
+    modify_docstring : bool, optional
+        If the wrapped function has a docstring, add the deprecated parameters
+        to the "Other Parameters" section.
+    stacklevel : {None, int}, optional
+        If None, the decorator attempts to detect the appropriate stacklevel for the
+        deprecation warning automatically. This can fail, e.g., due to
+        decorating a closure, in which case you can set the stacklevel manually
+        here. The outermost decorator should have stacklevel 2, the next inner
+        one stacklevel 3, etc.
+
+    Notes
+    -----
+    Assign `DEPRECATED` as the new default value for the deprecated parameter.
+    This marks the status of the parameter also in the signature and rendered
+    HTML docs.
+
+    This decorator can be stacked to deprecate more than one parameter.
+
+    Examples
+    --------
+    >>> from skimage._shared.utils import deprecate_parameter, DEPRECATED
+    >>> @deprecate_parameter(
+    ...     "b", new_name="c", start_version="0.1", stop_version="0.3"
+    ... )
+    ... def foo(a, b=DEPRECATED, *, c=None):
+    ...     return a, c
+
+    Calling ``foo(1, b=2)``  will warn with::
+
+        FutureWarning: Parameter `b` is deprecated since version 0.1 and will
+        be removed in 0.3 (or later). To avoid this warning, please use the
+        parameter `c` instead. For more details, see the documentation of
+        `foo`.
+    """
+
+    DEPRECATED = DEPRECATED  # Make signal value accessible for convenience
+
+    remove_parameter_template = (
+        "Parameter `{deprecated_name}` is deprecated since version "
+        "{deprecated_version} and will be removed in {changed_version} (or "
+        "later). To avoid this warning, please do not use the parameter "
+        "`{deprecated_name}`. For more details, see the documentation of "
+        "`{func_name}`."
+    )
+
+    replace_parameter_template = (
+        "Parameter `{deprecated_name}` is deprecated since version "
+        "{deprecated_version} and will be removed in {changed_version} (or "
+        "later). To avoid this warning, please use the parameter `{new_name}` "
+        "instead. For more details, see the documentation of `{func_name}`."
+    )
+
+    def __init__(
+        self,
+        deprecated_name,
+        *,
+        start_version,
+        stop_version,
+        template=None,
+        new_name=None,
+        modify_docstring=True,
+        stacklevel=None,
+    ):
+        self.deprecated_name = deprecated_name
+        self.new_name = new_name
+        self.template = template
+        self.start_version = start_version
+        self.stop_version = stop_version
+        self.modify_docstring = modify_docstring
+        self.stacklevel = stacklevel
+
+    def __call__(self, func):
+        parameters = inspect.signature(func).parameters
+        try:
+            deprecated_idx = list(parameters.keys()).index(self.deprecated_name)
+        except ValueError as e:
+            raise ValueError(f"{self.deprecated_name!r} not in parameters") from e
+
+        new_idx = False
+        if self.new_name:
+            try:
+                new_idx = list(parameters.keys()).index(self.new_name)
+            except ValueError as e:
+                raise ValueError(f"{self.new_name!r} not in parameters") from e
+
+        if parameters[self.deprecated_name].default is not DEPRECATED:
+            raise RuntimeError(
+                f"Expected `{self.deprecated_name}` to have the value {DEPRECATED!r} "
+                f"to indicate its status in the rendered signature."
+            )
+
+        if self.template is not None:
+            template = self.template
+        elif self.new_name is not None:
+            template = self.replace_parameter_template
+        else:
+            template = self.remove_parameter_template
+        warning_message = template.format(
+            deprecated_name=self.deprecated_name,
+            deprecated_version=self.start_version,
+            changed_version=self.stop_version,
+            func_name=func.__qualname__,
+            new_name=self.new_name,
+        )
+
+        @functools.wraps(func)
+        def fixed_func(*args, **kwargs):
+            deprecated_value = DEPRECATED
+            new_value = DEPRECATED
+
+            # Extract value of deprecated parameter
+            if len(args) > deprecated_idx:
+                deprecated_value = args[deprecated_idx]
+                # Overwrite old with DEPRECATED if replacement exists
+                if self.new_name is not None:
+                    args = (
+                        args[:deprecated_idx]
+                        + (DEPRECATED,)
+                        + args[deprecated_idx + 1 :]
+                    )
+            if self.deprecated_name in kwargs.keys():
+                deprecated_value = kwargs[self.deprecated_name]
+                # Overwrite old with DEPRECATED if replacement exists
+                if self.new_name is not None:
+                    kwargs[self.deprecated_name] = DEPRECATED
+
+            # Extract value of new parameter (if present)
+            if new_idx is not False and len(args) > new_idx:
+                new_value = args[new_idx]
+            if self.new_name and self.new_name in kwargs.keys():
+                new_value = kwargs[self.new_name]
+
+            if deprecated_value is not DEPRECATED:
+                stacklevel = (
+                    self.stacklevel
+                    if self.stacklevel is not None
+                    else _warning_stacklevel(func)
+                )
+                warnings.warn(
+                    warning_message, category=FutureWarning, stacklevel=stacklevel
+                )
+
+                if new_value is not DEPRECATED:
+                    raise ValueError(
+                        f"Both deprecated parameter `{self.deprecated_name}` "
+                        f"and new parameter `{self.new_name}` are used. Use "
+                        f"only the latter to avoid conflicting values."
+                    )
+                elif self.new_name is not None:
+                    # Assign old value to new one
+                    kwargs[self.new_name] = deprecated_value
+
+            return func(*args, **kwargs)
+
+        if self.modify_docstring and func.__doc__ is not None:
+            newdoc = _docstring_add_deprecated(
+                func, {self.deprecated_name: self.new_name}, self.start_version
+            )
+            fixed_func.__doc__ = newdoc
+
+        return fixed_func
+
+
+def _docstring_add_deprecated(func, kwarg_mapping, deprecated_version):
+    """Add deprecated kwarg(s) to the "Other Params" section of a docstring.
+
+    Parameters
+    ----------
+    func : function
+        The function whose docstring we wish to update.
+    kwarg_mapping : dict
+        A dict containing {old_arg: new_arg} key/value pairs, see
+        `deprecate_parameter`.
+    deprecated_version : str
+        A major.minor version string specifying when old_arg was
+        deprecated.
+
+    Returns
+    -------
+    new_doc : str
+        The updated docstring. Returns the original docstring if numpydoc is
+        not available.
+    """
+    if func.__doc__ is None:
+        return None
+    try:
+        from numpydoc.docscrape import FunctionDoc, Parameter
+    except ImportError:
+        # Return an unmodified docstring if numpydoc is not available.
+        return func.__doc__
+
+    Doc = FunctionDoc(func)
+    for old_arg, new_arg in kwarg_mapping.items():
+        desc = []
+        if new_arg is None:
+            desc.append(f'`{old_arg}` is deprecated.')
+        else:
+            desc.append(f'Deprecated in favor of `{new_arg}`.')
+
+        desc += ['', f'.. deprecated:: {deprecated_version}']
+        Doc['Other Parameters'].append(
+            Parameter(name=old_arg, type='DEPRECATED', desc=desc)
+        )
+    new_docstring = str(Doc)
+
+    # new_docstring will have a header starting with:
+    #
+    # .. function:: func.__name__
+    #
+    # and some additional blank lines. We strip these off below.
+    split = new_docstring.split('\n')
+    no_header = split[1:]
+    while not no_header[0].strip():
+        no_header.pop(0)
+
+    # Store the initial description before any of the Parameters fields.
+    # Usually this is a single line, but the while loop covers any case
+    # where it is not.
+    descr = no_header.pop(0)
+    while no_header[0].strip():
+        descr += '\n    ' + no_header.pop(0)
+    descr += '\n\n'
+    # '\n    ' rather than '\n' here to restore the original indentation.
+    final_docstring = descr + '\n    '.join(no_header)
+    # strip any extra spaces from ends of lines
+    final_docstring = '\n'.join([line.rstrip() for line in final_docstring.split('\n')])
+    return final_docstring
+
+
+class FailedEstimationAccessError(AttributeError):
+    """Error from use of failed estimation instance
+
+    This error arises from attempts to use an instance of
+    :class:`FailedEstimation`.
+    """
+
+
+class FailedEstimation:
+    """Class to indicate a failed transform estimation.
+
+    The ``from_estimate`` class method of each transform type may return an
+    instance of this class to indicate some failure in the estimation process.
+
+    Parameters
+    ----------
+    message : str
+        Message indicating reason for failed estimation.
+
+    Attributes
+    ----------
+    message : str
+        Message above.
+
+    Raises
+    ------
+    FailedEstimationAccessError
+        Exception raised for missing attributes or if the instance is used as a
+        callable.
+    """
+
+    error_cls = FailedEstimationAccessError
+
+    hint = (
+        "You can check for a failed estimation by truth testing the returned "
+        "object. For failed estimations, `bool(estimation_result)` will be `False`. "
+        "E.g.\n\n"
+        "    if not estimation_result:\n"
+        "        raise RuntimeError(f'Failed estimation: {estimation_result}')"
+    )
+
+    def __init__(self, message):
+        self.message = message
+
+    def __bool__(self):
+        return False
+
+    def __repr__(self):
+        return f"{type(self).__name__}({self.message!r})"
+
+    def __str__(self):
+        return self.message
+
+    def __call__(self, *args, **kwargs):
+        msg = (
+            f'{type(self).__name__} is not callable. {self.message}\n\n'
+            f'Hint: {self.hint}'
+        )
+        raise self.error_cls(msg)
+
+    def __getattr__(self, name):
+        msg = (
+            f'{type(self).__name__} has no attribute {name!r}. {self.message}\n\n'
+            f'Hint: {self.hint}'
+        )
+        raise self.error_cls(msg)
+
+
+@contextmanager
+def _ignore_deprecated_estimate_warning():
+    """Filter warnings about the deprecated `estimate` method.
+
+    Use either as decorator or context manager.
+    """
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            action="ignore",
+            category=FutureWarning,
+            message="`estimate` is deprecated",
+            module="skimage",
+        )
+        yield
+
+
+class channel_as_last_axis:
+    """Decorator for automatically making channels axis last for all arrays.
+
+    This decorator reorders axes for compatibility with functions that only
+    support channels along the last axis. After the function call is complete
+    the channels axis is restored back to its original position.
+
+    Parameters
+    ----------
+    channel_arg_positions : tuple of int, optional
+        Positional arguments at the positions specified in this tuple are
+        assumed to be multichannel arrays. The default is to assume only the
+        first argument to the function is a multichannel array.
+    channel_kwarg_names : tuple of str, optional
+        A tuple containing the names of any keyword arguments corresponding to
+        multichannel arrays.
+    multichannel_output : bool, optional
+        A boolean that should be True if the output of the function is not a
+        multichannel array and False otherwise. This decorator does not
+        currently support the general case of functions with multiple outputs
+        where some or all are multichannel.
+
+    """
+
+    def __init__(
+        self,
+        channel_arg_positions=(0,),
+        channel_kwarg_names=(),
+        multichannel_output=True,
+    ):
+        self.arg_positions = set(channel_arg_positions)
+        self.kwarg_names = set(channel_kwarg_names)
+        self.multichannel_output = multichannel_output
+
+    def __call__(self, func):
+        @functools.wraps(func)
+        def fixed_func(*args, **kwargs):
+            channel_axis = kwargs.get('channel_axis', None)
+
+            if channel_axis is None:
+                return func(*args, **kwargs)
+
+            # TODO: convert scalars to a tuple in anticipation of eventually
+            #       supporting a tuple of channel axes. Right now, only an
+            #       integer or a single-element tuple is supported, though.
+            if np.isscalar(channel_axis):
+                channel_axis = (channel_axis,)
+            if len(channel_axis) > 1:
+                raise ValueError("only a single channel axis is currently supported")
+
+            if channel_axis == (-1,) or channel_axis == -1:
+                return func(*args, **kwargs)
+
+            if self.arg_positions:
+                new_args = []
+                for pos, arg in enumerate(args):
+                    if pos in self.arg_positions:
+                        new_args.append(np.moveaxis(arg, channel_axis[0], -1))
+                    else:
+                        new_args.append(arg)
+                new_args = tuple(new_args)
+            else:
+                new_args = args
+
+            for name in self.kwarg_names:
+                kwargs[name] = np.moveaxis(kwargs[name], channel_axis[0], -1)
+
+            # now that we have moved the channels axis to the last position,
+            # change the channel_axis argument to -1
+            kwargs["channel_axis"] = -1
+
+            # Call the function with the fixed arguments
+            out = func(*new_args, **kwargs)
+            if self.multichannel_output:
+                out = np.moveaxis(out, -1, channel_axis[0])
+            return out
+
+        return fixed_func
+
+
+class deprecate_func:
+    """Decorate a deprecated function and warn when it is called.
+
+    Adapted from <http://wiki.python.org/moin/PythonDecoratorLibrary>.
+
+    Parameters
+    ----------
+    deprecated_version : str
+        The package version when the deprecation was introduced.
+    removed_version : str
+        The package version in which the deprecated function will be removed.
+    hint : str, optional
+        A hint on how to address this deprecation,
+        e.g., "Use `skimage.submodule.alternative_func` instead."
+    stacklevel :  {None, int}, optional
+        If None, the decorator attempts to detect the appropriate stacklevel for the
+        deprecation warning automatically. This can fail, e.g., due to
+        decorating a closure, in which case you can set the stacklevel manually
+        here. The outermost decorator should have stacklevel 2, the next inner
+        one stacklevel 3, etc.
+
+    Examples
+    --------
+    >>> @deprecate_func(
+    ...     deprecated_version="1.0.0",
+    ...     removed_version="1.2.0",
+    ...     hint="Use `bar` instead."
+    ... )
+    ... def foo():
+    ...     pass
+
+    Calling ``foo`` will warn with::
+
+        FutureWarning: `foo` is deprecated since version 1.0.0
+        and will be removed in version 1.2.0. Use `bar` instead.
+    """
+
+    def __init__(
+        self, *, deprecated_version, removed_version=None, hint=None, stacklevel=None
+    ):
+        self.deprecated_version = deprecated_version
+        self.removed_version = removed_version
+        self.hint = hint
+        self.stacklevel = stacklevel
+
+    def __call__(self, func):
+        message = (
+            f"`{func.__name__}` is deprecated since version {self.deprecated_version}"
+        )
+        if self.removed_version:
+            message += f" and will be removed in version {self.removed_version}."
+        if self.hint:
+            # Prepend space and make sure it closes with "."
+            message += f" {self.hint.rstrip('.')}."
+
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            stacklevel = (
+                self.stacklevel
+                if self.stacklevel is not None
+                else _warning_stacklevel(func)
+            )
+            warnings.warn(message, category=FutureWarning, stacklevel=stacklevel)
+            return func(*args, **kwargs)
+
+        # modify docstring to display deprecation warning
+        doc = f'**Deprecated:** {message}'
+        if wrapped.__doc__ is None:
+            wrapped.__doc__ = doc
+        else:
+            wrapped.__doc__ = doc + '\n\n    ' + wrapped.__doc__
+
+        return wrapped
+
+
+def _deprecate_estimate(func, class_name=None):
+    """Deprecate ``estimate`` method."""
+    class_name = func.__qualname__.split('.')[0] if class_name is None else class_name
+    return deprecate_func(
+        deprecated_version="0.26",
+        removed_version="2.2",
+        hint=f"Please use `{class_name}.from_estimate` class constructor instead.",
+        stacklevel=2,
+    )(func)
+
+
+def _deprecate_inherited_estimate(cls):
+    """Deprecate inherited ``estimate`` instance method.
+
+    This needs a class decorator so we can correctly specify the class of the
+    `from_estimate` class method in the deprecation message.
+    """
+
+    def estimate(self, *args, **kwargs):
+        return self._estimate(*args, **kwargs) is None
+
+    # The inherited method will always be wrapped by deprecator.
+    inherited_meth = getattr(cls, 'estimate').__wrapped__
+    estimate.__doc__ = inherited_meth.__doc__
+    estimate.__signature__ = inspect.signature(inherited_meth)
+
+    cls.estimate = _deprecate_estimate(estimate, cls.__name__)
+    return cls
+
+
+def _update_from_estimate_docstring(cls):
+    """Fix docstring for inherited ``from_estimate`` class method.
+
+    Even for classes that inherit the `from_estimate` method, and do not
+    override it, we nevertheless need to change the *docstring* of the
+    `from_estimate` method to point the user to the current (inheriting) class,
+    rather than the class in which the method is defined (the inherited class).
+
+    This needs a class decorator so we can modify the docstring of the new
+    class method.  CPython currently does not allow us to modify class method
+    docstrings by updating ``__doc__``.
+    """
+
+    inherited_cmeth = getattr(cls, 'from_estimate')
+
+    def from_estimate(cls, *args, **kwargs):
+        return inherited_cmeth(*args, **kwargs)
+
+    inherited_class_name = inherited_cmeth.__qualname__.split('.')[-2]
+
+    from_estimate.__doc__ = inherited_cmeth.__doc__.replace(
+        inherited_class_name, cls.__name__
+    )
+    from_estimate.__signature__ = inspect.signature(inherited_cmeth)
+
+    cls.from_estimate = classmethod(from_estimate)
+    return cls
+
+
+def get_bound_method_class(m):
+    """Return the class for a bound method."""
+    return m.im_class if sys.version < '3' else m.__self__.__class__
+
+
+def safe_as_int(val, atol=1e-3):
+    """
+    Attempt to safely cast values to integer format.
+
+    Parameters
+    ----------
+    val : scalar or iterable of scalars
+        Number or container of numbers which are intended to be interpreted as
+        integers, e.g., for indexing purposes, but which may not carry integer
+        type.
+    atol : float
+        Absolute tolerance away from nearest integer to consider values in
+        ``val`` functionally integers.
+
+    Returns
+    -------
+    val_int : NumPy scalar or ndarray of dtype `np.int64`
+        Returns the input value(s) coerced to dtype `np.int64` assuming all
+        were within ``atol`` of the nearest integer.
+
+    Notes
+    -----
+    This operation calculates ``val`` modulo 1, which returns the mantissa of
+    all values. Then all mantissas greater than 0.5 are subtracted from one.
+    Finally, the absolute tolerance from zero is calculated. If it is less
+    than ``atol`` for all value(s) in ``val``, they are rounded and returned
+    in an integer array. Or, if ``val`` was a scalar, a NumPy scalar type is
+    returned.
+
+    If any value(s) are outside the specified tolerance, an informative error
+    is raised.
+
+    Examples
+    --------
+    >>> safe_as_int(7.0)
+    7
+
+    >>> safe_as_int([9, 4, 2.9999999999])
+    array([9, 4, 3])
+
+    >>> safe_as_int(53.1)
+    Traceback (most recent call last):
+        ...
+    ValueError: Integer argument required but received 53.1, check inputs.
+
+    >>> safe_as_int(53.01, atol=0.01)
+    53
+
+    """
+    mod = np.asarray(val) % 1  # Extract mantissa
+
+    # Check for and subtract any mod values > 0.5 from 1
+    if mod.ndim == 0:  # Scalar input, cannot be indexed
+        if mod > 0.5:
+            mod = 1 - mod
+    else:  # Iterable input, now ndarray
+        mod[mod > 0.5] = 1 - mod[mod > 0.5]  # Test on each side of nearest int
+
+    if not np.allclose(mod, 0, atol=atol):
+        raise ValueError(f'Integer argument required but received {val}, check inputs.')
+
+    return np.round(val).astype(np.int64)
+
+
+def check_shape_equality(*images):
+    """Check that all images have the same shape"""
+    image0 = images[0]
+    if not all(image0.shape == image.shape for image in images[1:]):
+        raise ValueError('Input images must have the same dimensions.')
+    return
+
+
+def slice_at_axis(sl, axis):
+    """
+    Construct tuple of slices to slice an array in the given dimension.
+
+    Parameters
+    ----------
+    sl : slice
+        The slice for the given dimension.
+    axis : int
+        The axis to which `sl` is applied. All other dimensions are left
+        "unsliced".
+
+    Returns
+    -------
+    sl : tuple of slices
+        A tuple with slices matching `shape` in length.
+
+    Examples
+    --------
+    >>> slice_at_axis(slice(None, 3, -1), 1)
+    (slice(None, None, None), slice(None, 3, -1), Ellipsis)
+    """
+    return (slice(None),) * axis + (sl,) + (...,)
+
+
+def reshape_nd(arr, ndim, dim):
+    """Reshape a 1D array to have n dimensions, all singletons but one.
+
+    Parameters
+    ----------
+    arr : array, shape (N,)
+        Input array
+    ndim : int
+        Number of desired dimensions of reshaped array.
+    dim : int
+        Which dimension/axis will not be singleton-sized.
+
+    Returns
+    -------
+    arr_reshaped : array, shape ([1, ...], N, [1,...])
+        View of `arr` reshaped to the desired shape.
+
+    Examples
+    --------
+    >>> rng = np.random.default_rng()
+    >>> arr = rng.random(7)
+    >>> reshape_nd(arr, 2, 0).shape
+    (7, 1)
+    >>> reshape_nd(arr, 3, 1).shape
+    (1, 7, 1)
+    >>> reshape_nd(arr, 4, -1).shape
+    (1, 1, 1, 7)
+    """
+    if arr.ndim != 1:
+        raise ValueError("arr must be a 1D array")
+    new_shape = [1] * ndim
+    new_shape[dim] = -1
+    return np.reshape(arr, new_shape)
+
+
+def check_nD(array, ndim, arg_name='image'):
+    """
+    Verify an array meets the desired ndims and array isn't empty.
+
+    Parameters
+    ----------
+    array : array-like
+        Input array to be validated
+    ndim : int or iterable of ints
+        Allowable ndim or ndims for the array.
+    arg_name : str, optional
+        The name of the array in the original function.
+
+    """
+    array = np.asanyarray(array)
+    msg_incorrect_dim = "The parameter `%s` must be a %s-dimensional array"
+    msg_empty_array = "The parameter `%s` cannot be an empty array"
+    if isinstance(ndim, int):
+        ndim = [ndim]
+    if array.size == 0:
+        raise ValueError(msg_empty_array % (arg_name))
+    if array.ndim not in ndim:
+        raise ValueError(
+            msg_incorrect_dim % (arg_name, '-or-'.join([str(n) for n in ndim]))
+        )
+
+
+def convert_to_float(image, preserve_range):
+    """Convert input image to float image with the appropriate range.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    preserve_range : bool
+        Determines if the range of the image should be kept or transformed
+        using img_as_float. Also see
+        https://scikit-image.org/docs/dev/user_guide/data_types.html
+
+    Notes
+    -----
+    * Input images with `float32` data type are not upcast.
+
+    Returns
+    -------
+    image : ndarray
+        Transformed version of the input.
+
+    """
+    if image.dtype == np.float16:
+        return image.astype(np.float32)
+    if preserve_range:
+        # Convert image to double only if it is not single or double
+        # precision float
+        if image.dtype.char not in 'df':
+            image = image.astype(float)
+    else:
+        from ..util.dtype import img_as_float
+
+        image = img_as_float(image)
+    return image
+
+
+def _validate_interpolation_order(image_dtype, order):
+    """Validate and return spline interpolation's order.
+
+    Parameters
+    ----------
+    image_dtype : dtype
+        Image dtype.
+    order : {None, int}, optional
+        The order of the spline interpolation. The order has to be in the range
+        0-5. If ``None`` assume order 0 for Boolean images, otherwise 1. See
+        `skimage.transform.warp` for detail.
+
+    Returns
+    -------
+    order : int
+        if input order is None, returns 0 if image_dtype is bool and 1
+        otherwise. Otherwise, image_dtype is checked and input order
+        is validated accordingly (order > 0 is not supported for bool
+        image dtype)
+
+    """
+
+    if order is None:
+        return 0 if image_dtype == bool else 1
+
+    if order < 0 or order > 5:
+        raise ValueError("Spline interpolation order has to be in the range 0-5.")
+
+    if image_dtype == bool and order != 0:
+        raise ValueError(
+            "Input image dtype is bool. Interpolation is not defined "
+            "with bool data type. Please set order to 0 or explicitly "
+            "cast input image to another data type."
+        )
+
+    return order
+
+
+def _to_np_mode(mode):
+    """Convert padding modes from `ndi.correlate` to `np.pad`."""
+    mode_translation_dict = dict(nearest='edge', reflect='symmetric', mirror='reflect')
+    if mode in mode_translation_dict:
+        mode = mode_translation_dict[mode]
+    return mode
+
+
+def _to_ndimage_mode(mode):
+    """Convert from `numpy.pad` mode name to the corresponding ndimage mode."""
+    mode_translation_dict = dict(
+        constant='constant',
+        edge='nearest',
+        symmetric='reflect',
+        reflect='mirror',
+        wrap='wrap',
+    )
+    if mode not in mode_translation_dict:
+        raise ValueError(
+            f"Unknown mode: '{mode}', or cannot translate mode. The "
+            f"mode should be one of 'constant', 'edge', 'symmetric', "
+            f"'reflect', or 'wrap'. See the documentation of numpy.pad for "
+            f"more info."
+        )
+    return _fix_ndimage_mode(mode_translation_dict[mode])
+
+
+def _fix_ndimage_mode(mode):
+    # SciPy 1.6.0 introduced grid variants of constant and wrap which
+    # have less surprising behavior for images. Use these when available
+    grid_modes = {'constant': 'grid-constant', 'wrap': 'grid-wrap'}
+    return grid_modes.get(mode, mode)
+
+
+new_float_type = {
+    # preserved types
+    np.float32().dtype.char: np.float32,
+    np.float64().dtype.char: np.float64,
+    np.complex64().dtype.char: np.complex64,
+    np.complex128().dtype.char: np.complex128,
+    # altered types
+    np.float16().dtype.char: np.float32,
+    'g': np.float64,  # np.float128 ; doesn't exist on windows
+    'G': np.complex128,  # np.complex256 ; doesn't exist on windows
+}
+
+
+def _supported_float_type(input_dtype, allow_complex=False):
+    """Return an appropriate floating-point dtype for a given dtype.
+
+    float32, float64, complex64, complex128 are preserved.
+    float16 is promoted to float32.
+    complex256 is demoted to complex128.
+    Other types are cast to float64.
+
+    Parameters
+    ----------
+    input_dtype : np.dtype or tuple of np.dtype
+        The input dtype. If a tuple of multiple dtypes is provided, each
+        dtype is first converted to a supported floating point type and the
+        final dtype is then determined by applying `np.result_type` on the
+        sequence of supported floating point types.
+    allow_complex : bool, optional
+        If False, raise a ValueError on complex-valued inputs.
+
+    Returns
+    -------
+    float_type : dtype
+        Floating-point dtype for the image.
+    """
+    if isinstance(input_dtype, tuple):
+        return np.result_type(*(_supported_float_type(d) for d in input_dtype))
+    input_dtype = np.dtype(input_dtype)
+    if not allow_complex and input_dtype.kind == 'c':
+        raise ValueError("complex valued input is not supported")
+    return new_float_type.get(input_dtype.char, np.float64)
+
+
+def identity(image, *args, **kwargs):
+    """Returns the first argument unmodified."""
+    return image
+
+
+def as_binary_ndarray(array, *, variable_name):
+    """Return `array` as a numpy.ndarray of dtype bool.
+
+    Raises
+    ------
+    ValueError:
+        An error including the given `variable_name` if `array` can not be
+        safely cast to a boolean array.
+    """
+    array = np.asarray(array)
+    if array.dtype != bool:
+        if np.any((array != 1) & (array != 0)):
+            raise ValueError(
+                f"{variable_name} array is not of dtype boolean or "
+                f"contains values other than 0 and 1 so cannot be "
+                f"safely cast to boolean array."
+            )
+    return np.asarray(array, dtype=bool)

envs/kitoverlay/skimage/graph/__init__.py

@@ -0,0 +1,12 @@
+"""
+Graph-based operations, e.g., shortest paths.
+
+This includes creating adjacency graphs of pixels in an image, finding the
+central pixel in an image, finding (minimum-cost) paths across pixels, merging
+and cutting of graphs, etc.
+
+"""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/graph/__init__.pyi

@@ -0,0 +1,27 @@
+# Explicitly setting `__all__` is necessary for type inference engines
+# to know which symbols are exported. See
+# https://peps.python.org/pep-0484/#stub-files
+
+__all__ = [
+    'pixel_graph',
+    'central_pixel',
+    'shortest_path',
+    'MCP',
+    'MCP_Geometric',
+    'MCP_Connect',
+    'MCP_Flexible',
+    'route_through_array',
+    'rag_mean_color',
+    'rag_boundary',
+    'cut_threshold',
+    'cut_normalized',
+    'merge_hierarchical',
+    'RAG',
+]
+
+from ._graph import pixel_graph, central_pixel
+from ._graph_cut import cut_threshold, cut_normalized
+from ._graph_merge import merge_hierarchical
+from ._rag import rag_mean_color, RAG, show_rag, rag_boundary
+from .spath import shortest_path
+from .mcp import MCP, MCP_Geometric, MCP_Connect, MCP_Flexible, route_through_array

envs/kitoverlay/skimage/graph/_graph.py

@@ -0,0 +1,220 @@
+import numpy as np
+from scipy import sparse
+from scipy.sparse import csgraph
+from ..morphology._util import _raveled_offsets_and_distances
+from ..util._map_array import map_array
+from ..segmentation.random_walker_segmentation import _safe_downcast_indices
+
+
+def _weighted_abs_diff(values0, values1, distances):
+    """A default edge function for complete image graphs.
+
+    A pixel graph on an image with no edge values and no mask is a very
+    boring regular lattice, so we define a default edge weight to be the
+    absolute difference between values *weighted* by the distance
+    between them.
+
+    Parameters
+    ----------
+    values0 : array
+        The pixel values for each node.
+    values1 : array
+        The pixel values for each neighbor.
+    distances : array
+        The distance between each node and its neighbor.
+
+    Returns
+    -------
+    edge_values : array of float
+        The computed values: abs(values0 - values1) * distances.
+    """
+    return np.abs(values0 - values1) * distances
+
+
+def pixel_graph(
+    image,
+    *,
+    mask=None,
+    edge_function=None,
+    connectivity=1,
+    spacing=None,
+    sparse_type="matrix",
+):
+    """Create an adjacency graph of pixels in an image.
+
+    Pixels where the mask is True are nodes in the returned graph, and they are
+    connected by edges to their neighbors according to the connectivity
+    parameter. By default, the *value* of an edge when a mask is given, or when
+    the image is itself the mask, is the Euclidean distance between the pixels.
+
+    However, if an int- or float-valued image is given with no mask, the value
+    of the edges is the absolute difference in intensity between adjacent
+    pixels, weighted by the Euclidean distance.
+
+    Parameters
+    ----------
+    image : array
+        The input image. If the image is of type bool, it will be used as the
+        mask as well.
+    mask : array of bool
+        Which pixels to use. If None, the graph for the whole image is used.
+    edge_function : callable
+        A function taking an array of pixel values, and an array of neighbor
+        pixel values, and an array of distances, and returning a value for the
+        edge. If no function is given, the value of an edge is just the
+        distance.
+    connectivity : int
+        The square connectivity of the pixel neighborhood: the number of
+        orthogonal steps allowed to consider a pixel a neighbor. See
+        `scipy.ndimage.generate_binary_structure` for details.
+    spacing : tuple of float
+        The spacing between pixels along each axis.
+    sparse_type : {"matrix", "array"}, optional
+        The return type of `graph`, either `scipy.sparse.csr_array` or
+        `scipy.sparse.csr_matrix` (default).
+
+    Returns
+    -------
+    graph : scipy.sparse.csr_matrix or scipy.sparse.csr_array
+        A sparse adjacency matrix in which entry (i, j) is 1 if nodes i and j
+        are neighbors, 0 otherwise. Depending on `sparse_type`, this can be
+        returned as a `scipy.sparse.csr_array`.
+    nodes : array of int
+        The nodes of the graph. These correspond to the raveled indices of the
+        nonzero pixels in the mask.
+    """
+    if mask is None:
+        if image.dtype == bool:
+            mask = image
+        else:
+            mask = np.ones_like(image, dtype=bool)
+
+    if edge_function is None:
+        if image.dtype == bool:
+
+            def edge_function(x, y, distances):
+                return distances
+
+        else:
+            edge_function = _weighted_abs_diff
+
+    # Strategy: we are going to build the (i, j, data) arrays of a scipy
+    # sparse CSR matrix.
+    # - grab the raveled IDs of the foreground (mask == True) parts of the
+    #   image **in the padded space**.
+    # - broadcast them together with the raveled offsets to their neighbors.
+    #   This gives us for each foreground pixel a list of neighbors (that
+    #   may or may not be selected by the mask). (We also track the *distance*
+    #   to each neighbor.)
+    # - select "valid" entries in the neighbors and distance arrays by indexing
+    #   into the mask, which we can do since these are raveled indices.
+    # - use np.repeat() to repeat each source index according to the number
+    #   of neighbors selected by the mask it has. Each of these repeated
+    #   indices will be lined up with its neighbor, i.e. **this is the row_ind
+    #   array** of the CSR format matrix.
+    # - use the mask as a boolean index to get a 1D view of the selected
+    #   neighbors. **This is the col_ind array.**
+    # - by default, the same boolean indexing can be applied to the distances
+    #   to each neighbor, to give the **data array.** Optionally, a
+    #   provided edge function can be computed on the pixel values and the
+    #   distances to give a different value for the edges.
+    # Note, we use map_array to map the raveled coordinates in the padded
+    # image to the ones in the original image, and those are the returned
+    # nodes.
+    padded = np.pad(mask, 1, mode='constant', constant_values=False)
+    nodes_padded = np.flatnonzero(padded)
+    neighbor_offsets_padded, distances_padded = _raveled_offsets_and_distances(
+        padded.shape, connectivity=connectivity, spacing=spacing
+    )
+    neighbors_padded = nodes_padded[:, np.newaxis] + neighbor_offsets_padded
+    neighbor_distances_full = np.broadcast_to(distances_padded, neighbors_padded.shape)
+    nodes = np.flatnonzero(mask)
+    nodes_sequential = np.arange(nodes.size)
+    # neighbors outside the mask get mapped to 0, which is a valid index,
+    # BUT, they will be masked out in the next step.
+    neighbors = map_array(neighbors_padded, nodes_padded, nodes)
+    neighbors_mask = padded.reshape(-1)[neighbors_padded]
+    num_neighbors = np.sum(neighbors_mask, axis=1)
+    indices = np.repeat(nodes, num_neighbors)
+    indices_sequential = np.repeat(nodes_sequential, num_neighbors)
+    neighbor_indices = neighbors[neighbors_mask]
+    neighbor_distances = neighbor_distances_full[neighbors_mask]
+    neighbor_indices_sequential = map_array(neighbor_indices, nodes, nodes_sequential)
+
+    image_r = image.reshape(-1)
+    data = edge_function(
+        image_r[indices], image_r[neighbor_indices], neighbor_distances
+    )
+
+    m = nodes_sequential.size
+    graph = sparse.csr_array(
+        (data, (indices_sequential, neighbor_indices_sequential)), shape=(m, m)
+    )
+
+    if sparse_type == "matrix":
+        graph = sparse.csr_matrix(graph)
+    elif sparse_type != "array":
+        msg = f"`sparse_type` must be 'array' or 'matrix', got {sparse_type}"
+        raise ValueError(msg)
+
+    return graph, nodes
+
+
+def central_pixel(graph, nodes=None, shape=None, partition_size=100):
+    """Find the pixel with the highest closeness centrality.
+
+    Closeness centrality is the inverse of the total sum of shortest distances
+    from a node to every other node.
+
+    Parameters
+    ----------
+    graph : scipy.sparse.csr_array or scipy.sparse.csr_matrix
+        The sparse representation of the graph.
+    nodes : array of int
+        The raveled index of each node in graph in the image. If not provided,
+        the returned value will be the index in the input graph.
+    shape : tuple of int
+        The shape of the image in which the nodes are embedded. If provided,
+        the returned coordinates are a NumPy multi-index of the same
+        dimensionality as the input shape. Otherwise, the returned coordinate
+        is the raveled index provided in `nodes`.
+    partition_size : int
+        This function computes the shortest path distance between every pair
+        of nodes in the graph. This can result in a very large (N*N) matrix.
+        As a simple performance tweak, the distance values are computed in
+        lots of `partition_size`, resulting in a memory requirement of only
+        partition_size*N.
+
+    Returns
+    -------
+    position : int or tuple of int
+        If shape is given, the coordinate of the central pixel in the image.
+        Otherwise, the raveled index of that pixel.
+    distances : array of float
+        The total sum of distances from each node to each other reachable
+        node.
+    """
+    if nodes is None:
+        nodes = np.arange(graph.shape[0])
+    if partition_size is None:
+        num_splits = 1
+    else:
+        num_splits = max(2, graph.shape[0] // partition_size)
+    graph.indices, graph.indptr = _safe_downcast_indices(
+        graph, np.int32, 'index values too large for csgraph'
+    )
+    idxs = np.arange(graph.shape[0])
+    total_shortest_path_len_list = []
+    for partition in np.array_split(idxs, num_splits):
+        shortest_paths = csgraph.shortest_path(graph, directed=False, indices=partition)
+        shortest_paths_no_inf = np.nan_to_num(shortest_paths)
+        total_shortest_path_len_list.append(np.sum(shortest_paths_no_inf, axis=1))
+    total_shortest_path_len = np.concatenate(total_shortest_path_len_list)
+    nonzero = np.flatnonzero(total_shortest_path_len)
+    min_sp = np.argmin(total_shortest_path_len[nonzero])
+    raveled_index = nodes[nonzero[min_sp]]
+    if shape is not None:
+        central = np.unravel_index(raveled_index, shape)
+    else:
+        central = raveled_index
+    return central, total_shortest_path_len

envs/kitoverlay/skimage/graph/_graph_cut.py

@@ -0,0 +1,319 @@
+import networkx as nx
+import numpy as np
+from scipy.sparse import linalg
+
+from skimage._shared.compat import SCIPY_GE_1_17_0_DEV0
+from . import _ncut, _ncut_cy
+
+
+def cut_threshold(labels, rag, thresh, in_place=True):
+    """Combine regions separated by weight less than threshold.
+
+    Given an image's labels and its RAG, output new labels by
+    combining regions whose nodes are separated by a weight less
+    than the given threshold.
+
+    Parameters
+    ----------
+    labels : ndarray
+        The array of labels.
+    rag : RAG
+        The region adjacency graph.
+    thresh : float
+        The threshold. Regions connected by edges with smaller weights are
+        combined.
+    in_place : bool
+        If set, modifies `rag` in place. The function will remove the edges
+        with weights less that `thresh`. If set to `False` the function
+        makes a copy of `rag` before proceeding.
+
+    Returns
+    -------
+    out : ndarray
+        The new labelled array.
+
+    Examples
+    --------
+    >>> from skimage import data, segmentation, graph
+    >>> img = data.astronaut()
+    >>> labels = segmentation.slic(img)
+    >>> rag = graph.rag_mean_color(img, labels)
+    >>> new_labels = graph.cut_threshold(labels, rag, 10)
+
+    References
+    ----------
+    .. [1] Alain Tremeau and Philippe Colantoni
+           "Regions Adjacency Graph Applied To Color Image Segmentation"
+           :DOI:`10.1109/83.841950`
+
+    """
+    if not in_place:
+        rag = rag.copy()
+
+    # Because deleting edges while iterating through them produces an error.
+    to_remove = [(x, y) for x, y, d in rag.edges(data=True) if d['weight'] >= thresh]
+    rag.remove_edges_from(to_remove)
+
+    comps = nx.connected_components(rag)
+
+    # We construct an array which can map old labels to the new ones.
+    # All the labels within a connected component are assigned to a single
+    # label in the output.
+    map_array = np.arange(labels.max() + 1, dtype=labels.dtype)
+    for i, nodes in enumerate(comps):
+        for node in nodes:
+            for label in rag.nodes[node]['labels']:
+                map_array[label] = i
+
+    return map_array[labels]
+
+
+def cut_normalized(
+    labels,
+    rag,
+    thresh=0.001,
+    num_cuts=10,
+    in_place=True,
+    max_edge=1.0,
+    *,
+    rng=None,
+):
+    """Perform Normalized Graph cut on the Region Adjacency Graph.
+
+    Given an image's labels and its similarity RAG, recursively perform
+    a 2-way normalized cut on it. All nodes belonging to a subgraph
+    that cannot be cut further are assigned a unique label in the
+    output.
+
+    Parameters
+    ----------
+    labels : ndarray
+        The array of labels.
+    rag : RAG
+        The region adjacency graph.
+    thresh : float
+        The threshold. A subgraph won't be further subdivided if the
+        value of the N-cut exceeds `thresh`.
+    num_cuts : int
+        The number or N-cuts to perform before determining the optimal one.
+    in_place : bool
+        If set, modifies `rag` in place. For each node `n` the function will
+        set a new attribute ``rag.nodes[n]['ncut label']``.
+    max_edge : float, optional
+        The maximum possible value of an edge in the RAG. This corresponds to
+        an edge between identical regions. This is used to put self
+        edges in the RAG.
+    rng : {`numpy.random.Generator`, int}, optional
+        Pseudo-random number generator.
+        By default, a PCG64 generator is used (see :func:`numpy.random.default_rng`).
+        If `rng` is an int, it is used to seed the generator.
+
+        The `rng` is used to determine the starting point
+        of `scipy.sparse.linalg.eigsh`.
+
+    Returns
+    -------
+    out : ndarray
+        The new labeled array.
+
+    Examples
+    --------
+    >>> from skimage import data, segmentation, graph
+    >>> img = data.astronaut()
+    >>> labels = segmentation.slic(img)
+    >>> rag = graph.rag_mean_color(img, labels, mode='similarity')
+    >>> new_labels = graph.cut_normalized(labels, rag)
+
+    References
+    ----------
+    .. [1] Shi, J.; Malik, J., "Normalized cuts and image segmentation",
+           Pattern Analysis and Machine Intelligence,
+           IEEE Transactions on, vol. 22, no. 8, pp. 888-905, August 2000.
+
+    """
+    rng = np.random.default_rng(rng)
+    if not in_place:
+        rag = rag.copy()
+
+    for node in rag.nodes():
+        rag.add_edge(node, node, weight=max_edge)
+
+    _ncut_relabel(rag, thresh, num_cuts, rng)
+
+    map_array = np.zeros(labels.max() + 1, dtype=labels.dtype)
+    # Mapping from old labels to new
+    for n, d in rag.nodes(data=True):
+        map_array[d['labels']] = d['ncut label']
+
+    return map_array[labels]
+
+
+def partition_by_cut(cut, rag):
+    """Compute resulting subgraphs from given bi-partition.
+
+    Parameters
+    ----------
+    cut : array
+        A array of booleans. Elements set to `True` belong to one
+        set.
+    rag : RAG
+        The Region Adjacency Graph.
+
+    Returns
+    -------
+    sub1, sub2 : RAG
+        The two resulting subgraphs from the bi-partition.
+    """
+    # `cut` is derived from `D` and `W` matrices, which also follow the
+    # ordering returned by `rag.nodes()` because we use
+    # nx.to_scipy_sparse_array.
+
+    # Example
+    # rag.nodes() = [3, 7, 9, 13]
+    # cut = [True, False, True, False]
+    # nodes1 = [3, 9]
+    # nodes2 = [7, 10]
+
+    nodes1 = [n for i, n in enumerate(rag.nodes()) if cut[i]]
+    nodes2 = [n for i, n in enumerate(rag.nodes()) if not cut[i]]
+
+    sub1 = rag.subgraph(nodes1)
+    sub2 = rag.subgraph(nodes2)
+
+    return sub1, sub2
+
+
+def get_min_ncut(ev, d, w, num_cuts):
+    """Threshold an eigenvector evenly, to determine minimum ncut.
+
+    Parameters
+    ----------
+    ev : array
+        The eigenvector to threshold.
+    d : ndarray
+        The diagonal matrix of the graph.
+    w : ndarray
+        The weight matrix of the graph.
+    num_cuts : int
+        The number of evenly spaced thresholds to check for.
+
+    Returns
+    -------
+    mask : array
+        The array of booleans which denotes the bi-partition.
+    mcut : float
+        The value of the minimum ncut.
+    """
+    mcut = np.inf
+    mn = ev.min()
+    mx = ev.max()
+
+    # If all values in `ev` are equal, it implies that the graph can't be
+    # further sub-divided. In this case the bi-partition is the the graph
+    # itself and an empty set.
+    min_mask = np.zeros_like(ev, dtype=bool)
+    if np.allclose(mn, mx):
+        return min_mask, mcut
+
+    # Refer Shi & Malik 2001, Section 3.1.3, Page 892
+    # Perform evenly spaced n-cuts and determine the optimal one.
+    for t in np.linspace(mn, mx, num_cuts, endpoint=False):
+        mask = ev > t
+        cost = _ncut.ncut_cost(mask, d, w)
+        if cost < mcut:
+            min_mask = mask
+            mcut = cost
+
+    return min_mask, mcut
+
+
+def _label_all(rag, attr_name):
+    """Assign a unique integer to the given attribute in the RAG.
+
+    This function assumes that all labels in `rag` are unique. It
+    picks up a random label from them and assigns it to the `attr_name`
+    attribute of all the nodes.
+
+    rag : RAG
+        The Region Adjacency Graph.
+    attr_name : string
+        The attribute to which a unique integer is assigned.
+    """
+    node = min(rag.nodes())
+    new_label = rag.nodes[node]['labels'][0]
+    for n, d in rag.nodes(data=True):
+        d[attr_name] = new_label
+
+
+def _ncut_relabel(rag, thresh, num_cuts, random_generator):
+    """Perform Normalized Graph cut on the Region Adjacency Graph.
+
+    Recursively partition the graph into 2, until further subdivision
+    yields a cut greater than `thresh` or such a cut cannot be computed.
+    For such a subgraph, indices to labels of all its nodes map to a single
+    unique value.
+
+    Parameters
+    ----------
+    rag : RAG
+        The region adjacency graph.
+    thresh : float
+        The threshold. A subgraph won't be further subdivided if the
+        value of the N-cut exceeds `thresh`.
+    num_cuts : int
+        The number or N-cuts to perform before determining the optimal one.
+    random_generator : `numpy.random.Generator`
+        Provides initial values for eigenvalue solver.
+    """
+    d, w = _ncut.DW_matrices(rag)
+    m = w.shape[0]
+
+    if (m > 2) and (d != w).nnz > 0:
+        # This avoids further segmenting a graph that is too small,
+        # and the degenerate case (d == w), which typically occurs
+        # when only three single pixels remain.
+        #
+        # We're not sure exactly why this latter case arises. For
+        # SciPy <= 0.14, SciPy continued to compute an eigenvector,
+        # but newer versions (correctly) won't.  We refuse to guess,
+        # and stop further segmentation.
+        #
+        # It may make sense to a warning here; on the other hand segmentations
+        # are not a ground truth, so this level of "noise" should be acceptable.
+
+        d2 = d.copy()
+        # Since d is diagonal, we can directly operate on its data
+        # the inverse of the square root
+        d2.data = np.reciprocal(np.sqrt(d2.data, out=d2.data), out=d2.data)
+
+        # Refer Shi & Malik 2001, Equation 7, Page 891
+        A = d2 @ (d - w) @ d2
+        # Initialize the vector to ensure reproducibility.
+        v0 = random_generator.random(A.shape[0])
+
+        # SciPy 1.17.0.dev0 adds the new `rng` keyword, allowing `eigsh` to
+        # become deterministic
+        rng_kw = {"rng": random_generator} if SCIPY_GE_1_17_0_DEV0 else {}
+        vals, vectors = linalg.eigsh(A, which='SM', v0=v0, k=min(100, m - 2), **rng_kw)
+
+        # Pick second smallest eigenvector.
+        # Refer Shi & Malik 2001, Section 3.2.3, Page 893
+        vals, vectors = np.real(vals), np.real(vectors)
+        index2 = _ncut_cy.argmin2(vals)
+        ev = vectors[:, index2]
+
+        cut_mask, mcut = get_min_ncut(ev, d, w, num_cuts)
+        if mcut < thresh:
+            # Sub divide and perform N-cut again
+            # Refer Shi & Malik 2001, Section 3.2.5, Page 893
+            sub1, sub2 = partition_by_cut(cut_mask, rag)
+
+            _ncut_relabel(sub1, thresh, num_cuts, random_generator)
+            _ncut_relabel(sub2, thresh, num_cuts, random_generator)
+            return
+
+    # The N-cut wasn't small enough, or could not be computed.
+    # The remaining graph is a region.
+    # Assign `ncut label` by picking any label from the existing nodes, since
+    # `labels` are unique, `new_label` is also unique.
+    _label_all(rag, 'ncut label')

envs/kitoverlay/skimage/graph/_graph_merge.py

@@ -0,0 +1,138 @@
+import numpy as np
+import heapq
+
+
+def _revalidate_node_edges(rag, node, heap_list):
+    """Handles validation and invalidation of edges incident to a node.
+
+    This function invalidates all existing edges incident on `node` and inserts
+    new items in `heap_list` updated with the valid weights.
+
+    rag : RAG
+        The Region Adjacency Graph.
+    node : int
+        The id of the node whose incident edges are to be validated/invalidated
+        .
+    heap_list : list
+        The list containing the existing heap of edges.
+    """
+    # networkx updates data dictionary if edge exists
+    # this would mean we have to reposition these edges in
+    # heap if their weight is updated.
+    # instead we invalidate them
+
+    for nbr in rag.neighbors(node):
+        data = rag[node][nbr]
+        try:
+            # invalidate edges incident on `dst`, they have new weights
+            data['heap item'][3] = False
+            _invalidate_edge(rag, node, nbr)
+        except KeyError:
+            # will handle the case where the edge did not exist in the existing
+            # graph
+            pass
+
+        wt = data['weight']
+        heap_item = [wt, node, nbr, True]
+        data['heap item'] = heap_item
+        heapq.heappush(heap_list, heap_item)
+
+
+def _rename_node(graph, node_id, copy_id):
+    """Rename `node_id` in `graph` to `copy_id`."""
+
+    graph._add_node_silent(copy_id)
+    graph.nodes[copy_id].update(graph.nodes[node_id])
+
+    for nbr in graph.neighbors(node_id):
+        wt = graph[node_id][nbr]['weight']
+        graph.add_edge(nbr, copy_id, {'weight': wt})
+
+    graph.remove_node(node_id)
+
+
+def _invalidate_edge(graph, n1, n2):
+    """Invalidates the edge (n1, n2) in the heap."""
+    graph[n1][n2]['heap item'][3] = False
+
+
+def merge_hierarchical(
+    labels, rag, thresh, rag_copy, in_place_merge, merge_func, weight_func
+):
+    """Perform hierarchical merging of a RAG.
+
+    Greedily merges the most similar pair of nodes until no edges lower than
+    `thresh` remain.
+
+    Parameters
+    ----------
+    labels : ndarray
+        The array of labels.
+    rag : RAG
+        The Region Adjacency Graph.
+    thresh : float
+        Regions connected by an edge with weight smaller than `thresh` are
+        merged.
+    rag_copy : bool
+        If set, the RAG copied before modifying.
+    in_place_merge : bool
+        If set, the nodes are merged in place. Otherwise, a new node is
+        created for each merge..
+    merge_func : callable
+        This function is called before merging two nodes. For the RAG `graph`
+        while merging `src` and `dst`, it is called as follows
+        ``merge_func(graph, src, dst)``.
+    weight_func : callable
+        The function to compute the new weights of the nodes adjacent to the
+        merged node. This is directly supplied as the argument `weight_func`
+        to `merge_nodes`.
+
+    Returns
+    -------
+    out : ndarray
+        The new labeled array.
+
+    """
+    if rag_copy:
+        rag = rag.copy()
+
+    edge_heap = []
+    for n1, n2, data in rag.edges(data=True):
+        # Push a valid edge in the heap
+        wt = data['weight']
+        heap_item = [wt, n1, n2, True]
+        heapq.heappush(edge_heap, heap_item)
+
+        # Reference to the heap item in the graph
+        data['heap item'] = heap_item
+
+    while len(edge_heap) > 0 and edge_heap[0][0] < thresh:
+        _, n1, n2, valid = heapq.heappop(edge_heap)
+
+        # Ensure popped edge is valid, if not, the edge is discarded
+        if valid:
+            # Invalidate all neighbors of `src` before its deleted
+
+            for nbr in rag.neighbors(n1):
+                _invalidate_edge(rag, n1, nbr)
+
+            for nbr in rag.neighbors(n2):
+                _invalidate_edge(rag, n2, nbr)
+
+            if not in_place_merge:
+                next_id = rag.next_id()
+                _rename_node(rag, n2, next_id)
+                src, dst = n1, next_id
+            else:
+                src, dst = n1, n2
+
+            merge_func(rag, src, dst)
+            new_id = rag.merge_nodes(src, dst, weight_func)
+            _revalidate_node_edges(rag, new_id, edge_heap)
+
+    label_map = np.arange(labels.max() + 1)
+    for ix, (n, d) in enumerate(rag.nodes(data=True)):
+        for label in d['labels']:
+            label_map[label] = ix
+
+    return label_map[labels]

envs/kitoverlay/skimage/graph/_ncut.py

@@ -0,0 +1,64 @@
+import networkx as nx
+import numpy as np
+from scipy import sparse
+from . import _ncut_cy
+
+
+def DW_matrices(graph):
+    """Returns the diagonal and weight matrices of a graph.
+
+    Parameters
+    ----------
+    graph : RAG
+        A Region Adjacency Graph.
+
+    Returns
+    -------
+    D : csc_array
+        The diagonal matrix of the graph. ``D[i, i]`` is the sum of weights of
+        all edges incident on `i`. All other entries are `0`.
+    W : csc_array
+        The weight matrix of the graph. ``W[i, j]`` is the weight of the edge
+        joining `i` to `j`.
+    """
+    # sparse.eighsh is most efficient with CSC-formatted input
+    W = nx.to_scipy_sparse_array(graph, format='csc')
+    entries = W.sum(axis=0)
+    D = sparse.dia_array((entries, 0), shape=W.shape).tocsc()
+
+    return D, W
+
+
+def ncut_cost(cut, D, W):
+    """Returns the N-cut cost of a bi-partition of a graph.
+
+    Parameters
+    ----------
+    cut : ndarray
+        The mask for the nodes in the graph. Nodes corresponding to a `True`
+        value are in one set.
+    D : csc_array
+        The diagonal matrix of the graph.
+    W : csc_array
+        The weight matrix of the graph.
+
+    Returns
+    -------
+    cost : float
+        The cost of performing the N-cut.
+
+    References
+    ----------
+    .. [1] Normalized Cuts and Image Segmentation, Jianbo Shi and
+           Jitendra Malik, IEEE Transactions on Pattern Analysis and Machine
+           Intelligence, Page 889, Equation 2.
+    """
+    cut = np.array(cut)
+    cut_cost = _ncut_cy.cut_cost(cut, W.data, W.indices, W.indptr, num_cols=W.shape[0])
+
+    # D has elements only along the diagonal, one per node, so we can directly
+    # index the data attribute with cut.
+    assoc_a = D.data[cut].sum()
+    assoc_b = D.data[~cut].sum()
+
+    return (cut_cost / assoc_a) + (cut_cost / assoc_b)

envs/kitoverlay/skimage/graph/_rag.py

@@ -0,0 +1,581 @@
+import networkx as nx
+import numpy as np
+from scipy import ndimage as ndi
+from scipy import sparse
+import math
+
+from .. import measure, segmentation, util, color
+from .._shared.version_requirements import require
+
+
+__doctest_requires__ = {("show_rag",): ["matplotlib"]}
+
+
+def _edge_generator_from_csr(csr_array):
+    """Yield weighted edge triples for use by NetworkX from a CSR matrix.
+
+    This function is a straight rewrite of
+    `networkx.convert_matrix._csr_gen_triples`. Since that is a private
+    function, it is safer to include our own here.
+
+    Parameters
+    ----------
+    csr_array : scipy.sparse.csr_array
+        The input matrix. An edge (i, j, w) will be yielded if there is a
+        data value for coordinates (i, j) in the matrix, even if that value
+        is 0.
+
+    Yields
+    ------
+    i, j, w : (int, int, float) tuples
+        Each value `w` in the matrix along with its coordinates (i, j).
+
+    Examples
+    --------
+
+    >>> dense = np.eye(2, dtype=float)
+    >>> csr = sparse.csr_array(dense)
+    >>> edges = _edge_generator_from_csr(csr)
+    >>> list(edges)
+    [(0, 0, 1.0), (1, 1, 1.0)]
+    """
+    nrows = csr_array.shape[0]
+    values = csr_array.data
+    indptr = csr_array.indptr
+    col_indices = csr_array.indices
+    for i in range(nrows):
+        for j in range(indptr[i], indptr[i + 1]):
+            yield i, col_indices[j], values[j]
+
+
+def min_weight(graph, src, dst, n):
+    """Callback to handle merging nodes by choosing minimum weight.
+
+    Returns a dictionary with `"weight"` set as either the weight between
+    (`src`, `n`) or (`dst`, `n`) in `graph` or the minimum of the two when
+    both exist.
+
+    Parameters
+    ----------
+    graph : RAG
+        The graph under consideration.
+    src, dst : int
+        The verices in `graph` to be merged.
+    n : int
+        A neighbor of `src` or `dst` or both.
+
+    Returns
+    -------
+    data : dict
+        A dict with the `"weight"` attribute set the weight between
+        (`src`, `n`) or (`dst`, `n`) in `graph` or the minimum of the two when
+        both exist.
+
+    """
+
+    # cover the cases where n only has edge to either `src` or `dst`
+    default = {'weight': np.inf}
+    w1 = graph[n].get(src, default)['weight']
+    w2 = graph[n].get(dst, default)['weight']
+    return {'weight': min(w1, w2)}
+
+
+def _add_edge_filter(values, graph):
+    """Create edge in `graph` between central element of `values` and the rest.
+
+    Add an edge between the middle element in `values` and
+    all other elements of `values` into `graph`.  ``values[len(values) // 2]``
+    is expected to be the central value of the footprint used.
+
+    Parameters
+    ----------
+    values : array
+        The array to process.
+    graph : RAG
+        The graph to add edges in.
+
+    Returns
+    -------
+    0 : float
+        Always returns 0. The return value is required so that `generic_filter`
+        can put it in the output array, but it is ignored by this filter.
+    """
+    values = values.astype(int)
+    center = values[len(values) // 2]
+    for value in values:
+        if value != center and not graph.has_edge(center, value):
+            graph.add_edge(center, value)
+    return 0.0
+
+
+class RAG(nx.Graph):
+    """The Region Adjacency Graph (RAG) of an image, subclasses :obj:`networkx.Graph`.
+
+    Parameters
+    ----------
+    label_image : array of int
+        An initial segmentation, with each region labeled as a different
+        integer. Every unique value in ``label_image`` will correspond to
+        a node in the graph.
+    connectivity : int in {1, ..., ``label_image.ndim``}, optional
+        The connectivity between pixels in ``label_image``. For a 2D image,
+        a connectivity of 1 corresponds to immediate neighbors up, down,
+        left, and right, while a connectivity of 2 also includes diagonal
+        neighbors. See :func:`scipy.ndimage.generate_binary_structure`.
+    data : :obj:`networkx.Graph` specification, optional
+        Initial or additional edges to pass to :obj:`networkx.Graph`
+        constructor. Valid edge specifications include edge list (list of tuples),
+        NumPy arrays, and SciPy sparse matrices.
+    **attr : keyword arguments, optional
+        Additional attributes to add to the graph.
+    """
+
+    def __init__(self, label_image=None, connectivity=1, data=None, **attr):
+        super().__init__(data, **attr)
+        if self.number_of_nodes() == 0:
+            self.max_id = 0
+        else:
+            self.max_id = max(self.nodes())
+
+        if label_image is not None:
+            fp = ndi.generate_binary_structure(label_image.ndim, connectivity)
+            # In the next ``ndi.generic_filter`` function, the kwarg
+            # ``output`` is used to provide a strided array with a single
+            # 64-bit floating point number, to which the function repeatedly
+            # writes. This is done because even if we don't care about the
+            # output, without this, a float array of the same shape as the
+            # input image will be created and that could be expensive in
+            # memory consumption.
+            output = np.broadcast_to(1.0, label_image.shape)
+            output.setflags(write=True)
+            ndi.generic_filter(
+                label_image,
+                function=_add_edge_filter,
+                footprint=fp,
+                mode='nearest',
+                output=output,
+                extra_arguments=(self,),
+            )
+
+    def merge_nodes(
+        self,
+        src,
+        dst,
+        weight_func=min_weight,
+        in_place=True,
+        extra_arguments=None,
+        extra_keywords=None,
+    ):
+        """Merge node `src` and `dst`.
+
+        The new combined node is adjacent to all the neighbors of `src`
+        and `dst`. `weight_func` is called to decide the weight of edges
+        incident on the new node.
+
+        Parameters
+        ----------
+        src, dst : int
+            Nodes to be merged.
+        weight_func : callable, optional
+            Function to decide the attributes of edges incident on the new
+            node. For each neighbor `n` for `src` and `dst`, `weight_func` will
+            be called as follows: `weight_func(src, dst, n, *extra_arguments,
+            **extra_keywords)`. `src`, `dst` and `n` are IDs of vertices in the
+            RAG object which is in turn a subclass of :obj:`networkx.Graph`. It is
+            expected to return a dict of attributes of the resulting edge.
+        in_place : bool, optional
+            If set to `True`, the merged node has the id `dst`, else merged
+            node has a new id which is returned.
+        extra_arguments : sequence, optional
+            The sequence of extra positional arguments passed to
+            `weight_func`.
+        extra_keywords : dictionary, optional
+            The dict of keyword arguments passed to the `weight_func`.
+
+        Returns
+        -------
+        id : int
+            The id of the new node.
+
+        Notes
+        -----
+        If `in_place` is `False` the resulting node has a new id, rather than
+        `dst`.
+        """
+        if extra_arguments is None:
+            extra_arguments = []
+        if extra_keywords is None:
+            extra_keywords = {}
+
+        src_nbrs = set(self.neighbors(src))
+        dst_nbrs = set(self.neighbors(dst))
+        neighbors = (src_nbrs | dst_nbrs) - {src, dst}
+
+        if in_place:
+            new = dst
+        else:
+            new = self.next_id()
+            self.add_node(new)
+
+        for neighbor in neighbors:
+            data = weight_func(
+                self, src, dst, neighbor, *extra_arguments, **extra_keywords
+            )
+            self.add_edge(neighbor, new, attr_dict=data)
+
+        self.nodes[new]['labels'] = (
+            self.nodes[src]['labels'] + self.nodes[dst]['labels']
+        )
+        self.remove_node(src)
+
+        if not in_place:
+            self.remove_node(dst)
+
+        return new
+
+    def add_node(self, n, attr_dict=None, **attr):
+        """Add node `n` while updating the maximum node id.
+
+        .. seealso:: :obj:`networkx.Graph.add_node`."""
+        if attr_dict is None:  # compatibility with old networkx
+            attr_dict = attr
+        else:
+            attr_dict.update(attr)
+        super().add_node(n, **attr_dict)
+        self.max_id = max(n, self.max_id)
+
+    def add_edge(self, u, v, attr_dict=None, **attr):
+        """Add an edge between `u` and `v` while updating max node id.
+
+        .. seealso:: :obj:`networkx.Graph.add_edge`."""
+        if attr_dict is None:  # compatibility with old networkx
+            attr_dict = attr
+        else:
+            attr_dict.update(attr)
+        super().add_edge(u, v, **attr_dict)
+        self.max_id = max(u, v, self.max_id)
+
+    def copy(self):
+        """Copy the graph with its max node id.
+
+        .. seealso:: :obj:`networkx.Graph.copy`."""
+        g = super().copy()
+        g.max_id = self.max_id
+        return g
+
+    def fresh_copy(self):
+        """Return a fresh copy graph with the same data structure.
+
+        A fresh copy has no nodes, edges or graph attributes. It is
+        the same data structure as the current graph. This method is
+        typically used to create an empty version of the graph.
+
+        This is required when subclassing Graph with networkx v2 and
+        does not cause problems for v1. Here is more detail from
+        the network migrating from 1.x to 2.x document::
+
+            With the new GraphViews (SubGraph, ReversedGraph, etc)
+            you can't assume that ``G.__class__()`` will create a new
+            instance of the same graph type as ``G``. In fact, the
+            call signature for ``__class__`` differs depending on
+            whether ``G`` is a view or a base class. For v2.x you
+            should use ``G.fresh_copy()`` to create a null graph of
+            the correct type---ready to fill with nodes and edges.
+
+        """
+        return RAG()
+
+    def next_id(self):
+        """Returns the `id` for the new node to be inserted.
+
+        The current implementation returns one more than the maximum `id`.
+
+        Returns
+        -------
+        id : int
+            The `id` of the new node to be inserted.
+        """
+        return self.max_id + 1
+
+    def _add_node_silent(self, n):
+        """Add node `n` without updating the maximum node id.
+
+        This is a convenience method used internally.
+
+        .. seealso:: :obj:`networkx.Graph.add_node`."""
+        super().add_node(n)
+
+
+def rag_mean_color(image, labels, connectivity=2, mode='distance', sigma=255.0):
+    """Compute the Region Adjacency Graph using mean colors.
+
+    Given an image and its initial segmentation, this method constructs the
+    corresponding Region Adjacency Graph (RAG). Each node in the RAG
+    represents a set of pixels within `image` with the same label in `labels`.
+    The weight between two adjacent regions represents how similar or
+    dissimilar two regions are depending on the `mode` parameter.
+
+    Parameters
+    ----------
+    image : ndarray, shape(M, N[, ..., P], 3)
+        Input image.
+    labels : ndarray, shape(M, N[, ..., P])
+        The labelled image. This should have one dimension less than
+        `image`. If `image` has dimensions `(M, N, 3)` `labels` should have
+        dimensions `(M, N)`.
+    connectivity : int, optional
+        Pixels with a squared distance less than `connectivity` from each other
+        are considered adjacent. It can range from 1 to `labels.ndim`. Its
+        behavior is the same as `connectivity` parameter in
+        ``scipy.ndimage.generate_binary_structure``.
+    mode : {'distance', 'similarity'}, optional
+        The strategy to assign edge weights.
+
+            'distance' : The weight between two adjacent regions is the
+            :math:`|c_1 - c_2|`, where :math:`c_1` and :math:`c_2` are the mean
+            colors of the two regions. It represents the Euclidean distance in
+            their average color.
+
+            'similarity' : The weight between two adjacent is
+            :math:`e^{-d^2/sigma}` where :math:`d=|c_1 - c_2|`, where
+            :math:`c_1` and :math:`c_2` are the mean colors of the two regions.
+            It represents how similar two regions are.
+    sigma : float, optional
+        Used for computation when `mode` is "similarity". It governs how
+        close to each other two colors should be, for their corresponding edge
+        weight to be significant. A very large value of `sigma` could make
+        any two colors behave as though they were similar.
+
+    Returns
+    -------
+    out : RAG
+        The region adjacency graph.
+
+    Examples
+    --------
+    >>> from skimage import data, segmentation, graph
+    >>> img = data.astronaut()
+    >>> labels = segmentation.slic(img)
+    >>> rag = graph.rag_mean_color(img, labels)
+
+    References
+    ----------
+    .. [1] Alain Tremeau and Philippe Colantoni
+           "Regions Adjacency Graph Applied To Color Image Segmentation"
+           :DOI:`10.1109/83.841950`
+    """
+    graph = RAG(labels, connectivity=connectivity)
+
+    for n in graph:
+        graph.nodes[n].update(
+            {
+                'labels': [n],
+                'pixel count': 0,
+                'total color': np.array([0, 0, 0], dtype=np.float64),
+            }
+        )
+
+    for index in np.ndindex(labels.shape):
+        current = labels[index]
+        graph.nodes[current]['pixel count'] += 1
+        graph.nodes[current]['total color'] += image[index]
+
+    for n in graph:
+        graph.nodes[n]['mean color'] = (
+            graph.nodes[n]['total color'] / graph.nodes[n]['pixel count']
+        )
+
+    for x, y, d in graph.edges(data=True):
+        diff = graph.nodes[x]['mean color'] - graph.nodes[y]['mean color']
+        diff = np.linalg.norm(diff)
+        if mode == 'similarity':
+            d['weight'] = math.e ** (-(diff**2) / sigma)
+        elif mode == 'distance':
+            d['weight'] = diff
+        else:
+            raise ValueError(f"The mode '{mode}' is not recognised")
+
+    return graph
+
+
+def rag_boundary(labels, edge_map, connectivity=2):
+    """Comouter RAG based on region boundaries
+
+    Given an image's initial segmentation and its edge map this method
+    constructs the corresponding Region Adjacency Graph (RAG). Each node in the
+    RAG represents a set of pixels within the image with the same label in
+    `labels`. The weight between two adjacent regions is the average value
+    in `edge_map` along their boundary.
+
+    labels : ndarray
+        The labelled image.
+    edge_map : ndarray
+        This should have the same shape as that of `labels`. For all pixels
+        along the boundary between 2 adjacent regions, the average value of the
+        corresponding pixels in `edge_map` is the edge weight between them.
+    connectivity : int, optional
+        Pixels with a squared distance less than `connectivity` from each other
+        are considered adjacent. It can range from 1 to `labels.ndim`. Its
+        behavior is the same as `connectivity` parameter in
+        `scipy.ndimage.generate_binary_structure`.
+
+    Examples
+    --------
+    >>> from skimage import data, segmentation, filters, color, graph
+    >>> img = data.chelsea()
+    >>> labels = segmentation.slic(img)
+    >>> edge_map = filters.sobel(color.rgb2gray(img))
+    >>> rag = graph.rag_boundary(labels, edge_map)
+
+    """
+
+    conn = ndi.generate_binary_structure(labels.ndim, connectivity)
+    eroded = ndi.grey_erosion(labels, footprint=conn)
+    dilated = ndi.grey_dilation(labels, footprint=conn)
+    boundaries0 = eroded != labels
+    boundaries1 = dilated != labels
+    labels_small = np.concatenate((eroded[boundaries0], labels[boundaries1]))
+    labels_large = np.concatenate((labels[boundaries0], dilated[boundaries1]))
+    n = np.max(labels_large) + 1
+
+    # use a dummy broadcast array as data for RAG
+    ones = np.broadcast_to(1.0, labels_small.shape)
+    count_matrix = sparse.csr_array(
+        (ones, (labels_small, labels_large)), dtype=int, shape=(n, n)
+    )
+    data = np.concatenate((edge_map[boundaries0], edge_map[boundaries1]))
+
+    graph_matrix = sparse.csr_array((data, (labels_small, labels_large)))
+    graph_matrix.data /= count_matrix.data
+
+    rag = RAG()
+    rag.add_weighted_edges_from(_edge_generator_from_csr(graph_matrix), weight='weight')
+    rag.add_weighted_edges_from(_edge_generator_from_csr(count_matrix), weight='count')
+
+    for n in rag.nodes():
+        rag.nodes[n].update({'labels': [n]})
+
+    return rag
+
+
+@require("matplotlib", ">=3.3")
+def show_rag(
+    labels,
+    rag,
+    image,
+    border_color='black',
+    edge_width=1.5,
+    edge_cmap='magma',
+    img_cmap='bone',
+    in_place=True,
+    ax=None,
+):
+    """Show a Region Adjacency Graph on an image.
+
+    Given a labelled image and its corresponding RAG, show the nodes and edges
+    of the RAG on the image with the specified colors. Edges are displayed between
+    the centroid of the 2 adjacent regions in the image.
+
+    Parameters
+    ----------
+    labels : ndarray, shape (M, N)
+        The labelled image.
+    rag : RAG
+        The Region Adjacency Graph.
+    image : ndarray, shape (M, N[, 3])
+        Input image. If `colormap` is `None`, the image should be in RGB
+        format.
+    border_color : color spec, optional
+        Color with which the borders between regions are drawn.
+    edge_width : float, optional
+        The thickness with which the RAG edges are drawn.
+    edge_cmap : :py:class:`matplotlib.colors.Colormap`, optional
+        Any matplotlib colormap with which the edges are drawn.
+    img_cmap : :py:class:`matplotlib.colors.Colormap`, optional
+        Any matplotlib colormap with which the image is draw. If set to `None`
+        the image is drawn as it is.
+    in_place : bool, optional
+        If set, the RAG is modified in place. For each node `n` the function
+        will set a new attribute ``rag.nodes[n]['centroid']``.
+    ax : :py:class:`matplotlib.axes.Axes`, optional
+        The axes to draw on. If not specified, new axes are created and drawn
+        on.
+
+    Returns
+    -------
+    lc : :py:class:`matplotlib.collections.LineCollection`
+         A collection of lines that represent the edges of the graph. It can be
+         passed to the :meth:`matplotlib.figure.Figure.colorbar` function.
+
+    Examples
+    --------
+    >>> from skimage import data, segmentation, graph
+    >>> import matplotlib.pyplot as plt
+    >>>
+    >>> img = data.coffee()
+    >>> labels = segmentation.slic(img)
+    >>> g =  graph.rag_mean_color(img, labels)
+    >>> lc = graph.show_rag(labels, g, img)
+    >>> cbar = plt.colorbar(lc)
+    """
+    from matplotlib import colors
+    from matplotlib import pyplot as plt
+    from matplotlib.collections import LineCollection
+
+    if not in_place:
+        rag = rag.copy()
+
+    if ax is None:
+        fig, ax = plt.subplots()
+    out = util.img_as_float(image, force_copy=True)
+
+    if img_cmap is None:
+        if image.ndim < 3 or image.shape[2] not in [3, 4]:
+            msg = 'If colormap is `None`, an RGB or RGBA image should be given'
+            raise ValueError(msg)
+        # Ignore the alpha channel
+        out = image[:, :, :3]
+    else:
+        img_cmap = plt.get_cmap(img_cmap)
+        out = color.rgb2gray(image)
+        # Ignore the alpha channel
+        out = img_cmap(out)[:, :, :3]
+
+    edge_cmap = plt.get_cmap(edge_cmap)
+
+    # Handling the case where one node has multiple labels
+    # offset is 1 so that regionprops does not ignore 0
+    offset = 1
+    map_array = np.arange(labels.max() + 1)
+    for n, d in rag.nodes(data=True):
+        for label in d['labels']:
+            map_array[label] = offset
+        offset += 1
+
+    rag_labels = map_array[labels]
+    regions = measure.regionprops(rag_labels)
+
+    for (n, data), region in zip(rag.nodes(data=True), regions):
+        data['centroid'] = tuple(map(int, region['centroid']))
+
+    cc = colors.ColorConverter()
+    if border_color is not None:
+        border_color = cc.to_rgb(border_color)
+        out = segmentation.mark_boundaries(out, rag_labels, color=border_color)
+
+    ax.imshow(out)
+
+    # Defining the end points of the edges
+    # The tuple[::-1] syntax reverses a tuple as matplotlib uses (x,y)
+    # convention while skimage uses (row, column)
+    lines = [
+        [rag.nodes[n1]['centroid'][::-1], rag.nodes[n2]['centroid'][::-1]]
+        for (n1, n2) in rag.edges()
+    ]
+
+    lc = LineCollection(lines, linewidths=edge_width, cmap=edge_cmap)
+    edge_weights = [d['weight'] for x, y, d in rag.edges(data=True)]
+    lc.set_array(np.array(edge_weights))
+    ax.add_collection(lc)
+
+    return lc

envs/kitoverlay/skimage/graph/mcp.py

@@ -0,0 +1,88 @@
+from ._mcp import MCP, MCP_Geometric, MCP_Connect, MCP_Flexible  # noqa: F401
+
+
+def route_through_array(array, start, end, fully_connected=True, geometric=True):
+    """Simple example of how to use the MCP and MCP_Geometric classes.
+
+    See the MCP and MCP_Geometric class documentation for explanation of the
+    path-finding algorithm.
+
+    Parameters
+    ----------
+    array : ndarray
+        Array of costs.
+    start : iterable
+        n-d index into `array` defining the starting point
+    end : iterable
+        n-d index into `array` defining the end point
+    fully_connected : bool (optional)
+        If True, diagonal moves are permitted, if False, only axial moves.
+    geometric : bool (optional)
+        If True, the MCP_Geometric class is used to calculate costs, if False,
+        the MCP base class is used. See the class documentation for
+        an explanation of the differences between MCP and MCP_Geometric.
+
+    Returns
+    -------
+    path : list
+        List of n-d index tuples defining the path from `start` to `end`.
+    cost : float
+        Cost of the path. If `geometric` is False, the cost of the path is
+        the sum of the values of `array` along the path. If `geometric` is
+        True, a finer computation is made (see the documentation of the
+        MCP_Geometric class).
+
+    See Also
+    --------
+    MCP, MCP_Geometric
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.graph import route_through_array
+    >>>
+    >>> image = np.array([[1, 3], [10, 12]])
+    >>> image
+    array([[ 1,  3],
+           [10, 12]])
+    >>> # Forbid diagonal steps
+    >>> route_through_array(image, [0, 0], [1, 1], fully_connected=False)
+    ([(0, 0), (0, 1), (1, 1)], 9.5)
+    >>> # Now allow diagonal steps: the path goes directly from start to end
+    >>> route_through_array(image, [0, 0], [1, 1])
+    ([(0, 0), (1, 1)], 9.19238815542512)
+    >>> # Cost is the sum of array values along the path (16 = 1 + 3 + 12)
+    >>> route_through_array(image, [0, 0], [1, 1], fully_connected=False,
+    ... geometric=False)
+    ([(0, 0), (0, 1), (1, 1)], 16.0)
+    >>> # Larger array where we display the path that is selected
+    >>> image = np.arange((36)).reshape((6, 6))
+    >>> image
+    array([[ 0,  1,  2,  3,  4,  5],
+           [ 6,  7,  8,  9, 10, 11],
+           [12, 13, 14, 15, 16, 17],
+           [18, 19, 20, 21, 22, 23],
+           [24, 25, 26, 27, 28, 29],
+           [30, 31, 32, 33, 34, 35]])
+    >>> # Find the path with lowest cost
+    >>> indices, weight = route_through_array(image, (0, 0), (5, 5))
+    >>> indices = np.stack(indices, axis=-1)
+    >>> path = np.zeros_like(image)
+    >>> path[indices[0], indices[1]] = 1
+    >>> path
+    array([[1, 1, 1, 1, 1, 0],
+           [0, 0, 0, 0, 0, 1],
+           [0, 0, 0, 0, 0, 1],
+           [0, 0, 0, 0, 0, 1],
+           [0, 0, 0, 0, 0, 1],
+           [0, 0, 0, 0, 0, 1]])
+
+    """
+    start, end = tuple(start), tuple(end)
+    if geometric:
+        mcp_class = MCP_Geometric
+    else:
+        mcp_class = MCP
+    m = mcp_class(array, fully_connected=fully_connected)
+    costs, traceback_array = m.find_costs([start], [end])
+    return m.traceback(end), costs[end]

envs/kitoverlay/skimage/graph/spath.py

@@ -0,0 +1,83 @@
+import numpy as np
+from . import _spath
+
+
+def shortest_path(arr, reach=1, axis=-1, output_indexlist=False):
+    """Find the shortest path through an n-d array from one side to another.
+
+    Parameters
+    ----------
+    arr : ndarray of float64
+    reach : int, optional
+        By default (``reach = 1``), the shortest path can only move
+        one row up or down for every step it moves forward (i.e.,
+        the path gradient is limited to 1). `reach` defines the
+        number of elements that can be skipped along each non-axis
+        dimension at each step.
+    axis : int, optional
+        The axis along which the path must always move forward (default -1)
+    output_indexlist : bool, optional
+        See return value `p` for explanation.
+
+    Returns
+    -------
+    p : iterable of int
+        For each step along `axis`, the coordinate of the shortest path.
+        If `output_indexlist` is True, then the path is returned as a list of
+        n-d tuples that index into `arr`. If False, then the path is returned
+        as an array listing the coordinates of the path along the non-axis
+        dimensions for each step along the axis dimension. That is,
+        `p.shape == (arr.shape[axis], arr.ndim-1)` except that p is squeezed
+        before returning so if `arr.ndim == 2`, then
+        `p.shape == (arr.shape[axis],)`
+    cost : float
+        Cost of path.  This is the absolute sum of all the
+        differences along the path.
+
+    """
+    # First: calculate the valid moves from any given position. Basically,
+    # always move +1 along the given axis, and then can move anywhere within
+    # a grid defined by the reach.
+    if axis < 0:
+        axis += arr.ndim
+    offset_ind_shape = (2 * reach + 1,) * (arr.ndim - 1)
+    offset_indices = np.indices(offset_ind_shape) - reach
+    offset_indices = np.insert(offset_indices, axis, np.ones(offset_ind_shape), axis=0)
+    offset_size = np.multiply.reduce(offset_ind_shape)
+    offsets = np.reshape(offset_indices, (arr.ndim, offset_size), order='F').T
+
+    # Valid starting positions are anywhere on the hyperplane defined by
+    # position 0 on the given axis. Ending positions are anywhere on the
+    # hyperplane at position -1 along the same.
+    non_axis_shape = arr.shape[:axis] + arr.shape[axis + 1 :]
+    non_axis_indices = np.indices(non_axis_shape)
+    non_axis_size = np.multiply.reduce(non_axis_shape)
+    start_indices = np.insert(non_axis_indices, axis, np.zeros(non_axis_shape), axis=0)
+    starts = np.reshape(start_indices, (arr.ndim, non_axis_size), order='F').T
+    end_indices = np.insert(
+        non_axis_indices,
+        axis,
+        np.full(non_axis_shape, -1, dtype=non_axis_indices.dtype),
+        axis=0,
+    )
+    ends = np.reshape(end_indices, (arr.ndim, non_axis_size), order='F').T
+
+    # Find the minimum-cost path to one of the end-points
+    m = _spath.MCP_Diff(arr, offsets=offsets)
+    costs, traceback = m.find_costs(starts, ends, find_all_ends=False)
+
+    # Figure out which end-point was found
+    for end in ends:
+        cost = costs[tuple(end)]
+        if cost != np.inf:
+            break
+    traceback = m.traceback(end)
+
+    if not output_indexlist:
+        traceback = np.array(traceback)
+        traceback = np.concatenate(
+            [traceback[:, :axis], traceback[:, axis + 1 :]], axis=1
+        )
+        traceback = np.squeeze(traceback)
+
+    return traceback, cost

envs/kitoverlay/skimage/registration/__init__.py

@@ -0,0 +1,5 @@
+"""Image registration algorithms, e.g., optical flow or phase cross correlation."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/registration/__init__.pyi

@@ -0,0 +1,8 @@
+# Explicitly setting `__all__` is necessary for type inference engines
+# to know which symbols are exported. See
+# https://peps.python.org/pep-0484/#stub-files
+
+__all__ = ['optical_flow_ilk', 'optical_flow_tvl1', 'phase_cross_correlation']
+
+from ._optical_flow import optical_flow_tvl1, optical_flow_ilk
+from ._phase_cross_correlation import phase_cross_correlation

envs/kitoverlay/skimage/registration/_masked_phase_cross_correlation.py

@@ -0,0 +1,306 @@
+"""
+Implementation of the masked normalized cross-correlation.
+
+Based on the following publication:
+D. Padfield. Masked object registration in the Fourier domain.
+IEEE Transactions on Image Processing (2012)
+
+and the author's original MATLAB implementation, available on this website:
+http://www.dirkpadfield.com/
+"""
+
+from functools import partial
+
+import numpy as np
+import scipy.fft as fftmodule
+from scipy.fft import next_fast_len
+
+from .._shared.utils import _supported_float_type
+
+
+def _masked_phase_cross_correlation(
+    reference_image, moving_image, reference_mask, moving_mask=None, overlap_ratio=0.3
+):
+    """Masked image translation registration by masked normalized
+    cross-correlation.
+
+    Parameters
+    ----------
+    reference_image : ndarray
+        Reference image.
+    moving_image : ndarray
+        Image to register. Must be same dimensionality as ``reference_image``,
+        but not necessarily the same size.
+    reference_mask : ndarray
+        Boolean mask for ``reference_image``. The mask should evaluate
+        to ``True`` (or 1) on valid pixels. ``reference_mask`` should
+        have the same shape as ``reference_image``.
+    moving_mask : ndarray or None, optional
+        Boolean mask for ``moving_image``. The mask should evaluate to ``True``
+        (or 1) on valid pixels. ``moving_mask`` should have the same shape
+        as ``moving_image``. If ``None``, ``reference_mask`` will be used.
+    overlap_ratio : float, optional
+        Minimum allowed overlap ratio between images. The correlation for
+        translations corresponding with an overlap ratio lower than this
+        threshold will be ignored. A lower `overlap_ratio` leads to smaller
+        maximum translation, while a higher `overlap_ratio` leads to greater
+        robustness against spurious matches due to small overlap between
+        masked images.
+
+    Returns
+    -------
+    shifts : ndarray
+        Shift vector (in pixels) required to register ``moving_image``
+        with ``reference_image``. Axis ordering is consistent with numpy.
+
+    References
+    ----------
+    .. [1] Dirk Padfield. Masked Object Registration in the Fourier Domain.
+           IEEE Transactions on Image Processing, vol. 21(5),
+           pp. 2706-2718 (2012). :DOI:`10.1109/TIP.2011.2181402`
+    .. [2] D. Padfield. "Masked FFT registration". In Proc. Computer Vision and
+           Pattern Recognition, pp. 2918-2925 (2010).
+           :DOI:`10.1109/CVPR.2010.5540032`
+
+    """
+    if moving_mask is None:
+        if reference_image.shape != moving_image.shape:
+            raise ValueError(
+                "Input images have different shapes, moving_mask must "
+                "be explicitly set."
+            )
+        moving_mask = reference_mask.astype(bool)
+
+    # We need masks to be of the same size as their respective images
+    for im, mask in [(reference_image, reference_mask), (moving_image, moving_mask)]:
+        if im.shape != mask.shape:
+            raise ValueError("Image sizes must match their respective mask sizes.")
+
+    xcorr = cross_correlate_masked(
+        moving_image,
+        reference_image,
+        moving_mask,
+        reference_mask,
+        axes=tuple(range(moving_image.ndim)),
+        mode='full',
+        overlap_ratio=overlap_ratio,
+    )
+
+    # Generalize to the average of multiple equal maxima
+    maxima = np.stack(np.nonzero(xcorr == xcorr.max()), axis=1)
+    center = np.mean(maxima, axis=0)
+    shifts = center - np.array(reference_image.shape) + 1
+
+    # The mismatch in size will impact the center location of the
+    # cross-correlation
+    size_mismatch = np.array(moving_image.shape) - np.array(reference_image.shape)
+
+    return -shifts + (size_mismatch / 2)
+
+
+def cross_correlate_masked(
+    arr1, arr2, m1, m2, mode='full', axes=(-2, -1), overlap_ratio=0.3
+):
+    """
+    Masked normalized cross-correlation between arrays.
+
+    Parameters
+    ----------
+    arr1 : ndarray
+        First array.
+    arr2 : ndarray
+        Seconds array. The dimensions of `arr2` along axes that are not
+        transformed should be equal to that of `arr1`.
+    m1 : ndarray
+        Mask of `arr1`. The mask should evaluate to `True`
+        (or 1) on valid pixels. `m1` should have the same shape as `arr1`.
+    m2 : ndarray
+        Mask of `arr2`. The mask should evaluate to `True`
+        (or 1) on valid pixels. `m2` should have the same shape as `arr2`.
+    mode : {'full', 'same'}, optional
+        'full':
+            This returns the convolution at each point of overlap. At
+            the end-points of the convolution, the signals do not overlap
+            completely, and boundary effects may be seen.
+        'same':
+            The output is the same size as `arr1`, centered with respect
+            to the `‘full’` output. Boundary effects are less prominent.
+    axes : tuple of ints, optional
+        Axes along which to compute the cross-correlation.
+    overlap_ratio : float, optional
+        Minimum allowed overlap ratio between images. The correlation for
+        translations corresponding with an overlap ratio lower than this
+        threshold will be ignored. A lower `overlap_ratio` leads to smaller
+        maximum translation, while a higher `overlap_ratio` leads to greater
+        robustness against spurious matches due to small overlap between
+        masked images.
+
+    Returns
+    -------
+    out : ndarray
+        Masked normalized cross-correlation.
+
+    Raises
+    ------
+    ValueError : if correlation `mode` is not valid, or array dimensions along
+        non-transformation axes are not equal.
+
+    References
+    ----------
+    .. [1] Dirk Padfield. Masked Object Registration in the Fourier Domain.
+           IEEE Transactions on Image Processing, vol. 21(5),
+           pp. 2706-2718 (2012). :DOI:`10.1109/TIP.2011.2181402`
+    .. [2] D. Padfield. "Masked FFT registration". In Proc. Computer Vision and
+           Pattern Recognition, pp. 2918-2925 (2010).
+           :DOI:`10.1109/CVPR.2010.5540032`
+    """
+    if mode not in {'full', 'same'}:
+        raise ValueError(f"Correlation mode '{mode}' is not valid.")
+
+    fixed_image = np.asarray(arr1)
+    moving_image = np.asarray(arr2)
+    float_dtype = _supported_float_type((fixed_image.dtype, moving_image.dtype))
+    if float_dtype.kind == 'c':
+        raise ValueError("complex-valued arr1, arr2 are not supported")
+
+    fixed_image = fixed_image.astype(float_dtype)
+    fixed_mask = np.array(m1, dtype=bool)
+    moving_image = moving_image.astype(float_dtype)
+    moving_mask = np.array(m2, dtype=bool)
+    eps = np.finfo(float_dtype).eps
+
+    # Array dimensions along non-transformation axes should be equal.
+    all_axes = set(range(fixed_image.ndim))
+    for axis in all_axes - set(axes):
+        if fixed_image.shape[axis] != moving_image.shape[axis]:
+            raise ValueError(
+                f'Array shapes along non-transformation axes should be '
+                f'equal, but dimensions along axis {axis} are not.'
+            )
+
+    # Determine final size along transformation axes
+    # Note that it might be faster to compute Fourier transform in a slightly
+    # larger shape (`fast_shape`). Then, after all fourier transforms are done,
+    # we slice back to`final_shape` using `final_slice`.
+    final_shape = list(arr1.shape)
+    for axis in axes:
+        final_shape[axis] = fixed_image.shape[axis] + moving_image.shape[axis] - 1
+    final_shape = tuple(final_shape)
+    final_slice = tuple([slice(0, int(sz)) for sz in final_shape])
+
+    # Extent transform axes to the next fast length (i.e. multiple of 3, 5, or
+    # 7)
+    fast_shape = tuple([next_fast_len(final_shape[ax]) for ax in axes])
+
+    # We use the new scipy.fft because they allow leaving the transform axes
+    # unchanged which was not possible with scipy.fftpack's
+    # fftn/ifftn in older versions of SciPy.
+    # E.g. arr shape (2, 3, 7), transform along axes (0, 1) with shape (4, 4)
+    # results in arr_fft shape (4, 4, 7)
+    fft = partial(fftmodule.fftn, s=fast_shape, axes=axes)
+    _ifft = partial(fftmodule.ifftn, s=fast_shape, axes=axes)
+
+    def ifft(x):
+        return _ifft(x).real
+
+    fixed_image[np.logical_not(fixed_mask)] = 0.0
+    moving_image[np.logical_not(moving_mask)] = 0.0
+
+    # N-dimensional analog to rotation by 180deg is flip over all relevant axes.
+    # See [1] for discussion.
+    rotated_moving_image = _flip(moving_image, axes=axes)
+    rotated_moving_mask = _flip(moving_mask, axes=axes)
+
+    fixed_fft = fft(fixed_image)
+    rotated_moving_fft = fft(rotated_moving_image)
+    fixed_mask_fft = fft(fixed_mask.astype(float_dtype))
+    rotated_moving_mask_fft = fft(rotated_moving_mask.astype(float_dtype))
+
+    # Calculate overlap of masks at every point in the convolution.
+    # Locations with high overlap should not be taken into account.
+    number_overlap_masked_px = ifft(rotated_moving_mask_fft * fixed_mask_fft)
+    number_overlap_masked_px[:] = np.round(number_overlap_masked_px)
+    number_overlap_masked_px[:] = np.fmax(number_overlap_masked_px, eps)
+    masked_correlated_fixed_fft = ifft(rotated_moving_mask_fft * fixed_fft)
+    masked_correlated_rotated_moving_fft = ifft(fixed_mask_fft * rotated_moving_fft)
+
+    numerator = ifft(rotated_moving_fft * fixed_fft)
+    numerator -= (
+        masked_correlated_fixed_fft
+        * masked_correlated_rotated_moving_fft
+        / number_overlap_masked_px
+    )
+
+    fixed_squared_fft = fft(np.square(fixed_image))
+    fixed_denom = ifft(rotated_moving_mask_fft * fixed_squared_fft)
+    fixed_denom -= np.square(masked_correlated_fixed_fft) / number_overlap_masked_px
+    fixed_denom[:] = np.fmax(fixed_denom, 0.0)
+
+    rotated_moving_squared_fft = fft(np.square(rotated_moving_image))
+    moving_denom = ifft(fixed_mask_fft * rotated_moving_squared_fft)
+    moving_denom -= (
+        np.square(masked_correlated_rotated_moving_fft) / number_overlap_masked_px
+    )
+    moving_denom[:] = np.fmax(moving_denom, 0.0)
+
+    denom = np.sqrt(fixed_denom * moving_denom)
+
+    # Slice back to expected convolution shape.
+    numerator = numerator[final_slice]
+    denom = denom[final_slice]
+    number_overlap_masked_px = number_overlap_masked_px[final_slice]
+
+    if mode == 'same':
+        _centering = partial(_centered, newshape=fixed_image.shape, axes=axes)
+        denom = _centering(denom)
+        numerator = _centering(numerator)
+        number_overlap_masked_px = _centering(number_overlap_masked_px)
+
+    # Pixels where `denom` is very small will introduce large
+    # numbers after division. To get around this problem,
+    # we zero-out problematic pixels.
+    tol = 1e3 * eps * np.max(np.abs(denom), axis=axes, keepdims=True)
+    nonzero_indices = denom > tol
+
+    # explicitly set out dtype for compatibility with SciPy < 1.4, where
+    # fftmodule will be numpy.fft which always uses float64 dtype.
+    out = np.zeros_like(denom, dtype=float_dtype)
+    out[nonzero_indices] = numerator[nonzero_indices] / denom[nonzero_indices]
+    np.clip(out, a_min=-1, a_max=1, out=out)
+
+    # Apply overlap ratio threshold
+    number_px_threshold = overlap_ratio * np.max(
+        number_overlap_masked_px, axis=axes, keepdims=True
+    )
+    out[number_overlap_masked_px < number_px_threshold] = 0.0
+
+    return out
+
+
+def _centered(arr, newshape, axes):
+    """Return the center `newshape` portion of `arr`, leaving axes not
+    in `axes` untouched."""
+    newshape = np.asarray(newshape)
+    currshape = np.array(arr.shape)
+
+    slices = [slice(None, None)] * arr.ndim
+
+    for ax in axes:
+        startind = (currshape[ax] - newshape[ax]) // 2
+        endind = startind + newshape[ax]
+        slices[ax] = slice(startind, endind)
+
+    return arr[tuple(slices)]
+
+
+def _flip(arr, axes=None):
+    """Reverse array over many axes. Generalization of arr[::-1] for many
+    dimensions. If `axes` is `None`, flip along all axes."""
+    if axes is None:
+        reverse = [slice(None, None, -1)] * arr.ndim
+    else:
+        reverse = [slice(None, None, None)] * arr.ndim
+        for axis in axes:
+            reverse[axis] = slice(None, None, -1)
+
+    return arr[tuple(reverse)]

envs/kitoverlay/skimage/registration/_optical_flow.py

@@ -0,0 +1,429 @@
+"""TV-L1 optical flow algorithm implementation."""
+
+from functools import partial
+from itertools import combinations_with_replacement
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from .._shared.filters import gaussian as gaussian_filter
+from .._shared.utils import _supported_float_type
+from ..transform import warp
+from ._optical_flow_utils import _coarse_to_fine, _get_warp_points
+
+
+def _tvl1(
+    reference_image,
+    moving_image,
+    flow0,
+    attachment,
+    tightness,
+    num_warp,
+    num_iter,
+    tol,
+    prefilter,
+):
+    """TV-L1 solver for optical flow estimation.
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    flow0 : ndarray, shape (image0.ndim, M, N[, P[, ...]])
+        Initialization for the vector field.
+    attachment : float
+        Attachment parameter. The smaller this parameter is,
+        the smoother is the solutions.
+    tightness : float
+        Tightness parameter. It should have a small value in order to
+        maintain attachment and regularization parts in
+        correspondence.
+    num_warp : int
+        Number of times moving_image is warped.
+    num_iter : int
+        Number of fixed point iteration.
+    tol : float
+        Tolerance used as stopping criterion based on the L² distance
+        between two consecutive values of (u, v).
+    prefilter : bool
+        Whether to prefilter the estimated optical flow before each
+        image warp.
+
+    Returns
+    -------
+    flow : ndarray, shape (image0.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    """
+
+    dtype = reference_image.dtype
+    grid = np.meshgrid(
+        *[np.arange(n, dtype=dtype) for n in reference_image.shape],
+        indexing='ij',
+        sparse=True,
+    )
+
+    # dt corresponds to tau in [3]_, i.e. the time step
+    dt = 0.5 / reference_image.ndim
+    reg_num_iter = 2
+    f0 = attachment * tightness
+    f1 = dt / tightness
+    tol *= reference_image.size
+
+    flow_current = flow_previous = flow0
+
+    g = np.zeros((reference_image.ndim,) + reference_image.shape, dtype=dtype)
+    proj = np.zeros(
+        (
+            reference_image.ndim,
+            reference_image.ndim,
+        )
+        + reference_image.shape,
+        dtype=dtype,
+    )
+
+    s_g = [
+        slice(None),
+    ] * g.ndim
+    s_p = [
+        slice(None),
+    ] * proj.ndim
+    s_d = [
+        slice(None),
+    ] * (proj.ndim - 2)
+
+    for _ in range(num_warp):
+        if prefilter:
+            flow_current = ndi.median_filter(
+                flow_current, [1] + reference_image.ndim * [3]
+            )
+
+        image1_warp = warp(
+            moving_image, _get_warp_points(grid, flow_current), mode='edge'
+        )
+        grad = np.array(np.gradient(image1_warp))
+        NI = (grad * grad).sum(0)
+        NI[NI == 0] = 1
+
+        rho_0 = image1_warp - reference_image - (grad * flow_current).sum(0)
+
+        for _ in range(num_iter):
+            # Data term
+
+            rho = rho_0 + (grad * flow_current).sum(0)
+
+            idx = abs(rho) <= f0 * NI
+
+            flow_auxiliary = flow_current
+
+            flow_auxiliary[:, idx] -= rho[idx] * grad[:, idx] / NI[idx]
+
+            idx = ~idx
+            srho = f0 * np.sign(rho[idx])
+            flow_auxiliary[:, idx] -= srho * grad[:, idx]
+
+            # Regularization term
+            flow_current = flow_auxiliary.copy()
+
+            for idx in range(reference_image.ndim):
+                s_p[0] = idx
+                for _ in range(reg_num_iter):
+                    for ax in range(reference_image.ndim):
+                        s_g[0] = ax
+                        s_g[ax + 1] = slice(0, -1)
+                        g[tuple(s_g)] = np.diff(flow_current[idx], axis=ax)
+                        s_g[ax + 1] = slice(None)
+
+                    norm = np.sqrt((g**2).sum(0))[np.newaxis, ...]
+                    norm *= f1
+                    norm += 1.0
+                    proj[idx] -= dt * g
+                    proj[idx] /= norm
+
+                    # d will be the (negative) divergence of proj[idx]
+                    d = -proj[idx].sum(0)
+                    for ax in range(reference_image.ndim):
+                        s_p[1] = ax
+                        s_p[ax + 2] = slice(0, -1)
+                        s_d[ax] = slice(1, None)
+                        d[tuple(s_d)] += proj[tuple(s_p)]
+                        s_p[ax + 2] = slice(None)
+                        s_d[ax] = slice(None)
+
+                    flow_current[idx] = flow_auxiliary[idx] + d
+
+        flow_previous -= flow_current  # The difference as stopping criteria
+        if (flow_previous * flow_previous).sum() < tol:
+            break
+
+        flow_previous = flow_current
+
+    return flow_current
+
+
+def optical_flow_tvl1(
+    reference_image,
+    moving_image,
+    *,
+    attachment=15,
+    tightness=0.3,
+    num_warp=5,
+    num_iter=10,
+    tol=1e-4,
+    prefilter=False,
+    dtype=np.float32,
+):
+    r"""Coarse to fine optical flow estimator.
+
+    The TV-L1 solver is applied at each level of the image
+    pyramid. TV-L1 is a popular algorithm for optical flow estimation
+    introduced by Zack et al. [1]_, improved in [2]_ and detailed in [3]_.
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    attachment : float, optional
+        Attachment parameter (:math:`\lambda` in [1]_). The smaller
+        this parameter is, the smoother the returned result will be.
+    tightness : float, optional
+        Tightness parameter (:math:`\theta` in [1]_). It should have
+        a small value in order to maintain attachment and
+        regularization parts in correspondence.
+    num_warp : int, optional
+        Number of times moving_image is warped.
+    num_iter : int, optional
+        Number of fixed point iteration.
+    tol : float, optional
+        Tolerance used as stopping criterion based on the L² distance
+        between two consecutive values of (u, v).
+    prefilter : bool, optional
+        Whether to prefilter the estimated optical flow before each
+        image warp. When True, a median filter with window size 3
+        along each axis is applied. This helps to remove potential
+        outliers.
+    dtype : dtype, optional
+        Output data type: must be floating point. Single precision
+        provides good results and saves memory usage and computation
+        time compared to double precision.
+
+    Returns
+    -------
+    flow : ndarray, shape (image0.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    Notes
+    -----
+    Color images are not supported.
+
+    References
+    ----------
+    .. [1] Zach, C., Pock, T., & Bischof, H. (2007, September). A
+       duality based approach for realtime TV-L 1 optical flow. In Joint
+       pattern recognition symposium (pp. 214-223). Springer, Berlin,
+       Heidelberg. :DOI:`10.1007/978-3-540-74936-3_22`
+    .. [2] Wedel, A., Pock, T., Zach, C., Bischof, H., & Cremers,
+       D. (2009). An improved algorithm for TV-L 1 optical flow. In
+       Statistical and geometrical approaches to visual motion analysis
+       (pp. 23-45). Springer, Berlin, Heidelberg.
+       :DOI:`10.1007/978-3-642-03061-1_2`
+    .. [3] Pérez, J. S., Meinhardt-Llopis, E., & Facciolo,
+       G. (2013). TV-L1 optical flow estimation. Image Processing On
+       Line, 2013, 137-150. :DOI:`10.5201/ipol.2013.26`
+
+    Examples
+    --------
+    >>> from skimage.color import rgb2gray
+    >>> from skimage.data import stereo_motorcycle
+    >>> from skimage.registration import optical_flow_tvl1
+    >>> image0, image1, disp = stereo_motorcycle()
+    >>> # --- Convert the images to gray level: color is not supported.
+    >>> image0 = rgb2gray(image0)
+    >>> image1 = rgb2gray(image1)
+    >>> flow = optical_flow_tvl1(image1, image0)
+
+    """
+
+    solver = partial(
+        _tvl1,
+        attachment=attachment,
+        tightness=tightness,
+        num_warp=num_warp,
+        num_iter=num_iter,
+        tol=tol,
+        prefilter=prefilter,
+    )
+
+    if np.dtype(dtype) != _supported_float_type(dtype):
+        msg = f"dtype={dtype} is not supported. Try 'float32' or 'float64.'"
+        raise ValueError(msg)
+
+    return _coarse_to_fine(reference_image, moving_image, solver, dtype=dtype)
+
+
+def _ilk(reference_image, moving_image, flow0, radius, num_warp, gaussian, prefilter):
+    """Iterative Lucas-Kanade (iLK) solver for optical flow estimation.
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    flow0 : ndarray, shape (reference_image.ndim, M, N[, P[, ...]])
+        Initialization for the vector field.
+    radius : int
+        Radius of the window considered around each pixel.
+    num_warp : int
+        Number of times moving_image is warped.
+    gaussian : bool
+        if True, a gaussian kernel is used for the local
+        integration. Otherwise, a uniform kernel is used.
+    prefilter : bool
+        Whether to prefilter the estimated optical flow before each
+        image warp. This helps to remove potential outliers.
+
+    Returns
+    -------
+    flow : ndarray, shape (reference_image.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    """
+    dtype = reference_image.dtype
+    ndim = reference_image.ndim
+    size = 2 * radius + 1
+
+    if gaussian:
+        sigma = ndim * (size / 4,)
+        filter_func = partial(gaussian_filter, sigma=sigma, mode='mirror')
+    else:
+        filter_func = partial(ndi.uniform_filter, size=ndim * (size,), mode='mirror')
+
+    flow = flow0
+    # For each pixel location (i, j), the optical flow X = flow[:, i, j]
+    # is the solution of the ndim x ndim linear system
+    # A[i, j] * X = b[i, j]
+    A = np.zeros(reference_image.shape + (ndim, ndim), dtype=dtype)
+    b = np.zeros(reference_image.shape + (ndim, 1), dtype=dtype)
+
+    grid = np.meshgrid(
+        *[np.arange(n, dtype=dtype) for n in reference_image.shape],
+        indexing='ij',
+        sparse=True,
+    )
+
+    for _ in range(num_warp):
+        if prefilter:
+            flow = ndi.median_filter(flow, (1,) + ndim * (3,))
+
+        moving_image_warp = warp(
+            moving_image, _get_warp_points(grid, flow), mode='edge'
+        )
+        grad = np.stack(np.gradient(moving_image_warp), axis=0)
+        error_image = (grad * flow).sum(axis=0) + reference_image - moving_image_warp
+
+        # Local linear systems creation
+        for i, j in combinations_with_replacement(range(ndim), 2):
+            A[..., i, j] = A[..., j, i] = filter_func(grad[i] * grad[j])
+
+        for i in range(ndim):
+            b[..., i, 0] = filter_func(grad[i] * error_image)
+
+        # Don't consider badly conditioned linear systems
+        idx = abs(np.linalg.det(A)) < 1e-14
+        A[idx] = np.eye(ndim, dtype=dtype)
+        b[idx] = 0
+
+        # Solve the local linear systems
+        flow = np.moveaxis(np.linalg.solve(A, b)[..., 0], ndim, 0)
+
+    return flow
+
+
+def optical_flow_ilk(
+    reference_image,
+    moving_image,
+    *,
+    radius=7,
+    num_warp=10,
+    gaussian=False,
+    prefilter=False,
+    dtype=np.float32,
+):
+    """Coarse to fine optical flow estimator.
+
+    The iterative Lucas-Kanade (iLK) solver is applied at each level
+    of the image pyramid. iLK [1]_ is a fast and robust alternative to
+    TVL1 algorithm although less accurate for rendering flat surfaces
+    and object boundaries (see [2]_).
+
+    Parameters
+    ----------
+    reference_image : ndarray, shape (M, N[, P[, ...]])
+        The first grayscale image of the sequence.
+    moving_image : ndarray, shape (M, N[, P[, ...]])
+        The second grayscale image of the sequence.
+    radius : int, optional
+        Radius of the window considered around each pixel.
+    num_warp : int, optional
+        Number of times moving_image is warped.
+    gaussian : bool, optional
+        If True, a Gaussian kernel is used for the local
+        integration. Otherwise, a uniform kernel is used.
+    prefilter : bool, optional
+        Whether to prefilter the estimated optical flow before each
+        image warp. When True, a median filter with window size 3
+        along each axis is applied. This helps to remove potential
+        outliers.
+    dtype : dtype, optional
+        Output data type: must be floating point. Single precision
+        provides good results and saves memory usage and computation
+        time compared to double precision.
+
+    Returns
+    -------
+    flow : ndarray, shape (reference_image.ndim, M, N[, P[, ...]])
+        The estimated optical flow components for each axis.
+
+    Notes
+    -----
+    - The implemented algorithm is described in **Table2** of [1]_.
+    - Color images are not supported.
+
+    References
+    ----------
+    .. [1] Le Besnerais, G., & Champagnat, F. (2005, September). Dense
+       optical flow by iterative local window registration. In IEEE
+       International Conference on Image Processing 2005 (Vol. 1,
+       pp. I-137). IEEE. :DOI:`10.1109/ICIP.2005.1529706`
+    .. [2] Plyer, A., Le Besnerais, G., & Champagnat,
+       F. (2016). Massively parallel Lucas Kanade optical flow for
+       real-time video processing applications. Journal of Real-Time
+       Image Processing, 11(4), 713-730. :DOI:`10.1007/s11554-014-0423-0`
+
+    Examples
+    --------
+    >>> from skimage.color import rgb2gray
+    >>> from skimage.data import stereo_motorcycle
+    >>> from skimage.registration import optical_flow_ilk
+    >>> reference_image, moving_image, disp = stereo_motorcycle()
+    >>> # --- Convert the images to gray level: color is not supported.
+    >>> reference_image = rgb2gray(reference_image)
+    >>> moving_image = rgb2gray(moving_image)
+    >>> flow = optical_flow_ilk(moving_image, reference_image)
+
+    """
+
+    solver = partial(
+        _ilk, radius=radius, num_warp=num_warp, gaussian=gaussian, prefilter=prefilter
+    )
+
+    if np.dtype(dtype) != _supported_float_type(dtype):
+        msg = f"dtype={dtype} is not supported. Try 'float32' or 'float64.'"
+        raise ValueError(msg)
+
+    return _coarse_to_fine(reference_image, moving_image, solver, dtype=dtype)