Add files using upload-large-folder tool

envs/kitoverlay/skimage/data/README.txt

@@ -0,0 +1,9 @@
+This directory contains sample data from scikit-image.
+
+By default, it only contains a small subset of the entire dataset.
+
+The full detaset can be downloaded by using the following commands from
+a python console.
+
+  >>> from skimage.data import download_all
+  >>> download_all()

envs/kitoverlay/skimage/data/__init__.py

@@ -0,0 +1,13 @@
+"""Example images and datasets.
+
+A curated set of general purpose and scientific images used in tests, examples,
+and documentation.
+
+Newer datasets are no longer included as part of the package, but are
+downloaded on demand. To make data available offline, use :func:`download_all`.
+
+"""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/data/__init__.pyi

@@ -0,0 +1,88 @@
+__all__ = [
+    'astronaut',
+    'binary_blobs',
+    'brain',
+    'brick',
+    'camera',
+    'cat',
+    'cell',
+    'cells3d',
+    'checkerboard',
+    'chelsea',
+    'clock',
+    'coffee',
+    'coins',
+    'colorwheel',
+    'data_dir',
+    'download_all',
+    'eagle',
+    'file_hash',
+    'grass',
+    'gravel',
+    'horse',
+    'hubble_deep_field',
+    'human_mitosis',
+    'immunohistochemistry',
+    'kidney',
+    'lbp_frontal_face_cascade_filename',
+    'lfw_subset',
+    'lily',
+    'logo',
+    'microaneurysms',
+    'moon',
+    'nickel_solidification',
+    'page',
+    'protein_transport',
+    'retina',
+    'rocket',
+    'shepp_logan_phantom',
+    'skin',
+    'stereo_motorcycle',
+    'text',
+    'vortex',
+]
+
+from ._binary_blobs import binary_blobs
+from ._fetchers import (
+    astronaut,
+    brain,
+    brick,
+    camera,
+    cat,
+    cell,
+    cells3d,
+    checkerboard,
+    chelsea,
+    clock,
+    coffee,
+    coins,
+    colorwheel,
+    data_dir,
+    download_all,
+    eagle,
+    file_hash,
+    grass,
+    gravel,
+    horse,
+    hubble_deep_field,
+    human_mitosis,
+    immunohistochemistry,
+    kidney,
+    lbp_frontal_face_cascade_filename,
+    lfw_subset,
+    lily,
+    logo,
+    microaneurysms,
+    moon,
+    nickel_solidification,
+    page,
+    palisades_of_vogt,
+    protein_transport,
+    retina,
+    rocket,
+    shepp_logan_phantom,
+    skin,
+    stereo_motorcycle,
+    text,
+    vortex,
+)

envs/kitoverlay/skimage/data/_binary_blobs.py

@@ -0,0 +1,106 @@
+import warnings
+
+import numpy as np
+
+from .._shared.filters import gaussian
+
+
+def binary_blobs(
+    length=512,
+    blob_size_fraction=0.1,
+    n_dim=2,
+    volume_fraction=0.5,
+    rng=None,
+    *,
+    boundary_mode='nearest',
+):
+    """
+    Generate synthetic binary image with several rounded blob-like objects.
+
+    Parameters
+    ----------
+    length : int, optional
+        Linear size of output image.
+    blob_size_fraction : float, optional
+        Typical linear size of blob, as a fraction of ``length``, should be
+        smaller than 1.
+    n_dim : int, optional
+        Number of dimensions of output image.
+    volume_fraction : float, default 0.5
+        Fraction of image pixels covered by the blobs (where the output is 1).
+        Should be in [0, 1].
+    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.
+    boundary_mode : {'nearest', 'wrap'}, optional
+        The blobs are created by smoothing and then thresholding an
+        array consisting of ones at seed positions. This mode determines which values are
+        filled in when the smoothing kernel overlaps the seed array's boundary.
+
+        'nearest' (`a a a a | a b c d | d d d d`)
+            By default, when applying the Gaussian filter, the seed array is extended by replicating the last
+            boundary value. This will increase the size of blobs whose seed or
+            center lies exactly on the edge.
+
+        'wrap' (`a b c d | a b c d | a b c d`)
+            The seed array is extended by wrapping around to the opposite edge.
+            The resulting blob array can be tiled and blobs will be contiguous and
+            have smooth edges across tile boundaries.
+
+    boundary_mode : str, default "nearest"
+        The `mode` parameter passed to the Gaussian filter.
+        Use "wrap" for periodic boundary conditions.
+
+    Returns
+    -------
+    blobs : ndarray of bools
+        Output binary image
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> data.binary_blobs(length=5, blob_size_fraction=0.2)  # doctest: +SKIP
+    array([[ True, False,  True,  True,  True],
+           [ True,  True,  True, False,  True],
+           [False,  True, False,  True,  True],
+           [ True, False, False,  True,  True],
+           [ True, False, False, False,  True]])
+    >>> blobs = data.binary_blobs(length=256, blob_size_fraction=0.1)
+    >>> # Finer structures
+    >>> blobs = data.binary_blobs(length=256, blob_size_fraction=0.05)
+    >>> # Blobs cover a smaller volume fraction of the image
+    >>> blobs = data.binary_blobs(length=256, volume_fraction=0.3)
+    """
+    if boundary_mode not in {"nearest", "wrap"}:
+        raise ValueError(f"unsupported `boundary_mode`: {boundary_mode!r}")
+
+    blob_size = blob_size_fraction * length
+    if blob_size < 0.1:
+        clamped_size_fraction = 0.1 / length
+        clamped_blob_size = clamped_size_fraction * length
+        warnings.warn(
+            f"`{blob_size_fraction=}` together with `{length=}` would result in a blob "
+            f"size of {blob_size} pixels. Small blob sizes likely lead to unexpected "
+            f"results! "
+            f"Clamping to `blob_size_fraction={clamped_size_fraction}` and a blob size "
+            f"of {clamped_blob_size} pixels to avoid allocating excessive memory.",
+            category=RuntimeWarning,
+            stacklevel=2,
+        )
+        blob_size_fraction = clamped_size_fraction
+
+    rs = np.random.default_rng(rng)
+    shape = tuple([length] * n_dim)
+    mask = np.zeros(shape)
+    n_pts = max(int(1.0 / blob_size_fraction) ** n_dim, 1)
+    points = (length * rs.random((n_dim, n_pts))).astype(int)
+    mask[tuple(indices for indices in points)] = 1
+    mask = gaussian(
+        mask,
+        sigma=0.25 * length * blob_size_fraction,
+        preserve_range=False,
+        mode=boundary_mode,
+    )
+    threshold = np.percentile(mask, 100 * (1 - volume_fraction))
+    return np.logical_not(mask < threshold)

envs/kitoverlay/skimage/data/_fetchers.py

@@ -0,0 +1,1271 @@
+"""Standard test images.
+
+For more images, see
+
+ - http://sipi.usc.edu/database/database.php
+
+"""
+
+import numpy as np
+import shutil
+
+from ..util.dtype import img_as_bool
+from ._registry import registry, registry_urls
+
+from .. import __version__
+
+import os.path as osp
+import os
+
+_LEGACY_DATA_DIR = osp.dirname(__file__)
+_DISTRIBUTION_DIR = osp.dirname(_LEGACY_DATA_DIR)
+
+try:
+    from pooch import file_hash
+except ModuleNotFoundError:
+    # Function taken from
+    # https://github.com/fatiando/pooch/blob/master/pooch/utils.py
+    def file_hash(fname, alg="sha256"):
+        """
+        Calculate the hash of a given file.
+        Useful for checking if a file has changed or been corrupted.
+        Parameters
+        ----------
+        fname : str
+            The name of the file.
+        alg : str
+            The type of the hashing algorithm
+        Returns
+        -------
+        hash : str
+            The hash of the file.
+        Examples
+        --------
+        >>> fname = "test-file-for-hash.txt"
+        >>> with open(fname, "w") as f:
+        ...     __ = f.write("content of the file")
+        >>> print(file_hash(fname))
+        0fc74468e6a9a829f103d069aeb2bb4f8646bad58bf146bb0e3379b759ec4a00
+        >>> import os
+        >>> os.remove(fname)
+        """
+        import hashlib
+
+        if alg not in hashlib.algorithms_available:
+            raise ValueError(f'Algorithm \'{alg}\' not available in hashlib')
+        # Calculate the hash in chunks to avoid overloading the memory
+        chunksize = 65536
+        hasher = hashlib.new(alg)
+        with open(fname, "rb") as fin:
+            buff = fin.read(chunksize)
+            while buff:
+                hasher.update(buff)
+                buff = fin.read(chunksize)
+        return hasher.hexdigest()
+
+
+def _has_hash(path, expected_hash):
+    """Check if the provided path has the expected hash."""
+    if not osp.exists(path):
+        return False
+    return file_hash(path) == expected_hash
+
+
+def _create_image_fetcher(prefix=None):
+    try:
+        import pooch
+
+        # older versions of Pooch don't have a __version__ attribute
+        if not hasattr(pooch, '__version__'):
+            retry = {}
+        else:
+            retry = {'retry_if_failed': 3}
+    except ImportError:
+        # Without pooch, fallback on the standard data directory
+        # which for now, includes a few limited data samples
+        return None, _LEGACY_DATA_DIR
+
+    # Pooch expects a `+` to exist in development versions.
+    # Since scikit-image doesn't follow that convention, we have to manually
+    # remove `.dev` with a `+` if it exists.
+    # This helps pooch understand that it should look in master
+    # to find the required files
+    if '+git' in __version__:
+        skimage_version_for_pooch = __version__.replace('.dev0+git', '+git')
+    else:
+        skimage_version_for_pooch = __version__.replace('.dev', '+')
+
+    if '+' in skimage_version_for_pooch:
+        if prefix is not None:
+            url = (
+                "https://github.com/scikit-image/scikit-image/raw/"
+                "{version}/tests/skimage/"
+            )
+        else:
+            url = (
+                "https://github.com/scikit-image/scikit-image/raw/"
+                "{version}/src/skimage/"
+            )
+    else:
+        if prefix is not None:
+            url = (
+                "https://github.com/scikit-image/scikit-image/raw/"
+                "v{version}/tests/skimage/"
+            )
+        else:
+            url = (
+                "https://github.com/scikit-image/scikit-image/raw/"
+                "v{version}/src/skimage/"
+            )
+
+    # Create a new friend to manage your sample data storage
+    image_fetcher = pooch.create(
+        # Pooch uses appdirs to select an appropriate directory for the cache
+        # on each platform.
+        # https://github.com/ActiveState/appdirs
+        # On linux this converges to
+        # '$HOME/.cache/scikit-image'
+        # With a version qualifier
+        path=pooch.os_cache("scikit-image"),
+        base_url=url,
+        version=skimage_version_for_pooch,
+        version_dev="main",
+        env="SKIMAGE_DATADIR",
+        registry=registry,
+        urls=registry_urls,
+        # Note: this should read `retry_if_failed=3,`, but we generate that
+        # dynamically at import time above, in case installed pooch is a less
+        # recent version
+        **retry,
+    )
+
+    data_dir = osp.join(str(image_fetcher.abspath), 'data')
+    return image_fetcher, data_dir
+
+
+_image_fetcher, data_dir = _create_image_fetcher(prefix='tests')
+
+
+def _skip_pytest_case_requiring_pooch(data_filename):
+    """If a test case is calling pooch, skip it.
+
+    This running the test suite in environments without internet
+    access, skipping only the tests that try to fetch external data.
+    """
+
+    # Check if pytest is currently running.
+    # Packagers might use pytest to run the tests suite, but may not
+    # want to run it online with pooch as a dependency.
+    # As such, we will avoid failing the test, and silently skipping it.
+    if 'PYTEST_CURRENT_TEST' in os.environ:
+        # https://docs.pytest.org/en/latest/example/simple.html#pytest-current-test-environment-variable
+        import pytest
+
+        # Pytest skip raises an exception that allows the
+        # tests to be skipped
+        pytest.skip(f'Unable to download {data_filename}', allow_module_level=True)
+
+
+def _ensure_cache_dir(*, target_dir):
+    """Prepare local cache directory if it doesn't exist already.
+
+    Creates::
+
+        /path/to/target_dir/
+                 └─ data/
+                    └─ README.txt
+    """
+    os.makedirs(osp.join(target_dir, "data"), exist_ok=True)
+    readme_src = osp.join(_DISTRIBUTION_DIR, "data/README.txt")
+    readme_dest = osp.join(target_dir, "data/README.txt")
+    if not osp.exists(readme_dest):
+        shutil.copy2(readme_src, readme_dest)
+
+
+def _fetch(data_filename, prefix=None):
+    """Fetch a given data file from either the local cache or the repository.
+
+    This function provides the path location of the data file given
+    its name in the scikit-image repository. If a data file is not included in the
+    distribution and pooch is available, it is downloaded and cached.
+
+    Parameters
+    ----------
+    data_filename : str
+        Name of the file in the scikit-image repository. e.g.
+        'restoration/camera_rl.npy'.
+
+    Returns
+    -------
+    file_path : str
+        Path of the local file.
+
+    Raises
+    ------
+    KeyError:
+        If the filename is not known to the scikit-image distribution.
+
+    ModuleNotFoundError:
+        If the filename is known to the scikit-image distribution but pooch
+        is not installed.
+
+    ConnectionError:
+        If scikit-image is unable to connect to the internet but the
+        dataset has not been downloaded yet.
+    """
+    if prefix is not None:
+        return osp.join("tests", "skimage", data_filename)
+
+    expected_hash = registry[data_filename]
+    if _image_fetcher is None:
+        cache_dir = osp.dirname(data_dir)
+    else:
+        cache_dir = str(_image_fetcher.abspath)
+
+    # Case 1: the file is already cached in `data_cache_dir`
+    cached_file_path = osp.join(cache_dir, data_filename)
+    if _has_hash(cached_file_path, expected_hash):
+        # Nothing to be done, file is where it is expected to be
+        return cached_file_path
+
+    # Case 2: file is present in `legacy_data_dir`
+    legacy_file_path = osp.join(_DISTRIBUTION_DIR, data_filename)
+    if _has_hash(legacy_file_path, expected_hash):
+        return legacy_file_path
+
+    # Case 3: file is not present locally
+    if _image_fetcher is None:
+        _skip_pytest_case_requiring_pooch(data_filename)
+        raise ModuleNotFoundError(
+            "The requested file is part of the scikit-image distribution, "
+            "but requires the installation of an optional dependency, pooch. "
+            "To install pooch, use your preferred python package manager. "
+            "Follow installation instruction found at "
+            "https://scikit-image.org/docs/stable/user_guide/install.html"
+        )
+    # Download the data with pooch which caches it automatically
+    _ensure_cache_dir(target_dir=cache_dir)
+    try:
+        cached_file_path = _image_fetcher.fetch(data_filename)
+        return cached_file_path
+    except ConnectionError as err:
+        _skip_pytest_case_requiring_pooch(data_filename)
+        # If we decide in the future to suppress the underlying 'requests'
+        # error, change this to `raise ... from None`. See PEP 3134.
+        raise ConnectionError(
+            'Tried to download a scikit-image dataset, but no internet '
+            'connection is available. To avoid this message in the '
+            'future, try `skimage.data.download_all()` when you are '
+            'connected to the internet.'
+        ) from err
+
+
+def download_all(directory=None):
+    """Download all datasets for use with scikit-image offline.
+
+    Scikit-image datasets are no longer shipped with the library by default.
+    This allows us to use higher quality datasets, while keeping the
+    library download size small.
+
+    This function requires the installation of an optional dependency, pooch,
+    to download the full dataset. Follow installation instruction found at
+
+        https://scikit-image.org/docs/stable/user_guide/install.html
+
+    Call this function to download all sample images making them available
+    offline on your machine.
+
+    Parameters
+    ----------
+    directory : path-like, optional
+        The directory where the dataset should be stored.
+
+    Raises
+    ------
+    ModuleNotFoundError:
+        If pooch is not install, this error will be raised.
+
+    Notes
+    -----
+    scikit-image will only search for images stored in the default directory.
+    Only specify the directory if you wish to download the images to your own
+    folder for a particular reason. You can access the location of the default
+    data directory by inspecting the variable ``skimage.data.data_dir``.
+    """
+
+    if _image_fetcher is None:
+        raise ModuleNotFoundError(
+            "To download all package data, scikit-image needs an optional "
+            "dependency, pooch."
+            "To install pooch, follow our installation instructions found at "
+            "https://scikit-image.org/docs/stable/user_guide/install.html"
+        )
+    # Consider moving this kind of logic to Pooch
+    old_dir = _image_fetcher.path
+    try:
+        if directory is not None:
+            directory = osp.expanduser(directory)
+            _image_fetcher.path = directory
+        _ensure_cache_dir(target_dir=_image_fetcher.path)
+
+        for data_filename in _image_fetcher.registry:
+            file_path = _fetch(data_filename)
+
+            # Copy to `directory` or implicit cache if it is not already there
+            if not file_path.startswith(str(_image_fetcher.path)):
+                dest_path = osp.join(_image_fetcher.path, data_filename)
+                os.makedirs(osp.dirname(dest_path), exist_ok=True)
+                shutil.copy2(file_path, dest_path)
+    finally:
+        _image_fetcher.path = old_dir
+
+
+def lbp_frontal_face_cascade_filename():
+    """Return the path to the XML file containing the weak classifier cascade.
+
+    These classifiers were trained using LBP features. The file is part
+    of the OpenCV repository [1]_.
+
+    References
+    ----------
+    .. [1] OpenCV lbpcascade trained files
+           https://github.com/opencv/opencv/tree/master/data/lbpcascades
+    """
+
+    return _fetch('data/lbpcascade_frontalface_opencv.xml')
+
+
+def _load(f, as_gray=False):
+    """Load an image file located in the data directory.
+
+    Parameters
+    ----------
+    f : string
+        File name.
+    as_gray : bool, optional
+        Whether to convert the image to grayscale.
+
+    Returns
+    -------
+    img : ndarray
+        Image loaded from ``skimage.data_dir``.
+    """
+    # importing io is quite slow since it scans all the backends
+    # we lazy import it here
+    from ..io import imread
+
+    return imread(_fetch(f), as_gray=as_gray)
+
+
+def camera():
+    """Gray-level "camera" image.
+
+    Can be used for segmentation and denoising examples.
+
+    Returns
+    -------
+    camera : (512, 512) uint8 ndarray
+        Camera image.
+
+    Notes
+    -----
+    No copyright restrictions. CC0 by the photographer (Lav Varshney).
+
+    .. versionchanged:: 0.18
+        This image was replaced due to copyright restrictions. For more
+        information, please see [1]_.
+
+    References
+    ----------
+    .. [1] https://github.com/scikit-image/scikit-image/issues/3927
+    """
+    return _load("data/camera.png")
+
+
+def eagle():
+    """A golden eagle.
+
+    Suitable for examples on segmentation, Hough transforms, and corner
+    detection.
+
+    Notes
+    -----
+    No copyright restrictions. CC0 by the photographer (Dayane Machado).
+
+    Returns
+    -------
+    eagle : (2019, 1826) uint8 ndarray
+        Eagle image.
+    """
+    return _load("data/eagle.png")
+
+
+def astronaut():
+    """Color image of the astronaut Eileen Collins.
+
+    Photograph of Eileen Collins, an American astronaut. She was selected
+    as an astronaut in 1992 and first piloted the space shuttle STS-63 in
+    1995. She retired in 2006 after spending a total of 38 days, 8 hours
+    and 10 minutes in outer space.
+
+    This image was downloaded from the NASA Great Images database
+    <https://flic.kr/p/r9qvLn>`__.
+
+    No known copyright restrictions, released into the public domain.
+
+    Returns
+    -------
+    astronaut : (512, 512, 3) uint8 ndarray
+        Astronaut image.
+    """
+
+    return _load("data/astronaut.png")
+
+
+def brick():
+    """Brick wall.
+
+    Returns
+    -------
+    brick : (512, 512) uint8 image
+        A small section of a brick wall.
+
+    Notes
+    -----
+    The original image was downloaded from
+    `CC0Textures <https://cc0textures.com/view.php?tex=Bricks25>`_ and licensed
+    under the Creative Commons CC0 License.
+
+    A perspective transform was then applied to the image, prior to
+    rotating it by 90 degrees, cropping and scaling it to obtain the final
+    image.
+    """
+
+    """
+    The following code was used to obtain the final image.
+
+    >>> import sys; print(sys.version)
+    >>> import platform; print(platform.platform())
+    >>> import skimage; print(f'scikit-image version: {skimage.__version__}')
+    >>> import numpy; print(f'numpy version: {numpy.__version__}')
+    >>> import imageio; print(f'imageio version {imageio.__version__}')
+    3.7.3 | packaged by conda-forge | (default, Jul  1 2019, 21:52:21)
+    [GCC 7.3.0]
+    Linux-5.0.0-20-generic-x86_64-with-debian-buster-sid
+    scikit-image version: 0.16.dev0
+    numpy version: 1.16.4
+    imageio version 2.4.1
+
+    >>> import requests
+    >>> import zipfile
+    >>> url = 'https://cdn.struffelproductions.com/file/cc0textures/Bricks25/%5B2K%5DBricks25.zip'
+    >>> r = requests.get(url)
+    >>> with open('[2K]Bricks25.zip', 'bw') as f:
+    ...     f.write(r.content)
+    >>> with zipfile.ZipFile('[2K]Bricks25.zip') as z:
+    ... z.extract('Bricks25_col.jpg')
+
+    >>> from numpy.linalg import inv
+    >>> from skimage.transform import rescale, warp, rotate
+    >>> from skimage.color import rgb2gray
+    >>> from imageio import imread, imwrite
+    >>> from skimage import img_as_ubyte
+    >>> import numpy as np
+
+
+    >>> # Obtained playing around with GIMP 2.10 with their perspective tool
+    >>> H = inv(np.asarray([[ 0.54764, -0.00219, 0],
+    ...                     [-0.12822,  0.54688, 0],
+    ...                     [-0.00022,        0, 1]]))
+
+
+    >>> brick_orig = imread('Bricks25_col.jpg')
+    >>> brick = warp(brick_orig, H)
+    >>> brick = rescale(brick[:1024, :1024], (0.5, 0.5, 1))
+    >>> brick = rotate(brick, -90)
+    >>> imwrite('brick.png', img_as_ubyte(rgb2gray(brick)))
+    """
+    return _load("data/brick.png", as_gray=True)
+
+
+def grass():
+    """Grass.
+
+    Returns
+    -------
+    grass : (512, 512) uint8 image
+        Some grass.
+
+    Notes
+    -----
+    The original image was downloaded from
+    `DeviantArt <https://www.deviantart.com/linolafett/art/Grass-01-434853879>`__
+    and licensed under the Creative Commons CC0 License.
+
+    The downloaded image was cropped to include a region of ``(512, 512)``
+    pixels around the top left corner, converted to grayscale, then to uint8
+    prior to saving the result in PNG format.
+
+    """
+
+    """
+    The following code was used to obtain the final image.
+
+    >>> import sys; print(sys.version)
+    >>> import platform; print(platform.platform())
+    >>> import skimage; print(f'scikit-image version: {skimage.__version__}')
+    >>> import numpy; print(f'numpy version: {numpy.__version__}')
+    >>> import imageio; print(f'imageio version {imageio.__version__}')
+    3.7.3 | packaged by conda-forge | (default, Jul  1 2019, 21:52:21)
+    [GCC 7.3.0]
+    Linux-5.0.0-20-generic-x86_64-with-debian-buster-sid
+    scikit-image version: 0.16.dev0
+    numpy version: 1.16.4
+    imageio version 2.4.1
+
+    >>> import requests
+    >>> import zipfile
+    >>> url = 'https://images-wixmp-ed30a86b8c4ca887773594c2.wixmp.com/f/a407467e-4ff0-49f1-923f-c9e388e84612/d76wfef-2878b78d-5dce-43f9-be36-26ec9bc0df3b.jpg?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1cm46YXBwOjdlMGQxODg5ODIyNjQzNzNhNWYwZDQxNWVhMGQyNmUwIiwiaXNzIjoidXJuOmFwcDo3ZTBkMTg4OTgyMjY0MzczYTVmMGQ0MTVlYTBkMjZlMCIsIm9iaiI6W1t7InBhdGgiOiJcL2ZcL2E0MDc0NjdlLTRmZjAtNDlmMS05MjNmLWM5ZTM4OGU4NDYxMlwvZDc2d2ZlZi0yODc4Yjc4ZC01ZGNlLTQzZjktYmUzNi0yNmVjOWJjMGRmM2IuanBnIn1dXSwiYXVkIjpbInVybjpzZXJ2aWNlOmZpbGUuZG93bmxvYWQiXX0.98hIcOTCqXWQ67Ec5bM5eovKEn2p91mWB3uedH61ynI'
+    >>> r = requests.get(url)
+    >>> with open('grass_orig.jpg', 'bw') as f:
+    ...     f.write(r.content)
+    >>> grass_orig = imageio.imread('grass_orig.jpg')
+    >>> grass = skimage.img_as_ubyte(skimage.color.rgb2gray(grass_orig[:512, :512]))
+    >>> imageio.imwrite('grass.png', grass)
+    """
+    return _load("data/grass.png", as_gray=True)
+
+
+def gravel():
+    """Gravel
+
+    Returns
+    -------
+    gravel : (512, 512) uint8 image
+        Grayscale gravel sample.
+
+    Notes
+    -----
+    The original image was downloaded from
+    `CC0Textures <https://cc0textures.com/view.php?tex=Gravel04>`__ and
+    licensed under the Creative Commons CC0 License.
+
+    The downloaded image was then rescaled to ``(1024, 1024)``, then the
+    top left ``(512, 512)`` pixel region  was cropped prior to converting the
+    image to grayscale and uint8 data type. The result was saved using the
+    PNG format.
+    """
+
+    """
+    The following code was used to obtain the final image.
+
+    >>> import sys; print(sys.version)
+    >>> import platform; print(platform.platform())
+    >>> import skimage; print(f'scikit-image version: {skimage.__version__}')
+    >>> import numpy; print(f'numpy version: {numpy.__version__}')
+    >>> import imageio; print(f'imageio version {imageio.__version__}')
+    3.7.3 | packaged by conda-forge | (default, Jul  1 2019, 21:52:21)
+    [GCC 7.3.0]
+    Linux-5.0.0-20-generic-x86_64-with-debian-buster-sid
+    scikit-image version: 0.16.dev0
+    numpy version: 1.16.4
+    imageio version 2.4.1
+
+    >>> import requests
+    >>> import zipfile
+
+    >>> url = 'https://cdn.struffelproductions.com/file/cc0textures/Gravel04/%5B2K%5DGravel04.zip'
+    >>> r = requests.get(url)
+    >>> with open('[2K]Gravel04.zip', 'bw') as f:
+    ...     f.write(r.content)
+
+    >>> with zipfile.ZipFile('[2K]Gravel04.zip') as z:
+    ...     z.extract('Gravel04_col.jpg')
+
+    >>> from skimage.transform import resize
+    >>> gravel_orig = imageio.imread('Gravel04_col.jpg')
+    >>> gravel = resize(gravel_orig, (1024, 1024))
+    >>> gravel = skimage.img_as_ubyte(skimage.color.rgb2gray(gravel[:512, :512]))
+    >>> imageio.imwrite('gravel.png', gravel)
+    """
+    return _load("data/gravel.png", as_gray=True)
+
+
+def text():
+    """Gray-level "text" image used for corner detection.
+
+    Notes
+    -----
+    This image was downloaded from Wikipedia
+    <https://en.wikipedia.org/wiki/File:Corner.png>`__.
+
+    No known copyright restrictions, released into the public domain.
+
+    Returns
+    -------
+    text : (172, 448) uint8 ndarray
+        Text image.
+    """
+
+    return _load("data/text.png")
+
+
+def checkerboard():
+    """Checkerboard image.
+
+    Checkerboards are often used in image calibration, since the
+    corner-points are easy to locate.  Because of the many parallel
+    edges, they also visualise distortions particularly well.
+
+    Returns
+    -------
+    checkerboard : (200, 200) uint8 ndarray
+        Checkerboard image.
+    """
+    return _load("data/chessboard_GRAY.png")
+
+
+def cells3d():
+    """3D fluorescence microscopy image of cells.
+
+    The returned data is a 3D multichannel array with dimensions provided in
+    ``(z, c, y, x)`` order. Each voxel has a size of ``(0.29 0.26 0.26)``
+    micrometer. Channel 0 contains cell membranes, channel 1 contains nuclei.
+
+    Returns
+    -------
+    cells3d: (60, 2, 256, 256) uint16 ndarray
+        The volumetric images of cells taken with an optical microscope.
+
+    Notes
+    -----
+    The data for this was provided by the Allen Institute for Cell Science.
+
+    It has been downsampled by a factor of 4 in the row and column dimensions
+    to reduce computational time.
+
+    The microscope reports the following voxel spacing in microns:
+
+        * Original voxel size is ``(0.290, 0.065, 0.065)``.
+        * Scaling factor is ``(1, 4, 4)`` in each dimension.
+        * After rescaling the voxel size is ``(0.29 0.26 0.26)``.
+    """
+
+    return _load("data/cells3d.tif")
+
+
+def human_mitosis():
+    """Image of human cells undergoing mitosis.
+
+    Returns
+    -------
+    human_mitosis: (512, 512) uint8 ndarray
+        Data of human cells undergoing mitosis taken during the preparation
+        of the manuscript in [1]_.
+
+    Notes
+    -----
+    Copyright David Root. Licensed under CC-0 [2]_.
+
+    References
+    ----------
+    .. [1] Moffat J, Grueneberg DA, Yang X, Kim SY, Kloepfer AM, Hinkle G,
+           Piqani B, Eisenhaure TM, Luo B, Grenier JK, Carpenter AE, Foo SY,
+           Stewart SA, Stockwell BR, Hacohen N, Hahn WC, Lander ES,
+           Sabatini DM, Root DE (2006) A lentiviral RNAi library for human and
+           mouse genes applied to an arrayed viral high-content screen. Cell,
+           124(6):1283-98 / :DOI: `10.1016/j.cell.2006.01.040` PMID 16564017
+
+    .. [2] GitHub licensing discussion
+           https://github.com/CellProfiler/examples/issues/41
+
+    """
+    return _load('data/mitosis.tif')
+
+
+def cell():
+    """Cell floating in saline.
+
+    This is a quantitative phase image retrieved from a digital hologram using
+    the Python library ``qpformat``. The image shows a cell with high phase
+    value, above the background phase.
+
+    Because of a banding pattern artifact in the background, this image is a
+    good test of thresholding algorithms. The pixel spacing is 0.107 µm.
+
+    These data were part of a comparison between several refractive index
+    retrieval techniques for spherical objects as part of [1]_.
+
+    This image is CC0, dedicated to the public domain. You may copy, modify, or
+    distribute it without asking permission.
+
+    Returns
+    -------
+    cell : (660, 550) uint8 array
+        Image of a cell.
+
+    References
+    ----------
+    .. [1] Paul Müller, Mirjam Schürmann, Salvatore Girardo, Gheorghe Cojoc,
+           and Jochen Guck. "Accurate evaluation of size and refractive index
+           for spherical objects in quantitative phase imaging." Optics Express
+           26(8): 10729-10743 (2018). :DOI:`10.1364/OE.26.010729`
+    """
+    return _load('data/cell.png')
+
+
+def coins():
+    """Greek coins from Pompeii.
+
+    This image shows several coins outlined against a gray background.
+    It is especially useful in, e.g. segmentation tests, where
+    individual objects need to be identified against a background.
+    The background shares enough grey levels with the coins that a
+    simple segmentation is not sufficient.
+
+    Notes
+    -----
+    This image was downloaded from the
+    `Brooklyn Museum Collection
+    <https://www.brooklynmuseum.org/opencollection/archives/image/51611>`__.
+
+    No known copyright restrictions.
+
+    Returns
+    -------
+    coins : (303, 384) uint8 ndarray
+        Coins image.
+    """
+    return _load("data/coins.png")
+
+
+def kidney():
+    """Mouse kidney tissue.
+
+    This biological tissue on a pre-prepared slide was imaged with confocal
+    fluorescence microscopy (Nikon C1 inverted microscope).
+    Image shape is (16, 512, 512, 3). That is 512x512 pixels in X-Y,
+    16 image slices in Z, and 3 color channels
+    (emission wavelengths 450nm, 515nm, and 605nm, respectively).
+    Real-space voxel size is 1.24 microns in X-Y, and 1.25 microns in Z.
+    Data type is unsigned 16-bit integers.
+
+    Notes
+    -----
+    This image was acquired by Genevieve Buckley at Monasoh Micro Imaging in
+    2018.
+    License: CC0
+
+    Returns
+    -------
+    kidney : (16, 512, 512, 3) uint16 ndarray
+        Kidney 3D multichannel image.
+    """
+    return _load("data/kidney.tif")
+
+
+def lily():
+    """Lily of the valley plant stem.
+
+    This plant stem on a pre-prepared slide was imaged with confocal
+    fluorescence microscopy (Nikon C1 inverted microscope).
+    Image shape is (922, 922, 4). That is 922x922 pixels in X-Y,
+    with 4 color channels.
+    Real-space voxel size is 1.24 microns in X-Y.
+    Data type is unsigned 16-bit integers.
+
+    Notes
+    -----
+    This image was acquired by Genevieve Buckley at Monasoh Micro Imaging in
+    2018.
+    License: CC0
+
+    Returns
+    -------
+    lily : (922, 922, 4) uint16 ndarray
+        Lily 2D multichannel image.
+    """
+    return _load("data/lily.tif")
+
+
+def logo():
+    """Scikit-image logo, a RGBA image.
+
+    Returns
+    -------
+    logo : (500, 500, 4) uint8 ndarray
+        Logo image.
+    """
+    return _load("data/logo.png")
+
+
+def microaneurysms():
+    """Gray-level "microaneurysms" image.
+
+    Detail from an image of the retina (green channel).
+    The image is a crop of image 07_dr.JPG from the
+    High-Resolution Fundus (HRF) Image Database:
+    https://www5.cs.fau.de/research/data/fundus-images/
+
+    Notes
+    -----
+    No copyright restrictions. CC0 given by owner (Andreas Maier).
+
+    Returns
+    -------
+    microaneurysms : (102, 102) uint8 ndarray
+        Retina image with lesions.
+
+    References
+    ----------
+    .. [1] Budai, A., Bock, R, Maier, A., Hornegger, J.,
+           Michelson, G. (2013).  Robust Vessel Segmentation in Fundus
+           Images. International Journal of Biomedical Imaging, vol. 2013,
+           2013.
+           :DOI:`10.1155/2013/154860`
+    """
+    return _load("data/microaneurysms.png")
+
+
+def moon():
+    """Surface of the moon.
+
+    This low-contrast image of the surface of the moon is useful for
+    illustrating histogram equalization and contrast stretching.
+
+    Returns
+    -------
+    moon : (512, 512) uint8 ndarray
+        Moon image.
+    """
+    return _load("data/moon.png")
+
+
+def page():
+    """Scanned page.
+
+    This image of printed text is useful for demonstrations requiring uneven
+    background illumination.
+
+    Returns
+    -------
+    page : (191, 384) uint8 ndarray
+        Page image.
+    """
+    return _load("data/page.png")
+
+
+def horse():
+    """Black and white silhouette of a horse.
+
+    This image was downloaded from
+    `openclipart <http://openclipart.org/detail/158377/horse-by-marauder>`
+
+    No copyright restrictions. CC0 given by owner (Andreas Preuss (marauder)).
+
+    Returns
+    -------
+    horse : (328, 400) bool ndarray
+        Horse image.
+    """
+    return img_as_bool(_load("data/horse.png", as_gray=True))
+
+
+def clock():
+    """Motion blurred clock.
+
+    This photograph of a wall clock was taken while moving the camera in an
+    approximately horizontal direction.  It may be used to illustrate
+    inverse filters and deconvolution.
+
+    Released into the public domain by the photographer (Stefan van der Walt).
+
+    Returns
+    -------
+    clock : (300, 400) uint8 ndarray
+        Clock image.
+    """
+    return _load("data/clock_motion.png")
+
+
+def immunohistochemistry():
+    """Immunohistochemical (IHC) staining with hematoxylin counterstaining.
+
+    This picture shows colonic glands where the IHC expression of FHL2 protein
+    is revealed with DAB. Hematoxylin counterstaining is applied to enhance the
+    negative parts of the tissue.
+
+    This image was acquired at the Center for Microscopy And Molecular Imaging
+    (CMMI).
+
+    No known copyright restrictions.
+
+    Returns
+    -------
+    immunohistochemistry : (512, 512, 3) uint8 ndarray
+        Immunohistochemistry image.
+    """
+    return _load("data/ihc.png")
+
+
+def chelsea():
+    """Chelsea the cat.
+
+    An example with texture, prominent edges in horizontal and diagonal
+    directions, as well as features of differing scales.
+
+    Notes
+    -----
+    No copyright restrictions.  CC0 by the photographer (Stefan van der Walt).
+
+    Returns
+    -------
+    chelsea : (300, 451, 3) uint8 ndarray
+        Chelsea image.
+    """
+    return _load("data/chelsea.png")
+
+
+# Define an alias for chelsea that is more descriptive.
+cat = chelsea
+
+
+def coffee():
+    """Coffee cup.
+
+    This photograph is courtesy of Pikolo Espresso Bar.
+    It contains several elliptical shapes as well as varying texture (smooth
+    porcelain to coarse wood grain).
+
+    Notes
+    -----
+    No copyright restrictions.  CC0 by the photographer (Rachel Michetti).
+
+    Returns
+    -------
+    coffee : (400, 600, 3) uint8 ndarray
+        Coffee image.
+    """
+    return _load("data/coffee.png")
+
+
+def hubble_deep_field():
+    """Hubble eXtreme Deep Field.
+
+    This photograph contains the Hubble Telescope's farthest ever view of
+    the universe. It can be useful as an example for multi-scale
+    detection.
+
+    Notes
+    -----
+    This image was downloaded from
+    `HubbleSite
+    <http://hubblesite.org/newscenter/archive/releases/2012/37/image/a/>`__.
+
+    The image was captured by NASA and `may be freely used in the public domain
+    <http://www.nasa.gov/audience/formedia/features/MP_Photo_Guidelines.html>`_.
+
+    Returns
+    -------
+    hubble_deep_field : (872, 1000, 3) uint8 ndarray
+        Hubble deep field image.
+    """
+    return _load("data/hubble_deep_field.jpg")
+
+
+def retina():
+    """Human retina.
+
+    This image of a retina is useful for demonstrations requiring circular
+    images.
+
+    Notes
+    -----
+    This image was downloaded from
+    `wikimedia <https://commons.wikimedia.org/wiki/File:Fundus_photograph_of_normal_left_eye.jpg>`.
+    This file is made available under the Creative Commons CC0 1.0 Universal
+    Public Domain Dedication.
+
+    References
+    ----------
+    .. [1] Häggström, Mikael (2014). "Medical gallery of Mikael Häggström 2014".
+           WikiJournal of Medicine 1 (2). :DOI:`10.15347/wjm/2014.008`.
+           ISSN 2002-4436. Public Domain
+
+    Returns
+    -------
+    retina : (1411, 1411, 3) uint8 ndarray
+        Retina image in RGB.
+    """
+    return _load("data/retina.jpg")
+
+
+def shepp_logan_phantom():
+    """Shepp Logan Phantom.
+
+    References
+    ----------
+    .. [1] L. A. Shepp and B. F. Logan, "The Fourier reconstruction of a head
+           section," in IEEE Transactions on Nuclear Science, vol. 21,
+           no. 3, pp. 21-43, June 1974. :DOI:`10.1109/TNS.1974.6499235`
+
+    Returns
+    -------
+    phantom : (400, 400) float64 image
+        Image of the Shepp-Logan phantom in grayscale.
+    """
+    return _load("data/phantom.png", as_gray=True)
+
+
+def colorwheel():
+    """Color Wheel.
+
+    Returns
+    -------
+    colorwheel : (370, 371, 3) uint8 image
+        A colorwheel.
+    """
+    return _load("data/color.png")
+
+
+def palisades_of_vogt():
+    """Return image sequence of in-vivo tissue showing the palisades of Vogt.
+
+    In the human eye, the palisades of Vogt are normal features of the corneal
+    limbus, which is the border between the cornea and the sclera (i.e., the
+    white of the eye).
+    In the image sequence, there are some dark spots due to the presence of
+    dust on the reference mirror.
+
+    Returns
+    -------
+    palisades_of_vogt: (60, 1440, 1440) uint16 ndarray
+
+    Notes
+    -----
+    See info under `in-vivo-cornea-spots.tif` at
+    https://gitlab.com/scikit-image/data/-/blob/master/README.md#data.
+
+    """
+    return _load('data/palisades_of_vogt.tif')
+
+
+def rocket():
+    """Launch photo of DSCOVR on Falcon 9 by SpaceX.
+
+    This is the launch photo of Falcon 9 carrying DSCOVR lifted off from
+    SpaceX's Launch Complex 40 at Cape Canaveral Air Force Station, FL.
+
+    Notes
+    -----
+    This image was downloaded from
+    `SpaceX Photos
+    <https://www.flickr.com/photos/spacexphotos/16511594820/in/photostream/>`__.
+
+    The image was captured by SpaceX and `released in the public domain
+    <http://arstechnica.com/tech-policy/2015/03/elon-musk-puts-spacex-photos-into-the-public-domain/>`_.
+
+    Returns
+    -------
+    rocket : (427, 640, 3) uint8 ndarray
+        Rocket image.
+    """
+    return _load("data/rocket.jpg")
+
+
+def stereo_motorcycle():
+    """Rectified stereo image pair with ground-truth disparities.
+
+    The two images are rectified such that every pixel in the left image has
+    its corresponding pixel on the same scanline in the right image. That means
+    that both images are warped such that they have the same orientation but a
+    horizontal spatial offset (baseline). The ground-truth pixel offset in
+    column direction is specified by the included disparity map.
+
+    The two images are part of the Middlebury 2014 stereo benchmark. The
+    dataset was created by Nera Nesic, Porter Westling, Xi Wang, York Kitajima,
+    Greg Krathwohl, and Daniel Scharstein at Middlebury College. A detailed
+    description of the acquisition process can be found in [1]_.
+
+    The images included here are down-sampled versions of the default exposure
+    images in the benchmark. The images are down-sampled by a factor of 4 using
+    the function `skimage.transform.downscale_local_mean`. The calibration data
+    in the following and the included ground-truth disparity map are valid for
+    the down-sampled images::
+
+        Focal length:           994.978px
+        Principal point x:      311.193px
+        Principal point y:      254.877px
+        Principal point dx:      31.086px
+        Baseline:               193.001mm
+
+    Returns
+    -------
+    img_left : (500, 741, 3) uint8 ndarray
+        Left stereo image.
+    img_right : (500, 741, 3) uint8 ndarray
+        Right stereo image.
+    disp : (500, 741, 3) float ndarray
+        Ground-truth disparity map, where each value describes the offset in
+        column direction between corresponding pixels in the left and the right
+        stereo images. E.g. the corresponding pixel of
+        ``img_left[10, 10 + disp[10, 10]]`` is ``img_right[10, 10]``.
+        NaNs denote pixels in the left image that do not have ground-truth.
+
+    Notes
+    -----
+    The original resolution images, images with different exposure and
+    lighting, and ground-truth depth maps can be found at the Middlebury
+    website [2]_.
+
+    References
+    ----------
+    .. [1] D. Scharstein, H. Hirschmueller, Y. Kitajima, G. Krathwohl, N.
+           Nesic, X. Wang, and P. Westling. High-resolution stereo datasets
+           with subpixel-accurate ground truth. In German Conference on Pattern
+           Recognition (GCPR 2014), Muenster, Germany, September 2014.
+    .. [2] http://vision.middlebury.edu/stereo/data/scenes2014/
+
+    """
+    filename = _fetch("data/motorcycle_disp.npz")
+    # np.load of npz file holds onto open file handle.
+    with np.load(filename) as data:
+        disp = data['arr_0']
+    return (_load("data/motorcycle_left.png"), _load("data/motorcycle_right.png"), disp)
+
+
+def lfw_subset():
+    """Subset of data from the LFW dataset.
+
+    This database is a subset of the LFW database containing:
+
+    * 100 faces
+    * 100 non-faces
+
+    The full dataset is available at [2]_.
+
+    Returns
+    -------
+    images : (200, 25, 25) uint8 ndarray
+        100 first images are faces and subsequent 100 are non-faces.
+
+    Notes
+    -----
+    The faces were randomly selected from the LFW dataset and the non-faces
+    were extracted from the background of the same dataset. The cropped ROIs
+    have been resized to a 25 x 25 pixels.
+
+    References
+    ----------
+    .. [1] Huang, G., Mattar, M., Lee, H., & Learned-Miller, E. G. (2012).
+           Learning to align from scratch. In Advances in Neural Information
+           Processing Systems (pp. 764-772).
+    .. [2] http://vis-www.cs.umass.edu/lfw/
+
+    """
+    return np.load(_fetch('data/lfw_subset.npy'))
+
+
+def skin():
+    """Microscopy image of dermis and epidermis (skin layers).
+
+    Hematoxylin and eosin stained slide at 10x of normal epidermis and dermis
+    with a benign intradermal nevus.
+
+    Notes
+    -----
+    This image requires an Internet connection the first time it is called,
+    and to have the ``pooch`` package installed, in order to fetch the image
+    file from the scikit-image datasets repository.
+
+    The source of this image is
+    https://en.wikipedia.org/wiki/File:Normal_Epidermis_and_Dermis_with_Intradermal_Nevus_10x.JPG
+
+    The image was released in the public domain by its author Kilbad.
+
+    Returns
+    -------
+    skin : (960, 1280, 3) RGB image of uint8
+    """
+    return _load('data/skin.jpg')
+
+
+def nickel_solidification():
+    """Image sequence of synchrotron x-radiographs showing the rapid
+    solidification of a nickel alloy sample.
+
+    Returns
+    -------
+    nickel_solidification: (11, 384, 512) uint16 ndarray
+
+    Notes
+    -----
+    See info under `nickel_solidification.tif` at
+    https://gitlab.com/scikit-image/data/-/blob/master/README.md#data.
+
+    """
+    return _load('data/solidification.tif')
+
+
+def protein_transport():
+    """Microscopy image sequence with fluorescence tagging of proteins
+    re-localizing from the cytoplasmic area to the nuclear envelope.
+
+    Returns
+    -------
+    protein_transport: (15, 2, 180, 183) uint8 ndarray
+
+    Notes
+    -----
+    See info under `NPCsingleNucleus.tif` at
+    https://gitlab.com/scikit-image/data/-/blob/master/README.md#data.
+
+    """
+    return _load('data/protein_transport.tif')
+
+
+def brain():
+    """Subset of data from the University of North Carolina Volume Rendering
+    Test Data Set.
+
+    The full dataset is available at [1]_.
+
+    Returns
+    -------
+    image : (10, 256, 256) uint16 ndarray
+
+    Notes
+    -----
+    The 3D volume consists of 10 layers from the larger volume.
+
+    References
+    ----------
+    .. [1] https://graphics.stanford.edu/data/voldata/
+
+    """
+    return _load("data/brain.tiff")
+
+
+def vortex():
+    """Case B1 image pair from the first PIV challenge.
+
+    Returns
+    -------
+    image0, image1 : (512, 512) grayscale images
+        A pair of images featuring synthetic moving particles.
+
+    Notes
+    -----
+    This image was licensed as CC0 by its author, Prof. Koji Okamoto, with
+    thanks to Prof. Jun Sakakibara, who maintains the PIV Challenge site.
+
+    References
+    ----------
+    .. [1] Particle Image Velocimetry (PIV) Challenge site
+           http://pivchallenge.org
+    .. [2] 1st PIV challenge Case B: http://pivchallenge.org/pub/index.html#b
+    """
+    return (
+        _load('data/pivchallenge-B-B001_1.tif'),
+        _load('data/pivchallenge-B-B001_2.tif'),
+    )

envs/kitoverlay/skimage/data/_registry.py

@@ -0,0 +1,191 @@
+# Registry of datafiles that can be downloaded along with their SHA256 hashes
+# To generate the SHA256 hash, use the command
+# openssl sha256 filename
+registry = {
+    "color/data/lab_array_a_10.npy": "a3ef76f1530e374f9121020f1f220bc89767dc866f4bbd1b1f47e5b84891a38c",
+    "color/data/lab_array_a_2.npy": "793d5981cbffceb14b5fb589f998a2b1acdb5ff9c14d364c8e9e8bd45a80b275",
+    "color/data/lab_array_a_r.npy": "3d3613da109d0c87827525fc49b58111aefc12438fa6426654979f66807b9227",
+    "color/data/lab_array_b_10.npy": "e8d648b28077c1bfcef55ec6dc8679819612b56a01647f8c0a78625bb06f99b6",
+    "color/data/lab_array_b_2.npy": "da9c6aa99e4ab3af8ec3107bbf11647cc483a0760285dd5c9fb66988be393ca1",
+    "color/data/lab_array_b_r.npy": "d9eee96f4d65a2fbba82039508aac8c18304752ee8e33233e2a013e65bb91464",
+    "color/data/lab_array_c_10.npy": "88b4ff2a2d2c4f48e7bb265609221d4b9ef439a4e2d8a86989696bfdb47790e6",
+    "color/data/lab_array_c_2.npy": "e1b8acfdc7284ab9cd339de66948134304073b6f734ecf9ad42f8297b83d3405",
+    "color/data/lab_array_c_r.npy": "09ffba2ed69e467864fea883493cd2d2706da028433464e3e858a8086842867e",
+    "color/data/lab_array_d50_10.npy": "42e2ff26cb10e2a98fcf1bc06c2483302ff4fabf971fe8d49b530f490b5d24c7",
+    "color/data/lab_array_d50_2.npy": "4aa03b7018ff7276643d3c082123cf07304f9d8d898ae92a5756a86955de4faf",
+    "color/data/lab_array_d50_r.npy": "57db02009f9a68dade33ce1ecffead0418d8ac8113b2a589fc02a20e6bf7e799",
+    "color/data/lab_array_d55_10.npy": "ab4f21368b6d8351578ab093381c44b49ae87a6b7f25c11aa094b07f215eed7d",
+    "color/data/lab_array_d55_2.npy": "0319723de4632a252bae828b7c96d038fb075a7df05beadfbad653da05efe372",
+    "color/data/lab_array_d55_r.npy": "060ebc446f7b4da4df58a60f0006133dbca735da87ba61854f4a75d28db67a3a",
+    "color/data/lab_array_d65_10.npy": "5cb9e9c384d2577aaf8b7d2d21ff5b505708b80605a2f59d10e89d22c3d308d2",
+    "color/data/lab_array_d65_2.npy": "16e847160f7ba4f19806d8194ed44a6654c9367e5a2cb240aa6e7eece44a6649",
+    "color/data/lab_array_d65_r.npy": "82d0dd7a46741f627b8868793e64cdc2f9944fe1e049b573f752a93760a1577c",
+    "color/data/lab_array_d75_10.npy": "c2d3de5422c785c925926b0c6223aeaf50b9393619d1c30830190d433606cbe1",
+    "color/data/lab_array_d75_2.npy": "c94d53da398d36e076471ff7e0dafcaffc64ce4ba33b4d04849c32d19c87494a",
+    "color/data/lab_array_e_2.npy": "ac05f17a83961b020ceccbdd46bddc86943d43e678dabcc898caf4a1e4be6165",
+    "color/data/luv_array_a_10.npy": "c8af67f9fd64a6e9c610ac0c12c5315a49ca229363f048e5d851409d4a3ae5b6",
+    "color/data/luv_array_a_2.npy": "eaf05dc61f4a70ece367d5e751a14d42b7c397c7b1c2df4cfecec9ddf26e1c1a",
+    "color/data/luv_array_a_r.npy": "2c0891add787ec757601f9c61ad14dd9621dd969af4e32753f2e64df437081b7",
+    "color/data/luv_array_b_10.npy": "a5407736b8a43071139ca178d12cdf930f32f52a0644f0b13f89d8895c8b43db",
+    "color/data/luv_array_b_2.npy": "8e74173d54dc549b6c0ebd1f1d70489d2905cad87744e41ed74384f21f22986d",
+    "color/data/luv_array_b_r.npy": "0a74c41df369cbb5fc0a00c16d60dc6f946ebf144bc5e506545b0d160fa53dfa",
+    "color/data/luv_array_c_10.npy": "3a5f975ffa57f69a1be9e02b153e8161f83040ce3002ea1b0a05b9fbdd0d8ec4",
+    "color/data/luv_array_c_2.npy": "32506cd50ea2181997cb88d3511e275740e8151d6c693cd178f5eafd8b0c6e47",
+    "color/data/luv_array_c_r.npy": "c0fbf98cc0e62ed426ab4d228986d6660089444a7bbfcc64cbb1c632644067bb",
+    "color/data/luv_array_d50_10.npy": "fe223db556222ce3a59198bed3a3324c2c719b8083fb84dc5b00f214b4773b16",
+    "color/data/luv_array_d50_2.npy": "48e8989048904bdf2c3c1ada265c1c29c5eff60f02f848a25cde622982c84901",
+    "color/data/luv_array_d50_r.npy": "f93f0def9c93f872dd10ce4a91fdb3f06eea61ddb6e72387b7669909827d4f9c",
+    "color/data/luv_array_d55_10.npy": "d88d53d2bad230c2331442187712ec52ffdee62bf0f60b200c33411bfed76c60",
+    "color/data/luv_array_d55_2.npy": "c761b40475df591ae9c0475d54ef712d067190ca4652efc6308b69080a652061",
+    "color/data/luv_array_d55_r.npy": "05fbd57e3602ee4d5202b9f18f9b5fc05b545891a9b4456d2a88aa798a5a774a",
+    "color/data/luv_array_d65_10.npy": "41a5452ffac4d31dd579d9528e725432c60d77b5f505d801898d9401429c89bf",
+    "color/data/luv_array_d65_2.npy": "962ce180132c6c11798cbc423b2b204d1d10187670f6eb5dec1058eaad301e0e",
+    "color/data/luv_array_d65_r.npy": "78db8c19af26dd802ce98b039a33855f7c8d6a103a2721d094b1d9c619717449",
+    "color/data/luv_array_d75_10.npy": "e1cc70d56eb6789633d4c2a4059b9533f616a7c8592c9bd342403e41d72f45e4",
+    "color/data/luv_array_d75_2.npy": "07db3bd59bd89de8e5ff62dad786fe5f4b299133495ba9bea30495b375133a98",
+    "color/data/luv_array_e_2.npy": "41b1037d81b267305ffe9e8e97e0affa9fa54b18e60413b01b8f11861cb32213",
+    "color/ciede2000_test_data.txt": "2e005c6f76ddfb7bbcc8f68490f1f7b4b4a2a4b06b36a80c985677a2799c0e40",
+    "data/astronaut.png": "88431cd9653ccd539741b555fb0a46b61558b301d4110412b5bc28b5e3ea6cb5",
+    "data/brick.png": "7966caf324f6ba843118d98f7a07746d22f6a343430add0233eca5f6eaaa8fcf",
+    "data/cell.png": "8d23a7fb81f7cc877cd09f330357fc7f595651306e84e17252f6e0a1b3f61515",
+    "data/camera.png": "b0793d2adda0fa6ae899c03989482bff9a42d3d5690fc7e3648f2795d730c23a",
+    "data/chessboard_GRAY.png": "3e51870774515af4d07d820bd8827364c70839bf9b573c746e485095e893df90",
+    "data/chessboard_RGB.png": "1ac01eff2d4e50f4eda55a2ddecdc28a6576623a58d7a7ef84513c5cc19a0331",
+    "data/chelsea.png": "596aa1e7cb875eb79f437e310381d26b338a81c2da23439704a73c4651e8c4bb",
+    "data/clock_motion.png": "f029226b28b642e80113d86622e9b215ee067a0966feaf5e60604a1e05733955",
+    "data/coffee.png": "cc02f8ca188b167c775a7101b5d767d1e71792cf762c33d6fa15a4599b5a8de7",
+    "data/coins.png": "f8d773fc9cfa6f4d8e5942dc34d0a0788fcaed2a4fefbbed0aef5398d7ef4cba",
+    "data/color.png": "7d2df993de2b4fa2a78e04e5df8050f49a9c511aa75e59ab3bd56ac9c98aef7e",
+    "data/eagle.png": "928f1bbe7403b533265f56db3a6b07c835dfa8e2513f5c5075ca2f1960f6179e",
+    "data/horse.png": "c7fb60789fe394c485f842291ea3b21e50d140f39d6dcb5fb9917cc178225455",
+    "data/grass.png": "b6b6022426b38936c43a4ac09635cd78af074e90f42ffa8227ac8b7452d39f89",
+    "data/hubble_deep_field.jpg": "3a19c5dd8a927a9334bb1229a6d63711b1c0c767fb27e2286e7c84a3e2c2f5f4",
+    "data/ihc.png": "f8dd1aa387ddd1f49d8ad13b50921b237df8e9b262606d258770687b0ef93cef",
+    "data/logo.png": "f2c57fe8af089f08b5ba523d95573c26e62904ac5967f4c8851b27d033690168",
+    "data/lfw_subset.npy": "9560ec2f5edfac01973f63a8a99d00053fecd11e21877e18038fbe500f8e872c",
+    "data/microaneurysms.png": "a1e1be59aa447f8ce082f7fa809997ab369a2b137cb6c4202abc647c7ccf6456",
+    "data/moon.png": "78739619d11f7eb9c165bb5d2efd4772cee557812ec847532dbb1d92ef71f577",
+    "data/motorcycle_left.png": "db18e9c4157617403c3537a6ba355dfeafe9a7eabb6b9b94cb33f6525dd49179",
+    "data/motorcycle_right.png": "5fc913ae870e42a4b662314bc904d1786bcad8e2f0b9b67dba5a229406357797",
+    "data/motorcycle_disp.npz": "2e49c8cebff3fa20359a0cc6880c82e1c03bbb106da81a177218281bc2f113d7",
+    "data/mssim_matlab_output.npz": "cc11a14bfa040c75b02db32282439f2e2e3e96779196c171498afaa70528ed7a",
+    "data/page.png": "341a6f0a61557662b02734a9b6e56ec33a915b2c41886b97509dedf2a43b47a3",
+    "data/phantom.png": "552ff698167aa402cceb17981130607a228a0a0aa7c519299eaa4d5f301ba36c",
+    "data/retina.jpg": "38a07f36f27f095e818aea7b96d34202c05176d30253c66733f2e00379e9e0e6",
+    "data/rocket.jpg": "c2dd0de7c538df8d111e479619b129464d0269d0ae5fd18ca91d33a7fdfea95c",
+    "data/gravel.png": "c48615b451bf1e606fbd72c0aa9f8cc0f068ab7111ef7d93bb9b0f2586440c12",
+    "data/text.png": "bd84aa3a6e3c9887850d45d606c96b2e59433fbef50338570b63c319e668e6d1",
+    "data/chessboard_GRAY_U16.tif": "9fd3392c5b6cbc5f686d8ff83eb57ef91d038ee0852ac26817e5ac99df4c7f45",
+    "data/chessboard_GRAY_U16B.tif": "b0a9270751f0fc340c90b8b615b62b88187b9ab5995942717566735d523cddb2",
+    "data/chessboard_GRAY_U8.npy": "71f394694b721e8a33760a355b3666c9b7d7fc1188ff96b3cd23c2a1d73a38d8",
+    "data/lbpcascade_frontalface_opencv.xml": "03097789a3dcbb0e40d20b9ef82537dbc3b670b6a7f2268d735470f22e003a91",
+    "data/astronaut_GRAY_hog_L1.npy": "5d8ab22b166d1dd49c12caeff9d178ed28132efea3852b952e9d75f7f7f94954",
+    "data/astronaut_GRAY_hog_L2-Hys.npy": "c4dd6e50d1129aada358311cf8880ce8c775f31e0e550fc322c16e43a96d56fe",
+    "data/rank_filter_tests.npz": "efaf5699630f4a53255e91681dc72a965acd4a8aa1f84671c686fb93e7df046d",
+    "data/rank_filters_tests_3d.npz": "1741c2b978424e93558a07d345b2a0d9bfbb33c095c123da147fca066714ab16",
+    "data/palette_color.png": "c4e817035fb9f7730fe95cff1da3866dea01728efc72b6e703d78f7ab9717bdd",
+    "data/palette_gray.png": "bace7f73783bf3ab3b7fdaf701707e4fa09f0dbd0ea72cf5b12ddc73d50b02a9",
+    "data/green_palette.png": "42d49d94be8f9bc76e50639d3701ed0484258721f6b0bd7f50bb1b9274a010f0",
+    "data/truncated.jpg": "4c226038acc78012d335efba29c6119a24444a886842182b7e18db378f4a557d",
+    "data/multipage.tif": "4da0ad0d3df4807a9847247d1b5e565b50d46481f643afb5c37c14802c78130f",
+    "data/multipage_rgb.tif": "1d23b844fd38dce0e2d06f30432817cdb85e52070d8f5460a2ba58aebf34a0de",
+    "data/no_time_for_that_tiny.gif": "20abe94ba9e45f18de416c5fbef8d1f57a499600be40f9a200fae246010eefce",
+    "data/foo3x5x4indexed.png": "48a64c25c6da000ffdb5fcc34ebafe9ba3b1c9b61d7984ea7ca6dc54f9312dfa",
+    "data/gray_morph_output.npz": "49a0dae607cd8d31e134b4bfcbf0d86b13751fdce9667d8bf1ade93d435191b1",
+    "data/disk-matlab-output.npz": "8a39d5c866f6216d6a9c9166312aa4bbf4d18fab3d0dcd963c024985bde5856b",
+    "data/diamond-matlab-output.npz": "02fca68907e2b252b501dfe977eef71ae39fadaaa3702ebdc855195422ae1cc2",
+    "data/bw_text.png": "308c2b09f8975a69b212e103b18520e8cbb7a4eccfce0f757836cd371f1b9094",
+    "data/bw_text_skeleton.npy": "9ff4fc23c6a01497d7987f14e3a97cbcc39cce54b2b3b7ee33b84c1b661d0ae1",
+    "data/_blobs_3d_fiji_skeleton.tif": "e3449ad9819425959952050c147278555e5ffe1c2c4a30df29f6a1f9023e10c3",
+    "data/checker_bilevel.png": "2e207e486545874a2a3e69ba653b28fdef923157be9017559540e65d1bcb8e28",
+    "restoration/astronaut_rl.npy": "3f8373e2c6182a89366e51cef6624e3625deac75fdda1079cbdad2a33322152c",
+    "restoration/camera_rl.npy": "fd4f59af84dd471fbbe79ee70c1b7e68a69864c461f0db5ac587e7975363f78f",
+    "restoration/camera_unsup.npy": "3de10a0b97267352b18886b25d66a967f9e1d78ada61050577d78586cab82baa",
+    "restoration/camera_unsup2.npy": "29cdc60605eb528c5f014baa8564d7d1ba0bd4b3170a66522058cbe5aed0960b",
+    "restoration/camera_wiener.npy": "4505ea8b0d63d03250c6d756560d615751b76dd6ffc4a95972fa260c0c84633e",
+    "registration/data/OriginalX-130Y130.png": "bf24a06d99ae131c97e582ef5e1cd0c648a8dad0caab31281f3564045492811f",
+    "registration/data/OriginalX130Y130.png": "7fdd4c06d504fec35ee0703bd7ed2c08830b075a74c8506bae4a70d682f5a2db",
+    "registration/data/OriginalX75Y75.png": "c5cd58893c93140df02896df80b13ecf432f5c86eeaaf8fb311aec52a65c7016",
+    "registration/data/TransformedX-130Y130.png": "1cda90ed69c921eb7605b73b76d141cf4ea03fb8ce3336445ca08080e40d7375",
+    "registration/data/TransformedX130Y130.png": "bb10c6ae3f91a313b0ac543efdb7ca69c4b95e55674c65a88472a6c4f4692a25",
+    "registration/data/TransformedX75Y75.png": "a1e9ead5f8e4a0f604271e1f9c50e89baf53f068f1d19fab2876af4938e695ea",
+    "data/brain.tiff": "bcdbaf424fbad7b1fb0f855f608c68e5a838f35affc323ff04ea17f678eef5c6",
+    "data/cells3d.tif": "afc7c7d80d38bfde09788b4064ac1e64ec14e88454ab785ebdc8dbba5ca3b222",
+    "data/palisades_of_vogt.tif": "7f205b626407e194974cead67c4d3909344cf59c42d229a349da0198183e5bd0",
+    "data/kidney.tif": "80c0799bc58b08cf6eaa53ecd202305eb42fd7bc73746cb6c5064dbeae7e8476",
+    "data/lily.tif": "395c2f0194c25b9824a8cd79266920362a0816bc9e906dd392adce2d8309af03",
+    "data/mitosis.tif": "2751ba667c4067c5d30817cff004aa06f6f6287f1cdbb5b8c9c6a500308cb456",
+    "data/skin.jpg": "8759fe080509712163453f4b17106582b8513e73b0788d80160abf840e272075",
+    "data/pivchallenge-B-B001_1.tif": "e95e09abbcecba723df283ac7d361766328abd943701a2ec2f345d4a2014da2a",
+    "data/pivchallenge-B-B001_2.tif": "4ceb5407e4e333476a0f264c14b7a3f6c0e753fcdc99ee1c4b8196e5f823805e",
+    "data/protein_transport.tif": "a8e24e8d187f33e92ee28508d5615286c850ca75374af7e74e527d290e8b06ea",
+    "data/solidification.tif": "50ef9a52c621b7c0c506ad1fe1b8ee8a158a4d7c8e50ddfce1e273a422dca3f9",
+}
+
+registry_urls = {
+    "data/brain.tiff": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/brain.tiff",
+    "data/cells3d.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/cells3d.tif",
+    "data/palisades_of_vogt.tif": "https://gitlab.com/scikit-image/data/-/raw/b2bc880f3bac23a583724befe8388dae368c52fe/in-vivo-cornea-spots.tif",
+    "data/eagle.png": "https://gitlab.com/scikit-image/data/-/raw/1e4f62ac31ba4553d176d4473a5967ad1b076d62/eagle.png",
+    "data/kidney.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/kidney-tissue-fluorescence.tif",
+    "data/lily.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/lily-of-the-valley-fluorescence.tif",
+    "data/mitosis.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/AS_09125_050116030001_D03f00d0.tif",
+    "data/rank_filters_tests_3d.npz": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/Tests_besides_Equalize_Otsu/add18_entropy/rank_filters_tests_3d.npz",
+    "data/skin.jpg": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/Normal_Epidermis_and_Dermis_with_Intradermal_Nevus_10x.JPG",
+    "data/pivchallenge-B-B001_1.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/pivchallenge/B/B001_1.tif",
+    "data/pivchallenge-B-B001_2.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/pivchallenge/B/B001_2.tif",
+    "data/protein_transport.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/NPCsingleNucleus.tif",
+    "data/solidification.tif": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/nickel_solidification.tif",
+    "restoration/astronaut_rl.npy": "https://gitlab.com/scikit-image/data/-/raw/2cdc5ce89b334d28f06a58c9f0ca21aa6992a5ba/astronaut_rl.npy",
+    "data/gray_morph_output.npz": "https://gitlab.com/scikit-image/data/-/raw/806548e112bcf2b708a9a32275d335cb592480fd/Tests_besides_Equalize_Otsu/gray_morph_output.npz",
+    "data/_blobs_3d_fiji_skeleton.tif": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/_blobs_3d_fiji_skeleton.tif",
+    "data/astronaut.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/astronaut.png",
+    "data/astronaut_GRAY_hog_L1.npy": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/astronaut_GRAY_hog_L1.npy",
+    "data/astronaut_GRAY_hog_L2-Hys.npy": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/astronaut_GRAY_hog_L2-Hys.npy",
+    "data/brick.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/brick.png",
+    "data/bw_text.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/bw_text.png",
+    "data/bw_text_skeleton.npy": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/bw_text_skeleton.npy",
+    "data/camera.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/camera.png",
+    "data/cell.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/cell.png",
+    "data/checker_bilevel.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/checker_bilevel.png",
+    "data/chelsea.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/chelsea.png",
+    "data/chessboard_GRAY.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/chessboard_GRAY.png",
+    "data/chessboard_GRAY_U16.tif": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/chessboard_GRAY_U16.tif",
+    "data/chessboard_GRAY_U16B.tif": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/chessboard_GRAY_U16B.tif",
+    "data/chessboard_GRAY_U8.npy": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/chessboard_GRAY_U8.npy",
+    "data/chessboard_RGB.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/chessboard_RGB.png",
+    "data/clock_motion.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/clock_motion.png",
+    "data/coffee.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/coffee.png",
+    "data/coins.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/coins.png",
+    "data/color.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/color.png",
+    "data/diamond-matlab-output.npz": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/diamond-matlab-output.npz",
+    "data/disk-matlab-output.npz": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/disk-matlab-output.npz",
+    "data/foo3x5x4indexed.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/foo3x5x4indexed.png",
+    "data/grass.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/grass.png",
+    "data/gravel.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/gravel.png",
+    "data/green_palette.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/green_palette.png",
+    "data/horse.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/horse.png",
+    "data/hubble_deep_field.jpg": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/hubble_deep_field.jpg",
+    "data/ihc.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/ihc.png",
+    "data/lbpcascade_frontalface_opencv.xml": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/lbpcascade_frontalface_opencv.xml",
+    "data/lfw_subset.npy": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/lfw_subset.npy",
+    "data/logo.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/logo.png",
+    "data/microaneurysms.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/microaneurysms.png",
+    "data/moon.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/moon.png",
+    "data/motorcycle_disp.npz": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/motorcycle_disp.npz",
+    "data/motorcycle_left.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/motorcycle_left.png",
+    "data/motorcycle_right.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/motorcycle_right.png",
+    "data/mssim_matlab_output.npz": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/mssim_matlab_output.npz",
+    "data/multipage.tif": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/multipage.tif",
+    "data/multipage_rgb.tif": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/multipage_rgb.tif",
+    "data/no_time_for_that_tiny.gif": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/no_time_for_that_tiny.gif",
+    "data/page.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/page.png",
+    "data/palette_color.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/palette_color.png",
+    "data/palette_gray.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/palette_gray.png",
+    "data/phantom.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/phantom.png",
+    "data/rank_filter_tests.npz": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/rank_filter_tests.npz",
+    "data/retina.jpg": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/retina.jpg",
+    "data/rocket.jpg": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/rocket.jpg",
+    "data/text.png": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/text.png",
+    "data/truncated.jpg": "https://gitlab.com/scikit-image/data/-/raw/5c090b56df3988d988ff97928e2ef2d2cbe38e1b/truncated.jpg",
+}

envs/kitoverlay/skimage/data/lbpcascade_frontalface_opencv.xml

@@ -0,0 +1,1505 @@
+<?xml version="1.0"?>
+<!--
+number of positive samples 3000
+number of negative samples 1500
+-->
+<opencv_storage>
+<cascade type_id="opencv-cascade-classifier">
+  <stageType>BOOST</stageType>
+  <featureType>LBP</featureType>
+  <height>24</height>
+  <width>24</width>
+  <stageParams>
+    <boostType>GAB</boostType>
+    <minHitRate>0.9950000047683716</minHitRate>
+    <maxFalseAlarm>0.5000000000000000</maxFalseAlarm>
+    <weightTrimRate>0.9500000000000000</weightTrimRate>
+    <maxDepth>1</maxDepth>
+    <maxWeakCount>100</maxWeakCount></stageParams>
+  <featuhreParams>
+    <maxCatCount>256</maxCatCount></featuhreParams>
+  <stageNum>20</stageNum>
+  <stages>
+    <!-- stage 0 -->
+    <_>
+      <maxWeakCount>3</maxWeakCount>
+      <stageThreshold>-0.7520892024040222</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 46 -67130709 -21569 -1426120013 -1275125205 -21585
+            -16385 587145899 -24005</internalNodes>
+          <leafValues>
+            -0.6543210148811340 0.8888888955116272</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 13 -163512766 -769593758 -10027009 -262145 -514457854
+            -193593353 -524289 -1</internalNodes>
+          <leafValues>
+            -0.7739216089248657 0.7278633713722229</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 2 -363936790 -893203669 -1337948010 -136907894
+            1088782736 -134217726 -741544961 -1590337</internalNodes>
+          <leafValues>
+            -0.7068563103675842 0.6761534214019775</leafValues></_></weakClassifiers></_>
+    <!-- stage 1 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-0.4872078299522400</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 84 2147483647 1946124287 -536870913 2147450879
+            738132490 1061101567 243204619 2147446655</internalNodes>
+          <leafValues>
+            -0.8083735704421997 0.7685696482658386</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 21 2147483647 263176079 1879048191 254749487 1879048191
+            -134252545 -268435457 801111999</internalNodes>
+          <leafValues>
+            -0.7698410153388977 0.6592915654182434</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 106 -98110272 1610939566 -285484400 -850010381
+            -189334372 -1671954433 -571026695 -262145</internalNodes>
+          <leafValues>
+            -0.7506558895111084 0.5444605946540833</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 48 -798690576 -131075 1095771153 -237144073 -65569 -1
+            -216727745 -69206049</internalNodes>
+          <leafValues>
+            -0.7775990366935730 0.5465461611747742</leafValues></_></weakClassifiers></_>
+    <!-- stage 2 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-1.1592328548431396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 47 -21585 -20549 -100818262 -738254174 -20561 -36865
+            -151016790 -134238549</internalNodes>
+          <leafValues>
+            -0.5601882934570313 0.7743113040924072</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 12 -286003217 183435247 -268994614 -421330945
+            -402686081 1090387966 -286785545 -402653185</internalNodes>
+          <leafValues>
+            -0.6124526262283325 0.6978127956390381</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 26 -50347012 970882927 -50463492 -1253377 -134218251
+            -50364513 -33619992 -172490753</internalNodes>
+          <leafValues>
+            -0.6114496588706970 0.6537628173828125</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 8 -273 -135266321 1877977738 -2088243418 -134217987
+            2146926575 -18910642 1095231247</internalNodes>
+          <leafValues>
+            -0.6854077577590942 0.5403239130973816</leafValues></_></weakClassifiers></_>
+    <!-- stage 3 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.7562355995178223</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 96 -1273 1870659519 -20971602 -67633153 -134250731
+            2004875127 -250 -150995969</internalNodes>
+          <leafValues>
+            -0.4051094949245453 0.7584033608436585</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 33 -868162224 -76810262 -4262145 -257 1465211989
+            -268959873 -2656269 -524289</internalNodes>
+          <leafValues>
+            -0.7388162612915039 0.5340843200683594</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 57 -12817 -49 -541103378 -152950 -38993 -20481 -1153876
+            -72478976</internalNodes>
+          <leafValues>
+            -0.6582943797111511 0.5339496731758118</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 125 -269484161 -452984961 -319816180 -1594032130 -2111
+            -990117891 -488975296 -520947741</internalNodes>
+          <leafValues>
+            -0.5981323719024658 0.5323504805564880</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 53 557787431 670265215 -1342193665 -1075892225
+            1998528318 1056964607 -33570977 -1</internalNodes>
+          <leafValues>
+            -0.6498787999153137 0.4913350641727448</leafValues></_></weakClassifiers></_>
+    <!-- stage 4 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8085358142852783</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 60 -536873708 880195381 -16842788 -20971521 -176687276
+            -168427659 -16777260 -33554626</internalNodes>
+          <leafValues>
+            -0.5278195738792419 0.6946372389793396</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 7 -1 -62981529 -1090591130 805330978 -8388827 -41945787
+            -39577 -531118985</internalNodes>
+          <leafValues>
+            -0.5206505060195923 0.6329920291900635</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 98 -725287348 1347747543 -852489 -16809993 1489881036
+            -167903241 -1 -1</internalNodes>
+          <leafValues>
+            -0.7516061067581177 0.4232024252414703</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 44 -32777 1006582562 -65 935312171 -8388609 -1078198273
+            -1 733886267</internalNodes>
+          <leafValues>
+            -0.7639313936233521 0.4123568832874298</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -85474705 2138828511 -1036436754 817625855
+            1123369029 -58796809 -1013468481 -194513409</internalNodes>
+          <leafValues>
+            -0.5123769044876099 0.5791834592819214</leafValues></_></weakClassifiers></_>
+    <!-- stage 5 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.5549971461296082</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 42 -17409 -20481 -268457797 -134239493 -17473 -1 -21829
+            -21846</internalNodes>
+          <leafValues>
+            -0.3763174116611481 0.7298233509063721</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 6 -805310737 -2098262358 -269504725 682502698
+            2147483519 1740574719 -1090519233 -268472385</internalNodes>
+          <leafValues>
+            -0.5352765917778015 0.5659480094909668</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 61 -67109678 -6145 -8 -87884584 -20481 -1073762305
+            -50856216 -16849696</internalNodes>
+          <leafValues>
+            -0.5678374171257019 0.4961479902267456</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 123 -138428633 1002418167 -1359008245 -1908670465
+            -1346685918 910098423 -1359010520 -1346371657</internalNodes>
+          <leafValues>
+            -0.5706262588500977 0.4572288393974304</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 9 -89138513 -4196353 1256531674 -1330665426 1216308261
+            -36190633 33498198 -151796633</internalNodes>
+          <leafValues>
+            -0.5344601869583130 0.4672054052352905</leafValues></_></weakClassifiers></_>
+    <!-- stage 6 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8776460289955139</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 105 1073769576 206601725 -34013449 -33554433 -789514004
+            -101384321 -690225153 -264193</internalNodes>
+          <leafValues>
+            -0.7700348496437073 0.5943940877914429</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 30 -1432340997 -823623681 -49153 -34291724 -269484035
+            -1342767105 -1078198273 -1277955</internalNodes>
+          <leafValues>
+            -0.5043668746948242 0.6151274442672730</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 35 -1067385040 -195758209 -436748425 -134217731
+            -50855988 -129 -1 -1</internalNodes>
+          <leafValues>
+            -0.6808040738105774 0.4667325913906097</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 119 832534325 -34111555 -26050561 -423659521 -268468364
+            2105014143 -2114244 -17367185</internalNodes>
+          <leafValues>
+            -0.4927591383457184 0.5401885509490967</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 82 -1089439888 -1080524865 2143059967 -1114121
+            -1140949004 -3 -2361356 -739516</internalNodes>
+          <leafValues>
+            -0.6445107460021973 0.4227822124958038</leafValues></_></weakClassifiers></_>
+    <!-- stage 7 -->
+    <_>
+      <maxWeakCount>6</maxWeakCount>
+      <stageThreshold>-1.1139287948608398</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 52 -1074071553 -1074003969 -1 -1280135430 -5324817 -1
+            -335548482 582134442</internalNodes>
+          <leafValues>
+            -0.5307556986808777 0.6258179545402527</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 99 -706937396 -705364068 -540016724 -570495027
+            -570630659 -587857963 -33628164 -35848193</internalNodes>
+          <leafValues>
+            -0.5227634310722351 0.5049746036529541</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 18 -2035630093 42119158 -268503053 -1671444 261017599
+            1325432815 1954394111 -805306449</internalNodes>
+          <leafValues>
+            -0.4983572661876679 0.5106441378593445</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 111 -282529488 -1558073088 1426018736 -170526448
+            -546832487 -5113037 -34243375 -570427929</internalNodes>
+          <leafValues>
+            -0.4990860521793366 0.5060507059097290</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 92 1016332500 -606301707 915094269 -1080086049
+            -1837027144 -1361600280 2147318747 1067975613</internalNodes>
+          <leafValues>
+            -0.5695009231567383 0.4460467398166657</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 51 -656420166 -15413034 -141599534 -603435836
+            1505950458 -787556946 -79823438 -1326199134</internalNodes>
+          <leafValues>
+            -0.6590405106544495 0.3616424500942230</leafValues></_></weakClassifiers></_>
+    <!-- stage 8 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.8243625760078430</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 28 -901591776 -201916417 -262 -67371009 -143312112
+            -524289 -41943178 -1</internalNodes>
+          <leafValues>
+            -0.4972776770591736 0.6027074456214905</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 112 -4507851 -411340929 -268437513 -67502145 -17350859
+            -32901 -71344315 -29377</internalNodes>
+          <leafValues>
+            -0.4383158981800079 0.5966237187385559</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 69 -75894785 -117379438 -239063587 -12538500 1485072126
+            2076233213 2123118847 801906927</internalNodes>
+          <leafValues>
+            -0.6386105418205261 0.3977999985218048</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 19 -823480413 786628589 -16876049 -1364262914 242165211
+            1315930109 -696268833 -455082829</internalNodes>
+          <leafValues>
+            -0.5512794256210327 0.4282079637050629</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 73 -521411968 6746762 -1396236286 -2038436114
+            -185612509 57669627 -143132877 -1041235973</internalNodes>
+          <leafValues>
+            -0.6418755054473877 0.3549866080284119</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 126 -478153869 1076028979 -1645895615 1365298272
+            -557859073 -339771473 1442574528 -1058802061</internalNodes>
+          <leafValues>
+            -0.4841901361942291 0.4668019413948059</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 45 -246350404 -1650402048 -1610612745 -788400696
+            1467604861 -2787397 1476263935 -4481349</internalNodes>
+          <leafValues>
+            -0.5855734348297119 0.3879135847091675</leafValues></_></weakClassifiers></_>
+    <!-- stage 9 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-1.2237116098403931</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 114 -24819 1572863935 -16809993 -67108865 2146778388
+            1433927541 -268608444 -34865205</internalNodes>
+          <leafValues>
+            -0.2518476545810700 0.7088654041290283</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 97 -1841359 -134271049 -32769 -5767369 -1116675 -2185
+            -8231 -33603327</internalNodes>
+          <leafValues>
+            -0.4303432404994965 0.5283288359642029</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 25 -1359507589 -1360593090 -1073778729 -269553812
+            -809512977 1744707583 -41959433 -134758978</internalNodes>
+          <leafValues>
+            -0.4259553551673889 0.5440809130668640</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 34 729753407 -134270989 -1140907329 -235200777
+            658456383 2147467263 -1140900929 -16385</internalNodes>
+          <leafValues>
+            -0.5605589151382446 0.4220733344554901</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 134 -310380553 -420675595 -193005472 -353568129
+            1205338070 -990380036 887604324 -420544526</internalNodes>
+          <leafValues>
+            -0.5192656517028809 0.4399855434894562</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 16 -1427119361 1978920959 -287119734 -487068946
+            114759245 -540578051 -707510259 -671660453</internalNodes>
+          <leafValues>
+            -0.5013077259063721 0.4570254683494568</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 74 -738463762 -889949281 -328301948 -121832450
+            -1142658284 -1863576559 2146417353 -263185</internalNodes>
+          <leafValues>
+            -0.4631414115428925 0.4790246188640595</leafValues></_></weakClassifiers></_>
+    <!-- stage 10 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.5544230937957764</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 113 -76228780 -65538 -1 -67174401 -148007 -33 -221796
+            -272842924</internalNodes>
+          <leafValues>
+            -0.3949716091156006 0.6082032322883606</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 110 369147696 -1625232112 2138570036 -1189900 790708019
+            -1212613127 799948719 -4456483</internalNodes>
+          <leafValues>
+            -0.4855885505676270 0.4785369932651520</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 37 784215839 -290015241 536832799 -402984963
+            -1342414991 -838864897 -176769 -268456129</internalNodes>
+          <leafValues>
+            -0.4620285332202911 0.4989669024944305</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 41 -486418688 -171915327 -340294900 -21938 -519766032
+            -772751172 -73096060 -585322623</internalNodes>
+          <leafValues>
+            -0.6420643329620361 0.3624351918697357</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 117 -33554953 -475332625 -1423463824 -2077230421
+            -4849669 -2080505925 -219032928 -1071915349</internalNodes>
+          <leafValues>
+            -0.4820112884044647 0.4632140696048737</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 65 -834130468 -134217476 -1349314083 -1073803559
+            -619913764 -1449131844 -1386890321 -1979118423</internalNodes>
+          <leafValues>
+            -0.4465552568435669 0.5061788558959961</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 56 -285249779 1912569855 -16530 -1731022870 -1161904146
+            -1342177297 -268439634 -1464078708</internalNodes>
+          <leafValues>
+            -0.5190586447715759 0.4441480338573456</leafValues></_></weakClassifiers></_>
+    <!-- stage 11 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.7161560654640198</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 20 1246232575 1078001186 -10027057 60102 -277348353
+            -43646987 -1210581153 1195769615</internalNodes>
+          <leafValues>
+            -0.4323809444904327 0.5663768053054810</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 15 -778583572 -612921106 -578775890 -4036478
+            -1946580497 -1164766570 -1986687009 -12103599</internalNodes>
+          <leafValues>
+            -0.4588732719421387 0.4547033011913300</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 129 -1073759445 2013231743 -1363169553 -1082459201
+            -1414286549 868185983 -1356133589 -1077936257</internalNodes>
+          <leafValues>
+            -0.5218553543090820 0.4111092388629913</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 102 -84148365 -2093417722 -1204850272 564290299
+            -67121221 -1342177350 -1309195902 -776734797</internalNodes>
+          <leafValues>
+            -0.4920000731945038 0.4326725304126740</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 88 -25694458 67104495 -290216278 -168563037 2083877442
+            1702788383 -144191964 -234882162</internalNodes>
+          <leafValues>
+            -0.4494568109512329 0.4448510706424713</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 59 -857980836 904682741 -1612267521 232279415
+            1550862252 -574825221 -357380888 -4579409</internalNodes>
+          <leafValues>
+            -0.5180826783180237 0.3888972699642181</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 27 -98549440 -137838400 494928389 -246013630 939541351
+            -1196072350 -620603549 2137216273</internalNodes>
+          <leafValues>
+            -0.6081240773200989 0.3333222270011902</leafValues></_></weakClassifiers></_>
+    <!-- stage 12 -->
+    <_>
+      <maxWeakCount>8</maxWeakCount>
+      <stageThreshold>-0.6743940711021423</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 29 -150995201 2071191945 -1302151626 536934335
+            -1059008937 914128709 1147328110 -268369925</internalNodes>
+          <leafValues>
+            -0.1790193915367127 0.6605972051620483</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 128 -134509479 1610575703 -1342177289 1861484541
+            -1107833788 1577058173 -333558568 -136319041</internalNodes>
+          <leafValues>
+            -0.3681024610996246 0.5139749646186829</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 70 -1 1060154476 -1090984524 -630918524 -539492875
+            779616255 -839568424 -321</internalNodes>
+          <leafValues>
+            -0.3217232525348663 0.6171553134918213</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 4 -269562385 -285029906 -791084350 -17923776 235286671
+            1275504943 1344390399 -966276889</internalNodes>
+          <leafValues>
+            -0.4373284578323364 0.4358185231685638</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 76 17825984 -747628419 595427229 1474759671 575672208
+            -1684005538 872217086 -1155858277</internalNodes>
+          <leafValues>
+            -0.4404836893081665 0.4601220190525055</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 124 -336593039 1873735591 -822231622 -355795238
+            -470820869 -1997537409 -1057132384 -1015285005</internalNodes>
+          <leafValues>
+            -0.4294152259826660 0.4452161788940430</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 54 -834212130 -593694721 -322142257 -364892500
+            -951029539 -302125121 -1615106053 -79249765</internalNodes>
+          <leafValues>
+            -0.3973052501678467 0.4854526817798615</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 95 1342144479 2147431935 -33554561 -47873 -855685912 -1
+            1988052447 536827383</internalNodes>
+          <leafValues>
+            -0.7054683566093445 0.2697997391223908</leafValues></_></weakClassifiers></_>
+    <!-- stage 13 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.2042298316955566</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 39 1431368960 -183437936 -537002499 -137497097
+            1560590321 -84611081 -2097193 -513</internalNodes>
+          <leafValues>
+            -0.5905947685241699 0.5101932883262634</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 120 -1645259691 2105491231 2130706431 1458995007
+            -8567536 -42483883 -33780003 -21004417</internalNodes>
+          <leafValues>
+            -0.4449204802513123 0.4490709304809570</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 89 -612381022 -505806938 -362027516 -452985106
+            275854917 1920431639 -12600561 -134221825</internalNodes>
+          <leafValues>
+            -0.4693818688392639 0.4061094820499420</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 14 -805573153 -161 -554172679 -530519488 -16779441
+            2000682871 -33604275 -150997129</internalNodes>
+          <leafValues>
+            -0.3600351214408875 0.5056326985359192</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 67 6192 435166195 1467449341 2046691505 -1608493775
+            -4755729 -1083162625 -71365637</internalNodes>
+          <leafValues>
+            -0.4459891915321350 0.4132415652275085</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 86 -41689215 -3281034 1853357967 -420712635 -415924289
+            -270209208 -1088293113 -825311232</internalNodes>
+          <leafValues>
+            -0.4466069042682648 0.4135067760944367</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 80 -117391116 -42203396 2080374461 -188709 -542008165
+            -356831940 -1091125345 -1073796897</internalNodes>
+          <leafValues>
+            -0.3394956290721893 0.5658645033836365</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 75 -276830049 1378714472 -1342181951 757272098
+            1073740607 -282199241 -415761549 170896931</internalNodes>
+          <leafValues>
+            -0.5346512198448181 0.3584479391574860</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 55 -796075825 -123166849 2113667055 -217530421
+            -1107432194 -16385 -806359809 -391188771</internalNodes>
+          <leafValues>
+            -0.4379335641860962 0.4123645126819611</leafValues></_></weakClassifiers></_>
+    <!-- stage 14 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.8402050137519836</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 71 -890246622 15525883 -487690486 47116238 -1212319899
+            -1291847681 -68159890 -469829921</internalNodes>
+          <leafValues>
+            -0.2670986354351044 0.6014143228530884</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 31 -1361180685 -1898008841 -1090588811 -285410071
+            -1074016265 -840443905 2147221487 -262145</internalNodes>
+          <leafValues>
+            -0.4149844348430634 0.4670888185501099</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 40 1426190596 1899364271 2142731795 -142607505
+            -508232452 -21563393 -41960001 -65</internalNodes>
+          <leafValues>
+            -0.4985891580581665 0.3719584941864014</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 109 -201337965 10543906 -236498096 -746195597
+            1974565825 -15204415 921907633 -190058309</internalNodes>
+          <leafValues>
+            -0.4568729996681213 0.3965812027454376</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 130 -595026732 -656401928 -268649235 -571490699
+            -440600392 -133131 -358810952 -2004088646</internalNodes>
+          <leafValues>
+            -0.4770836830139160 0.3862601518630981</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 66 941674740 -1107882114 1332789109 -67691015
+            -1360463693 -1556612430 -609108546 733546933</internalNodes>
+          <leafValues>
+            -0.4877715110778809 0.3778986334800720</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 49 -17114945 -240061474 1552871558 -82775604 -932393844
+            -1308544889 -532635478 -99042357</internalNodes>
+          <leafValues>
+            -0.3721654713153839 0.4994400143623352</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 133 -655906006 1405502603 -939205164 1884929228
+            -498859222 559417357 -1928559445 -286264385</internalNodes>
+          <leafValues>
+            -0.3934195041656494 0.4769641458988190</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 0 -335837777 1860677295 -90 -1946186226 931096183
+            251612987 2013265917 -671232197</internalNodes>
+          <leafValues>
+            -0.4323300719261169 0.4342164099216461</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 103 37769424 -137772680 374692301 2002666345 -536176194
+            -1644484728 807009019 1069089930</internalNodes>
+          <leafValues>
+            -0.4993278682231903 0.3665378093719482</leafValues></_></weakClassifiers></_>
+    <!-- stage 15 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.1974394321441650</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 43 -5505 2147462911 2143265466 -4511070 -16450 -257
+            -201348440 -71333206</internalNodes>
+          <leafValues>
+            -0.3310225307941437 0.5624626278877258</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 90 -136842268 -499330741 2015250980 -87107126
+            -641665744 -788524639 -1147864792 -134892563</internalNodes>
+          <leafValues>
+            -0.5266560912132263 0.3704403042793274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 104 -146800880 -1780368555 2111170033 -140904684
+            -16777551 -1946681885 -1646463595 -839131947</internalNodes>
+          <leafValues>
+            -0.4171888828277588 0.4540435671806335</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 85 -832054034 -981663763 -301990281 -578814081
+            -932319000 -1997406723 -33555201 -69206017</internalNodes>
+          <leafValues>
+            -0.4556705355644226 0.3704262077808380</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -118492417 -1209026825 1119023838 -1334313353
+            1112948738 -297319313 1378887291 -139469193</internalNodes>
+          <leafValues>
+            -0.4182529747486115 0.4267231225967407</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 78 -1714382628 -2353704 -112094959 -549613092
+            -1567058760 -1718550464 -342315012 -1074972227</internalNodes>
+          <leafValues>
+            -0.3625369668006897 0.4684656262397766</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 5 -85219702 316836394 -33279 1904970288 2117267315
+            -260901769 -621461759 -88607770</internalNodes>
+          <leafValues>
+            -0.4742925167083740 0.3689507246017456</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 11 -294654041 -353603585 -1641159686 -50331921
+            -2080899877 1145569279 -143132713 -152044037</internalNodes>
+          <leafValues>
+            -0.3666271567344666 0.4580127298831940</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 32 1887453658 -638545712 -1877976819 -34320972
+            -1071067983 -661345416 -583338277 1060190561</internalNodes>
+          <leafValues>
+            -0.4567637443542481 0.3894708156585693</leafValues></_></weakClassifiers></_>
+    <!-- stage 16 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.5733128190040588</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 122 -994063296 1088745462 -318837116 -319881377
+            1102566613 1165490103 -121679694 -134744129</internalNodes>
+          <leafValues>
+            -0.4055117964744568 0.5487945079803467</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 68 -285233233 -538992907 1811935199 -369234005 -529
+            -20593 -20505 -1561401854</internalNodes>
+          <leafValues>
+            -0.3787897229194641 0.4532003402709961</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 58 -1335245632 1968917183 1940861695 536816369
+            -1226071367 -570908176 457026619 1000020667</internalNodes>
+          <leafValues>
+            -0.4258328974246979 0.4202791750431061</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 94 -1360318719 -1979797897 -50435249 -18646473
+            -608879292 -805306691 -269304244 -17840167</internalNodes>
+          <leafValues>
+            -0.4561023116111755 0.4002747833728790</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 87 2062765935 -16449 -1275080721 -16406 45764335
+            -1090552065 -772846337 -570464322</internalNodes>
+          <leafValues>
+            -0.4314672648906708 0.4086346626281738</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 127 -536896021 1080817663 -738234288 -965478709
+            -2082767969 1290855887 1993822934 -990381609</internalNodes>
+          <leafValues>
+            -0.4174543321132660 0.4249868988990784</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 3 -818943025 168730891 -293610428 -79249354 669224671
+            621166734 1086506807 1473768907</internalNodes>
+          <leafValues>
+            -0.4321364760398865 0.4090838730335236</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 79 -68895696 -67107736 -1414315879 -841676168
+            -619843344 -1180610531 -1081990469 1043203389</internalNodes>
+          <leafValues>
+            -0.5018386244773865 0.3702533841133118</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 116 -54002134 -543485719 -2124882422 -1437445858
+            -115617074 -1195787391 -1096024366 -2140472445</internalNodes>
+          <leafValues>
+            -0.5037505626678467 0.3564981222152710</leafValues></_></weakClassifiers></_>
+    <!-- stage 17 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.4892596900463104</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 132 -67113211 2003808111 1862135111 846461923 -2752
+            2002237273 -273154752 1937223539</internalNodes>
+          <leafValues>
+            -0.2448196411132813 0.5689709186553955</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 62 1179423888 -78064940 -611839555 -539167899
+            -1289358360 -1650810108 -892540499 -1432827684</internalNodes>
+          <leafValues>
+            -0.4633283913135529 0.3587929606437683</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 23 -285212705 -78450761 -656212031 -264050110 -27787425
+            -1334349961 -547662981 -135796924</internalNodes>
+          <leafValues>
+            -0.3731099069118500 0.4290455579757690</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 77 341863476 403702016 -550588417 1600194541
+            -1080690735 951127993 -1388580949 -1153717473</internalNodes>
+          <leafValues>
+            -0.3658909499645233 0.4556473195552826</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 22 -586880702 -204831512 -100644596 -39319550
+            -1191150794 705692513 457203315 -75806957</internalNodes>
+          <leafValues>
+            -0.5214384198188782 0.3221037387847900</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 72 -416546870 545911370 -673716192 -775559454
+            -264113598 139424 -183369982 -204474641</internalNodes>
+          <leafValues>
+            -0.4289036989212036 0.4004956185817719</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 50 -1026505020 -589692154 -1740499937 -1563770497
+            1348491006 -60710713 -1109853489 -633909413</internalNodes>
+          <leafValues>
+            -0.4621542394161224 0.3832748532295227</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 108 -1448872304 -477895040 -1778390608 -772418127
+            -1789923416 -1612057181 -805306693 -1415842113</internalNodes>
+          <leafValues>
+            -0.3711548447608948 0.4612701535224915</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 92 407905424 -582449988 52654751 -1294472 -285103725
+            -74633006 1871559083 1057955850</internalNodes>
+          <leafValues>
+            -0.5180652141571045 0.3205870389938355</leafValues></_></weakClassifiers></_>
+    <!-- stage 18 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.5911940932273865</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 81 4112 -1259563825 -846671428 -100902460 1838164148
+            -74153752 -90653988 -1074263896</internalNodes>
+          <leafValues>
+            -0.2592592537403107 0.5873016119003296</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 1 -285216785 -823206977 -1085589 -1081346 1207959293
+            1157103471 2097133565 -2097169</internalNodes>
+          <leafValues>
+            -0.3801195919513702 0.4718827307224274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 121 -12465 -536875169 2147478367 2130706303 -37765492
+            -866124467 -318782328 -1392509185</internalNodes>
+          <leafValues>
+            -0.3509117066860199 0.5094807147979736</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 38 2147449663 -20741 -16794757 1945873146 -16710 -1
+            -8406341 -67663041</internalNodes>
+          <leafValues>
+            -0.4068757295608521 0.4130136370658875</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 17 -155191713 866117231 1651407483 548272812 -479201468
+            -447742449 1354229504 -261884429</internalNodes>
+          <leafValues>
+            -0.4557141065597534 0.3539792001247406</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 100 -225319378 -251682065 -492783986 -792341777
+            -1287261695 1393643841 -11274182 -213909521</internalNodes>
+          <leafValues>
+            -0.4117803275585175 0.4118592441082001</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 63 -382220122 -2002072729 -51404800 -371201558
+            -923011069 -2135301457 -2066104743 -1042557441</internalNodes>
+          <leafValues>
+            -0.4008397758007050 0.4034757018089294</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 101 -627353764 -48295149 1581203952 -436258614
+            -105268268 -1435893445 -638126888 -1061107126</internalNodes>
+          <leafValues>
+            -0.5694189667701721 0.2964762747287750</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 118 -8399181 1058107691 -621022752 -251003468 -12582915
+            -574619739 -994397789 -1648362021</internalNodes>
+          <leafValues>
+            -0.3195341229438782 0.5294018983840942</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 92 -348343812 -1078389516 1717960437 364735981
+            -1783841602 -4883137 -457572354 -1076950384</internalNodes>
+          <leafValues>
+            -0.3365339040756226 0.5067458748817444</leafValues></_></weakClassifiers></_>
+    <!-- stage 19 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.7612916231155396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 10 -1976661318 -287957604 -1659497122 -782068 43591089
+            -453637880 1435470000 -1077438561</internalNodes>
+          <leafValues>
+            -0.4204545319080353 0.5165745615959168</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 131 -67110925 14874979 -142633168 -1338923040
+            2046713291 -2067933195 1473503712 -789579837</internalNodes>
+          <leafValues>
+            -0.3762553930282593 0.4075302779674530</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 83 -272814301 -1577073 -1118685 -305156120 -1052289
+            -1073813756 -538971154 -355523038</internalNodes>
+          <leafValues>
+            -0.4253497421741486 0.3728055357933044</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 135 -2233 -214486242 -538514758 573747007 -159390971
+            1994225489 -973738098 -203424005</internalNodes>
+          <leafValues>
+            -0.3601998090744019 0.4563256204128265</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 115 -261031688 -1330369299 -641860609 1029570301
+            -1306461192 -1196149518 -1529767778 683139823</internalNodes>
+          <leafValues>
+            -0.4034293889999390 0.4160816967487335</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 64 -572993608 -34042628 -417865 -111109 -1433365268
+            -19869715 -1920939864 -1279457063</internalNodes>
+          <leafValues>
+            -0.3620899617671967 0.4594142735004425</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 36 -626275097 -615256993 1651946018 805366393
+            2016559730 -430780849 -799868165 -16580645</internalNodes>
+          <leafValues>
+            -0.3903816640377045 0.4381459355354309</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 93 1354797300 -1090957603 1976418270 -1342502178
+            -1851873892 -1194637077 -1153521668 -1108399474</internalNodes>
+          <leafValues>
+            -0.3591445386409760 0.4624078869819641</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 91 68157712 1211368313 -304759523 1063017136 798797750
+            -275513546 648167355 -1145357350</internalNodes>
+          <leafValues>
+            -0.4297670423984528 0.4023293554782867</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 107 -546318240 -1628569602 -163577944 -537002306
+            -545456389 -1325465645 -380446736 -1058473386</internalNodes>
+          <leafValues>
+            -0.5727006793022156 0.2995934784412384</leafValues></_></weakClassifiers></_></stages>
+  <features>
+    <_>
+      <rect>
+        0 0 3 5</rect></_>
+    <_>
+      <rect>
+        0 0 4 2</rect></_>
+    <_>
+      <rect>
+        0 0 6 3</rect></_>
+    <_>
+      <rect>
+        0 1 2 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 7</rect></_>
+    <_>
+      <rect>
+        0 4 3 3</rect></_>
+    <_>
+      <rect>
+        0 11 3 4</rect></_>
+    <_>
+      <rect>
+        0 12 8 4</rect></_>
+    <_>
+      <rect>
+        0 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 0 5 3</rect></_>
+    <_>
+      <rect>
+        1 1 2 2</rect></_>
+    <_>
+      <rect>
+        1 3 3 1</rect></_>
+    <_>
+      <rect>
+        1 7 4 4</rect></_>
+    <_>
+      <rect>
+        1 12 2 2</rect></_>
+    <_>
+      <rect>
+        1 13 4 1</rect></_>
+    <_>
+      <rect>
+        1 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 17 3 2</rect></_>
+    <_>
+      <rect>
+        2 0 2 3</rect></_>
+    <_>
+      <rect>
+        2 1 2 2</rect></_>
+    <_>
+      <rect>
+        2 2 4 6</rect></_>
+    <_>
+      <rect>
+        2 3 4 4</rect></_>
+    <_>
+      <rect>
+        2 7 2 1</rect></_>
+    <_>
+      <rect>
+        2 11 2 3</rect></_>
+    <_>
+      <rect>
+        2 17 3 2</rect></_>
+    <_>
+      <rect>
+        3 0 2 2</rect></_>
+    <_>
+      <rect>
+        3 1 7 3</rect></_>
+    <_>
+      <rect>
+        3 7 2 1</rect></_>
+    <_>
+      <rect>
+        3 7 2 4</rect></_>
+    <_>
+      <rect>
+        3 18 2 2</rect></_>
+    <_>
+      <rect>
+        4 0 2 3</rect></_>
+    <_>
+      <rect>
+        4 3 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 5</rect></_>
+    <_>
+      <rect>
+        4 7 5 2</rect></_>
+    <_>
+      <rect>
+        4 8 4 3</rect></_>
+    <_>
+      <rect>
+        4 18 2 2</rect></_>
+    <_>
+      <rect>
+        5 0 2 2</rect></_>
+    <_>
+      <rect>
+        5 3 4 4</rect></_>
+    <_>
+      <rect>
+        5 6 2 5</rect></_>
+    <_>
+      <rect>
+        5 9 2 2</rect></_>
+    <_>
+      <rect>
+        5 10 2 2</rect></_>
+    <_>
+      <rect>
+        6 3 4 4</rect></_>
+    <_>
+      <rect>
+        6 4 4 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 5</rect></_>
+    <_>
+      <rect>
+        6 5 4 3</rect></_>
+    <_>
+      <rect>
+        6 6 4 2</rect></_>
+    <_>
+      <rect>
+        6 6 4 4</rect></_>
+    <_>
+      <rect>
+        6 18 1 2</rect></_>
+    <_>
+      <rect>
+        6 21 2 1</rect></_>
+    <_>
+      <rect>
+        7 0 3 7</rect></_>
+    <_>
+      <rect>
+        7 4 2 3</rect></_>
+    <_>
+      <rect>
+        7 9 5 1</rect></_>
+    <_>
+      <rect>
+        7 21 2 1</rect></_>
+    <_>
+      <rect>
+        8 0 1 4</rect></_>
+    <_>
+      <rect>
+        8 5 2 2</rect></_>
+    <_>
+      <rect>
+        8 5 3 2</rect></_>
+    <_>
+      <rect>
+        8 17 3 1</rect></_>
+    <_>
+      <rect>
+        8 18 1 2</rect></_>
+    <_>
+      <rect>
+        9 0 5 3</rect></_>
+    <_>
+      <rect>
+        9 2 2 6</rect></_>
+    <_>
+      <rect>
+        9 5 1 1</rect></_>
+    <_>
+      <rect>
+        9 11 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 2 1</rect></_>
+    <_>
+      <rect>
+        9 17 1 1</rect></_>
+    <_>
+      <rect>
+        9 18 1 1</rect></_>
+    <_>
+      <rect>
+        10 5 1 2</rect></_>
+    <_>
+      <rect>
+        10 5 3 3</rect></_>
+    <_>
+      <rect>
+        10 7 1 5</rect></_>
+    <_>
+      <rect>
+        10 8 1 1</rect></_>
+    <_>
+      <rect>
+        10 9 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 2</rect></_>
+    <_>
+      <rect>
+        10 14 3 3</rect></_>
+    <_>
+      <rect>
+        10 15 1 1</rect></_>
+    <_>
+      <rect>
+        10 15 2 1</rect></_>
+    <_>
+      <rect>
+        10 16 1 1</rect></_>
+    <_>
+      <rect>
+        10 16 2 1</rect></_>
+    <_>
+      <rect>
+        10 17 1 1</rect></_>
+    <_>
+      <rect>
+        10 21 1 1</rect></_>
+    <_>
+      <rect>
+        11 3 2 2</rect></_>
+    <_>
+      <rect>
+        11 5 1 2</rect></_>
+    <_>
+      <rect>
+        11 5 3 3</rect></_>
+    <_>
+      <rect>
+        11 5 4 6</rect></_>
+    <_>
+      <rect>
+        11 6 1 1</rect></_>
+    <_>
+      <rect>
+        11 7 2 2</rect></_>
+    <_>
+      <rect>
+        11 8 1 2</rect></_>
+    <_>
+      <rect>
+        11 10 1 1</rect></_>
+    <_>
+      <rect>
+        11 10 1 2</rect></_>
+    <_>
+      <rect>
+        11 15 1 1</rect></_>
+    <_>
+      <rect>
+        11 17 1 1</rect></_>
+    <_>
+      <rect>
+        11 18 1 1</rect></_>
+    <_>
+      <rect>
+        12 0 2 2</rect></_>
+    <_>
+      <rect>
+        12 1 2 5</rect></_>
+    <_>
+      <rect>
+        12 2 4 1</rect></_>
+    <_>
+      <rect>
+        12 3 1 3</rect></_>
+    <_>
+      <rect>
+        12 7 3 4</rect></_>
+    <_>
+      <rect>
+        12 10 3 2</rect></_>
+    <_>
+      <rect>
+        12 11 1 1</rect></_>
+    <_>
+      <rect>
+        12 12 3 2</rect></_>
+    <_>
+      <rect>
+        12 14 4 3</rect></_>
+    <_>
+      <rect>
+        12 17 1 1</rect></_>
+    <_>
+      <rect>
+        12 21 2 1</rect></_>
+    <_>
+      <rect>
+        13 6 2 5</rect></_>
+    <_>
+      <rect>
+        13 7 3 5</rect></_>
+    <_>
+      <rect>
+        13 11 3 2</rect></_>
+    <_>
+      <rect>
+        13 17 2 2</rect></_>
+    <_>
+      <rect>
+        13 17 3 2</rect></_>
+    <_>
+      <rect>
+        13 18 1 2</rect></_>
+    <_>
+      <rect>
+        13 18 2 2</rect></_>
+    <_>
+      <rect>
+        14 0 2 2</rect></_>
+    <_>
+      <rect>
+        14 1 1 3</rect></_>
+    <_>
+      <rect>
+        14 2 3 2</rect></_>
+    <_>
+      <rect>
+        14 7 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 3 3</rect></_>
+    <_>
+      <rect>
+        14 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 3</rect></_>
+    <_>
+      <rect>
+        15 4 3 2</rect></_>
+    <_>
+      <rect>
+        15 4 3 6</rect></_>
+    <_>
+      <rect>
+        15 6 3 2</rect></_>
+    <_>
+      <rect>
+        15 11 3 4</rect></_>
+    <_>
+      <rect>
+        15 13 3 2</rect></_>
+    <_>
+      <rect>
+        15 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 17 3 2</rect></_>
+    <_>
+      <rect>
+        16 1 2 3</rect></_>
+    <_>
+      <rect>
+        16 3 2 4</rect></_>
+    <_>
+      <rect>
+        16 6 1 1</rect></_>
+    <_>
+      <rect>
+        16 16 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 5</rect></_>
+    <_>
+      <rect>
+        17 12 2 2</rect></_>
+    <_>
+      <rect>
+        18 0 2 2</rect></_></features></cascade>
+</opencv_storage>

envs/kitoverlay/skimage/feature/__init__.py

@@ -0,0 +1,5 @@
+"""Feature detection and extraction, e.g., texture analysis, corners, etc."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/feature/__init__.pyi

@@ -0,0 +1,88 @@
+# 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__ = [
+    'canny',
+    'Cascade',
+    'daisy',
+    'hog',
+    'graycomatrix',
+    'graycoprops',
+    'local_binary_pattern',
+    'multiblock_lbp',
+    'draw_multiblock_lbp',
+    'peak_local_max',
+    'structure_tensor',
+    'structure_tensor_eigenvalues',
+    'hessian_matrix',
+    'hessian_matrix_det',
+    'hessian_matrix_eigvals',
+    'shape_index',
+    'corner_kitchen_rosenfeld',
+    'corner_harris',
+    'corner_shi_tomasi',
+    'corner_foerstner',
+    'corner_subpix',
+    'corner_peaks',
+    'corner_moravec',
+    'corner_fast',
+    'corner_orientations',
+    'match_template',
+    'BRIEF',
+    'CENSURE',
+    'ORB',
+    'SIFT',
+    'match_descriptors',
+    'plot_matched_features',
+    'blob_dog',
+    'blob_doh',
+    'blob_log',
+    'haar_like_feature',
+    'haar_like_feature_coord',
+    'draw_haar_like_feature',
+    'multiscale_basic_features',
+    'learn_gmm',
+    'fisher_vector',
+]
+
+from ._canny import canny
+from ._cascade import Cascade
+from ._daisy import daisy
+from ._hog import hog
+from .texture import (
+    graycomatrix,
+    graycoprops,
+    local_binary_pattern,
+    multiblock_lbp,
+    draw_multiblock_lbp,
+)
+from .peak import peak_local_max
+from .corner import (
+    corner_kitchen_rosenfeld,
+    corner_harris,
+    corner_shi_tomasi,
+    corner_foerstner,
+    corner_subpix,
+    corner_peaks,
+    corner_fast,
+    structure_tensor,
+    structure_tensor_eigenvalues,
+    hessian_matrix,
+    hessian_matrix_eigvals,
+    hessian_matrix_det,
+    corner_moravec,
+    corner_orientations,
+    shape_index,
+)
+from .template import match_template
+from .brief import BRIEF
+from .censure import CENSURE
+from .orb import ORB
+from .sift import SIFT
+from .match import match_descriptors
+from .util import plot_matched_features
+from .blob import blob_dog, blob_log, blob_doh
+from .haar import haar_like_feature, haar_like_feature_coord, draw_haar_like_feature
+from ._basic_features import multiscale_basic_features
+from ._fisher_vector import learn_gmm, fisher_vector

envs/kitoverlay/skimage/feature/_basic_features.py

@@ -0,0 +1,198 @@
+from itertools import combinations_with_replacement
+import itertools
+import numpy as np
+from skimage import filters, feature
+from skimage.util.dtype import img_as_float32
+from .._shared._dependency_checks import is_wasm
+
+if not is_wasm:
+    from concurrent.futures import ThreadPoolExecutor as PoolExecutor
+else:
+    from contextlib import AbstractContextManager
+
+    # Threading isn't supported on WASM, mock ThreadPoolExecutor as a fallback
+    class PoolExecutor(AbstractContextManager):
+        def __init__(self, *_, **__):
+            pass
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            pass
+
+        def map(self, fn, iterables):
+            return map(fn, iterables)
+
+
+def _texture_filter(gaussian_filtered):
+    H_elems = [
+        np.gradient(np.gradient(gaussian_filtered)[ax0], axis=ax1)
+        for ax0, ax1 in combinations_with_replacement(range(gaussian_filtered.ndim), 2)
+    ]
+    eigvals = feature.hessian_matrix_eigvals(H_elems)
+    return eigvals
+
+
+def _singlescale_basic_features_singlechannel(
+    img, sigma, intensity=True, edges=True, texture=True
+):
+    results = ()
+    gaussian_filtered = filters.gaussian(img, sigma=sigma, preserve_range=False)
+    if intensity:
+        results += (gaussian_filtered,)
+    if edges:
+        results += (filters.sobel(gaussian_filtered),)
+    if texture:
+        results += (*_texture_filter(gaussian_filtered),)
+    return results
+
+
+def _mutiscale_basic_features_singlechannel(
+    img,
+    intensity=True,
+    edges=True,
+    texture=True,
+    sigma_min=0.5,
+    sigma_max=16,
+    num_sigma=None,
+    workers=None,
+):
+    """Features for a single channel nd image.
+
+    Parameters
+    ----------
+    img : ndarray
+        Input image, which can be grayscale or multichannel.
+    intensity : bool, default True
+        If True, pixel intensities averaged over the different scales
+        are added to the feature set.
+    edges : bool, default True
+        If True, intensities of local gradients averaged over the different
+        scales are added to the feature set.
+    texture : bool, default True
+        If True, eigenvalues of the Hessian matrix after Gaussian blurring
+        at different scales are added to the feature set.
+    sigma_min : float, optional
+        Smallest value of the Gaussian kernel used to average local
+        neighborhoods before extracting features.
+    sigma_max : float, optional
+        Largest value of the Gaussian kernel used to average local
+        neighborhoods before extracting features.
+    num_sigma : int, optional
+        Number of values of the Gaussian kernel between sigma_min and sigma_max.
+        If None, sigma_min multiplied by powers of 2 are used.
+    workers : int or None, optional
+        The number of parallel threads to use. If set to ``None``, the full
+        set of available cores are used.
+
+    Returns
+    -------
+    features : list
+        List of features, each element of the list is an array of shape as img.
+    """
+    # computations are faster as float32
+    img = np.ascontiguousarray(img_as_float32(img))
+    if num_sigma is None:
+        num_sigma = int(np.log2(sigma_max) - np.log2(sigma_min) + 1)
+    sigmas = np.logspace(
+        np.log2(sigma_min),
+        np.log2(sigma_max),
+        num=num_sigma,
+        base=2,
+        endpoint=True,
+    )
+    with PoolExecutor(max_workers=workers) as ex:
+        out_sigmas = list(
+            ex.map(
+                lambda s: _singlescale_basic_features_singlechannel(
+                    img, s, intensity=intensity, edges=edges, texture=texture
+                ),
+                sigmas,
+            )
+        )
+    features = itertools.chain.from_iterable(out_sigmas)
+    return features
+
+
+def multiscale_basic_features(
+    image,
+    intensity=True,
+    edges=True,
+    texture=True,
+    sigma_min=0.5,
+    sigma_max=16,
+    num_sigma=None,
+    workers=None,
+    *,
+    channel_axis=None,
+):
+    """Local features for a single- or multi-channel nd image.
+
+    Intensity, gradient intensity and local structure are computed at
+    different scales thanks to Gaussian blurring.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image, which can be grayscale or multichannel.
+    intensity : bool, default True
+        If True, pixel intensities averaged over the different scales
+        are added to the feature set.
+    edges : bool, default True
+        If True, intensities of local gradients averaged over the different
+        scales are added to the feature set.
+    texture : bool, default True
+        If True, eigenvalues of the Hessian matrix after Gaussian blurring
+        at different scales are added to the feature set.
+    sigma_min : float, optional
+        Smallest value of the Gaussian kernel used to average local
+        neighborhoods before extracting features.
+    sigma_max : float, optional
+        Largest value of the Gaussian kernel used to average local
+        neighborhoods before extracting features.
+    num_sigma : int, optional
+        Number of values of the Gaussian kernel between sigma_min and sigma_max.
+        If None, sigma_min multiplied by powers of 2 are used.
+    workers : int or None, optional
+        The number of parallel threads to use. If set to ``None``, the full
+        set of available cores are used.
+    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.
+
+    Returns
+    -------
+    features : np.ndarray
+        Array of shape ``image.shape + (n_features,)``. When `channel_axis` is
+        not None, all channels are concatenated along the features dimension.
+        (i.e. ``n_features == n_features_singlechannel * n_channels``)
+    """
+    if not any([intensity, edges, texture]):
+        raise ValueError(
+            "At least one of `intensity`, `edges` or `textures`"
+            "must be True for features to be computed."
+        )
+    if channel_axis is None:
+        image = image[..., np.newaxis]
+        channel_axis = -1
+    elif channel_axis != -1:
+        image = np.moveaxis(image, channel_axis, -1)
+
+    all_results = (
+        _mutiscale_basic_features_singlechannel(
+            image[..., dim],
+            intensity=intensity,
+            edges=edges,
+            texture=texture,
+            sigma_min=sigma_min,
+            sigma_max=sigma_max,
+            num_sigma=num_sigma,
+            workers=workers,
+        )
+        for dim in range(image.shape[-1])
+    )
+    features = list(itertools.chain.from_iterable(all_results))
+    out = np.stack(features, axis=-1)
+    return out

envs/kitoverlay/skimage/feature/_canny.py

@@ -0,0 +1,262 @@
+"""
+canny.py - Canny Edge detector
+
+Reference: Canny, J., A Computational Approach To Edge Detection, IEEE Trans.
+    Pattern Analysis and Machine Intelligence, 8:679-714, 1986
+"""
+
+import numpy as np
+import scipy.ndimage as ndi
+
+from ..util.dtype import dtype_limits
+from .._shared.filters import gaussian
+from .._shared.utils import _supported_float_type, check_nD
+from ._canny_cy import _nonmaximum_suppression_bilinear
+
+
+def _preprocess(image, mask, sigma, mode, cval):
+    """Generate a smoothed image and an eroded mask.
+
+    The image is smoothed using a gaussian filter ignoring masked
+    pixels and the mask is eroded.
+
+    Parameters
+    ----------
+    image : array
+        Image to be smoothed.
+    mask : array
+        Mask with 1's for significant pixels, 0's for masked pixels.
+    sigma : scalar or sequence of scalars
+        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 : str, {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}
+        The ``mode`` parameter determines how the array borders are
+        handled, where ``cval`` is the value when mode is equal to
+        'constant'.
+    cval : float, optional
+        Value to fill past edges of input if `mode` is 'constant'.
+
+    Returns
+    -------
+    smoothed_image : ndarray
+        The smoothed array
+    eroded_mask : ndarray
+        The eroded mask.
+
+    Notes
+    -----
+    This function calculates the fractional contribution of masked pixels
+    by applying the function to the mask (which gets you the fraction of
+    the pixel data that's due to significant points). We then mask the image
+    and apply the function. The resulting values will be lower by the
+    bleed-over fraction, so you can recalibrate by dividing by the function
+    on the mask to recover the effect of smoothing from just the significant
+    pixels.
+    """
+    gaussian_kwargs = dict(sigma=sigma, mode=mode, cval=cval, preserve_range=False)
+    compute_bleedover = mode == 'constant' or mask is not None
+    float_type = _supported_float_type(image.dtype)
+    if mask is None:
+        if compute_bleedover:
+            mask = np.ones(image.shape, dtype=float_type)
+        masked_image = image
+
+        eroded_mask = np.ones(image.shape, dtype=bool)
+        eroded_mask[:1, :] = 0
+        eroded_mask[-1:, :] = 0
+        eroded_mask[:, :1] = 0
+        eroded_mask[:, -1:] = 0
+
+    else:
+        mask = mask.astype(bool, copy=False)
+        masked_image = np.zeros_like(image)
+        masked_image[mask] = image[mask]
+
+        # Make the eroded mask. Setting the border value to zero will wipe
+        # out the image edges for us.
+        s = ndi.generate_binary_structure(2, 2)
+        eroded_mask = ndi.binary_erosion(mask, s, border_value=0)
+
+    if compute_bleedover:
+        # Compute the fractional contribution of masked pixels by applying
+        # the function to the mask (which gets you the fraction of the
+        # pixel data that's due to significant points)
+        bleed_over = (
+            gaussian(mask.astype(float_type, copy=False), **gaussian_kwargs)
+            + np.finfo(float_type).eps
+        )
+
+    # Smooth the masked image
+    smoothed_image = gaussian(masked_image, **gaussian_kwargs)
+
+    # Lower the result by the bleed-over fraction, so you can
+    # recalibrate by dividing by the function on the mask to recover
+    # the effect of smoothing from just the significant pixels.
+    if compute_bleedover:
+        smoothed_image /= bleed_over
+
+    return smoothed_image, eroded_mask
+
+
+def canny(
+    image,
+    sigma=1.0,
+    low_threshold=None,
+    high_threshold=None,
+    mask=None,
+    use_quantiles=False,
+    *,
+    mode='constant',
+    cval=0.0,
+):
+    """Edge filter an image using the Canny algorithm.
+
+    Parameters
+    ----------
+    image : 2D array
+        Grayscale input image to detect edges on; can be of any dtype.
+    sigma : float, optional
+        Standard deviation of the Gaussian filter.
+    low_threshold : float, optional
+        Lower bound for hysteresis thresholding (linking edges).
+        If None, low_threshold is set to 10% of dtype's max.
+    high_threshold : float, optional
+        Upper bound for hysteresis thresholding (linking edges).
+        If None, high_threshold is set to 20% of dtype's max.
+    mask : array, dtype=bool, optional
+        Mask to limit the application of Canny to a certain area.
+    use_quantiles : bool, optional
+        If ``True`` then treat low_threshold and high_threshold as
+        quantiles of the edge magnitude image, rather than absolute
+        edge magnitude values. If ``True`` then the thresholds must be
+        in the range [0, 1].
+    mode : str, {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}
+        The ``mode`` parameter determines how the array borders are
+        handled during Gaussian filtering, where ``cval`` is the value when
+        mode is equal to 'constant'.
+    cval : float, optional
+        Value to fill past edges of input if `mode` is 'constant'.
+
+    Returns
+    -------
+    output : 2D array (image)
+        The binary edge map.
+
+    See also
+    --------
+    skimage.filters.sobel
+
+    Notes
+    -----
+    The steps of the algorithm are as follows:
+
+    * Smooth the image using a Gaussian with ``sigma`` width.
+
+    * Apply the horizontal and vertical Sobel operators to get the gradients
+      within the image. The edge strength is the norm of the gradient.
+
+    * Thin potential edges to 1-pixel wide curves. First, find the normal
+      to the edge at each point. This is done by looking at the
+      signs and the relative magnitude of the X-Sobel and Y-Sobel
+      to sort the points into 4 categories: horizontal, vertical,
+      diagonal and antidiagonal. Then look in the normal and reverse
+      directions to see if the values in either of those directions are
+      greater than the point in question. Use interpolation to get a mix of
+      points instead of picking the one that's the closest to the normal.
+
+    * Perform a hysteresis thresholding: first label all points above the
+      high threshold as edges. Then recursively label any point above the
+      low threshold that is 8-connected to a labeled point as an edge.
+
+    References
+    ----------
+    .. [1] Canny, J., A Computational Approach To Edge Detection, IEEE Trans.
+           Pattern Analysis and Machine Intelligence, 8:679-714, 1986
+           :DOI:`10.1109/TPAMI.1986.4767851`
+    .. [2] William Green's Canny tutorial
+           https://en.wikipedia.org/wiki/Canny_edge_detector
+
+    Examples
+    --------
+    >>> from skimage import feature
+    >>> rng = np.random.default_rng()
+    >>> # Generate noisy image of a square
+    >>> im = np.zeros((256, 256))
+    >>> im[64:-64, 64:-64] = 1
+    >>> im += 0.2 * rng.random(im.shape)
+    >>> # First trial with the Canny filter, with the default smoothing
+    >>> edges1 = feature.canny(im)
+    >>> # Increase the smoothing for better results
+    >>> edges2 = feature.canny(im, sigma=3)
+
+    """
+
+    # Regarding masks, any point touching a masked point will have a gradient
+    # that is "infected" by the masked point, so it's enough to erode the
+    # mask by one and then mask the output. We also mask out the border points
+    # because who knows what lies beyond the edge of the image?
+
+    if np.issubdtype(image.dtype, np.int64) or np.issubdtype(image.dtype, np.uint64):
+        raise ValueError("64-bit integer images are not supported")
+
+    check_nD(image, 2)
+    dtype_max = dtype_limits(image, clip_negative=False)[1]
+
+    if low_threshold is None:
+        low_threshold = 0.1
+    elif use_quantiles:
+        if not (0.0 <= low_threshold <= 1.0):
+            raise ValueError("Quantile thresholds must be between 0 and 1.")
+    else:
+        low_threshold /= dtype_max
+
+    if high_threshold is None:
+        high_threshold = 0.2
+    elif use_quantiles:
+        if not (0.0 <= high_threshold <= 1.0):
+            raise ValueError("Quantile thresholds must be between 0 and 1.")
+    else:
+        high_threshold /= dtype_max
+
+    if high_threshold < low_threshold:
+        raise ValueError("low_threshold should be lower then high_threshold")
+
+    # Image filtering
+    smoothed, eroded_mask = _preprocess(image, mask, sigma, mode, cval)
+
+    # Gradient magnitude estimation
+    jsobel = ndi.sobel(smoothed, axis=1)
+    isobel = ndi.sobel(smoothed, axis=0)
+    magnitude = isobel * isobel
+    magnitude += jsobel * jsobel
+    np.sqrt(magnitude, out=magnitude)
+
+    if use_quantiles:
+        low_threshold, high_threshold = np.percentile(
+            magnitude, [100.0 * low_threshold, 100.0 * high_threshold]
+        )
+
+    # Non-maximum suppression
+    low_masked = _nonmaximum_suppression_bilinear(
+        isobel, jsobel, magnitude, eroded_mask, low_threshold
+    )
+
+    # Double thresholding and edge tracking
+    #
+    # Segment the low-mask, then only keep low-segments that have
+    # some high_mask component in them
+    #
+    low_mask = low_masked > 0
+    strel = np.ones((3, 3), bool)
+    labels, count = ndi.label(low_mask, strel)
+    if count == 0:
+        return low_mask
+
+    high_mask = low_mask & (low_masked >= high_threshold)
+    nonzero_sums = np.unique(labels[high_mask])
+    good_label = np.zeros((count + 1,), bool)
+    good_label[nonzero_sums] = True
+    output_mask = good_label[labels]
+    return output_mask

envs/kitoverlay/skimage/feature/_daisy.py

@@ -0,0 +1,249 @@
+import math
+
+import numpy as np
+from numpy import arctan2, exp, pi, sqrt
+
+from .. import draw
+from ..util.dtype import img_as_float
+from .._shared.filters import gaussian
+from .._shared.utils import check_nD
+from ..color import gray2rgb
+
+
+def daisy(
+    image,
+    step=4,
+    radius=15,
+    rings=3,
+    histograms=8,
+    orientations=8,
+    normalization='l1',
+    sigmas=None,
+    ring_radii=None,
+    visualize=False,
+):
+    '''Extract DAISY feature descriptors densely for the given image.
+
+    DAISY is a feature descriptor similar to SIFT formulated in a way that
+    allows for fast dense extraction. Typically, this is practical for
+    bag-of-features image representations.
+
+    The implementation follows Tola et al. [1]_ but deviate on the following
+    points:
+
+      * Histogram bin contribution are smoothed with a circular Gaussian
+        window over the tonal range (the angular range).
+      * The sigma values of the spatial Gaussian smoothing in this code do not
+        match the sigma values in the original code by Tola et al. [2]_. In
+        their code, spatial smoothing is applied to both the input image and
+        the center histogram. However, this smoothing is not documented in [1]_
+        and, therefore, it is omitted.
+
+    Parameters
+    ----------
+    image : (M, N) array
+        Input image (grayscale).
+    step : int, optional
+        Distance between descriptor sampling points.
+    radius : int, optional
+        Radius (in pixels) of the outermost ring.
+    rings : int, optional
+        Number of rings.
+    histograms : int, optional
+        Number of histograms sampled per ring.
+    orientations : int, optional
+        Number of orientations (bins) per histogram.
+    normalization : [ 'l1' | 'l2' | 'daisy' | 'off' ], optional
+        How to normalize the descriptors
+
+          * 'l1': L1-normalization of each descriptor.
+          * 'l2': L2-normalization of each descriptor.
+          * 'daisy': L2-normalization of individual histograms.
+          * 'off': Disable normalization.
+
+    sigmas : 1D array of float, optional
+        Standard deviation of spatial Gaussian smoothing for the center
+        histogram and for each ring of histograms. The array of sigmas should
+        be sorted from the center and out. I.e. the first sigma value defines
+        the spatial smoothing of the center histogram and the last sigma value
+        defines the spatial smoothing of the outermost ring. Specifying sigmas
+        overrides the following parameter.
+
+            ``rings = len(sigmas) - 1``
+
+    ring_radii : 1D array of int, optional
+        Radius (in pixels) for each ring. Specifying ring_radii overrides the
+        following two parameters.
+
+            ``rings = len(ring_radii)``
+            ``radius = ring_radii[-1]``
+
+        If both sigmas and ring_radii are given, they must satisfy the
+        following predicate since no radius is needed for the center
+        histogram.
+
+            ``len(ring_radii) == len(sigmas) + 1``
+
+    visualize : bool, optional
+        Generate a visualization of the DAISY descriptors
+
+    Returns
+    -------
+    descs : array
+        Grid of DAISY descriptors for the given image as an array
+        dimensionality  (P, Q, R) where
+
+            ``P = ceil((M - radius*2) / step)``
+            ``Q = ceil((N - radius*2) / step)``
+            ``R = (rings * histograms + 1) * orientations``
+
+    descs_img : (M, N, 3) array (only if visualize==True)
+        Visualization of the DAISY descriptors.
+
+    References
+    ----------
+    .. [1] Tola et al. "Daisy: An efficient dense descriptor applied to wide-
+           baseline stereo." Pattern Analysis and Machine Intelligence, IEEE
+           Transactions on 32.5 (2010): 815-830.
+    .. [2] http://cvlab.epfl.ch/software/daisy
+    '''
+
+    check_nD(image, 2, 'img')
+
+    image = img_as_float(image)
+    float_dtype = image.dtype
+
+    # Validate parameters.
+    if (
+        sigmas is not None
+        and ring_radii is not None
+        and len(sigmas) - 1 != len(ring_radii)
+    ):
+        raise ValueError('`len(sigmas)-1 != len(ring_radii)`')
+    if ring_radii is not None:
+        rings = len(ring_radii)
+        radius = ring_radii[-1]
+    if sigmas is not None:
+        rings = len(sigmas) - 1
+    if sigmas is None:
+        sigmas = [radius * (i + 1) / float(2 * rings) for i in range(rings)]
+    if ring_radii is None:
+        ring_radii = [radius * (i + 1) / float(rings) for i in range(rings)]
+    if normalization not in ['l1', 'l2', 'daisy', 'off']:
+        raise ValueError('Invalid normalization method.')
+
+    # Compute image derivatives.
+    dx = np.zeros(image.shape, dtype=float_dtype)
+    dy = np.zeros(image.shape, dtype=float_dtype)
+    dx[:, :-1] = np.diff(image, n=1, axis=1)
+    dy[:-1, :] = np.diff(image, n=1, axis=0)
+
+    # Compute gradient orientation and magnitude and their contribution
+    # to the histograms.
+    grad_mag = sqrt(dx**2 + dy**2)
+    grad_ori = arctan2(dy, dx)
+    orientation_kappa = orientations / pi
+    orientation_angles = [2 * o * pi / orientations - pi for o in range(orientations)]
+    hist = np.empty((orientations,) + image.shape, dtype=float_dtype)
+    for i, o in enumerate(orientation_angles):
+        # Weigh bin contribution by the circular normal distribution
+        hist[i, :, :] = exp(orientation_kappa * np.cos(grad_ori - o))
+        # Weigh bin contribution by the gradient magnitude
+        hist[i, :, :] = np.multiply(hist[i, :, :], grad_mag)
+
+    # Smooth orientation histograms for the center and all rings.
+    sigmas = [sigmas[0]] + sigmas
+    hist_smooth = np.empty((rings + 1,) + hist.shape, dtype=float_dtype)
+    for i in range(rings + 1):
+        for j in range(orientations):
+            hist_smooth[i, j, :, :] = gaussian(
+                hist[j, :, :], sigma=sigmas[i], mode='reflect'
+            )
+
+    # Assemble descriptor grid.
+    theta = [2 * pi * j / histograms for j in range(histograms)]
+    desc_dims = (rings * histograms + 1) * orientations
+    descs = np.empty(
+        (desc_dims, image.shape[0] - 2 * radius, image.shape[1] - 2 * radius),
+        dtype=float_dtype,
+    )
+    descs[:orientations, :, :] = hist_smooth[0, :, radius:-radius, radius:-radius]
+    idx = orientations
+    for i in range(rings):
+        for j in range(histograms):
+            y_min = radius + int(round(ring_radii[i] * math.sin(theta[j])))
+            y_max = descs.shape[1] + y_min
+            x_min = radius + int(round(ring_radii[i] * math.cos(theta[j])))
+            x_max = descs.shape[2] + x_min
+            descs[idx : idx + orientations, :, :] = hist_smooth[
+                i + 1, :, y_min:y_max, x_min:x_max
+            ]
+            idx += orientations
+    descs = descs[:, ::step, ::step]
+    descs = descs.swapaxes(0, 1).swapaxes(1, 2)
+
+    # Normalize descriptors.
+    if normalization != 'off':
+        descs += 1e-10
+        if normalization == 'l1':
+            descs /= np.sum(descs, axis=2)[:, :, np.newaxis]
+        elif normalization == 'l2':
+            descs /= sqrt(np.sum(descs**2, axis=2))[:, :, np.newaxis]
+        elif normalization == 'daisy':
+            for i in range(0, desc_dims, orientations):
+                norms = sqrt(np.sum(descs[:, :, i : i + orientations] ** 2, axis=2))
+                descs[:, :, i : i + orientations] /= norms[:, :, np.newaxis]
+
+    if visualize:
+        descs_img = gray2rgb(image)
+        for i in range(descs.shape[0]):
+            for j in range(descs.shape[1]):
+                # Draw center histogram sigma
+                color = [1, 0, 0]
+                desc_y = i * step + radius
+                desc_x = j * step + radius
+                rows, cols, val = draw.circle_perimeter_aa(
+                    desc_y, desc_x, int(sigmas[0])
+                )
+                draw.set_color(descs_img, (rows, cols), color, alpha=val)
+                max_bin = np.max(descs[i, j, :])
+                for o_num, o in enumerate(orientation_angles):
+                    # Draw center histogram bins
+                    bin_size = descs[i, j, o_num] / max_bin
+                    dy = sigmas[0] * bin_size * math.sin(o)
+                    dx = sigmas[0] * bin_size * math.cos(o)
+                    rows, cols, val = draw.line_aa(
+                        desc_y, desc_x, int(desc_y + dy), int(desc_x + dx)
+                    )
+                    draw.set_color(descs_img, (rows, cols), color, alpha=val)
+                for r_num, r in enumerate(ring_radii):
+                    color_offset = float(1 + r_num) / rings
+                    color = (1 - color_offset, 1, color_offset)
+                    for t_num, t in enumerate(theta):
+                        # Draw ring histogram sigmas
+                        hist_y = desc_y + int(round(r * math.sin(t)))
+                        hist_x = desc_x + int(round(r * math.cos(t)))
+                        rows, cols, val = draw.circle_perimeter_aa(
+                            hist_y, hist_x, int(sigmas[r_num + 1])
+                        )
+                        draw.set_color(descs_img, (rows, cols), color, alpha=val)
+                        for o_num, o in enumerate(orientation_angles):
+                            # Draw histogram bins
+                            bin_size = descs[
+                                i,
+                                j,
+                                orientations
+                                + r_num * histograms * orientations
+                                + t_num * orientations
+                                + o_num,
+                            ]
+                            bin_size /= max_bin
+                            dy = sigmas[r_num + 1] * bin_size * math.sin(o)
+                            dx = sigmas[r_num + 1] * bin_size * math.cos(o)
+                            rows, cols, val = draw.line_aa(
+                                hist_y, hist_x, int(hist_y + dy), int(hist_x + dx)
+                            )
+                            draw.set_color(descs_img, (rows, cols), color, alpha=val)
+        return descs, descs_img
+    else:
+        return descs

envs/kitoverlay/skimage/feature/_fisher_vector.py

@@ -0,0 +1,262 @@
+"""
+fisher_vector.py - Implementation of the Fisher vector encoding algorithm
+
+This module contains the source code for Fisher vector computation. The
+computation is separated into two distinct steps, which are called separately
+by the user, namely:
+
+learn_gmm: Used to estimate the GMM for all vectors/descriptors computed for
+           all examples in the dataset (e.g. estimated using all the SIFT
+           vectors computed for all images in the dataset, or at least a subset
+           of this).
+
+fisher_vector: Used to compute the Fisher vector representation for a
+               single set of descriptors/vector (e.g. the SIFT
+               descriptors for a single image in your dataset, or
+               perhaps a test image).
+
+Reference: Perronnin, F. and Dance, C. Fisher kernels on Visual Vocabularies
+           for Image Categorization, IEEE Conference on Computer Vision and
+           Pattern Recognition, 2007
+
+Origin Author: Dan Oneata (Author of the original implementation for the Fisher
+vector computation using scikit-learn and NumPy. Subsequently ported to
+scikit-image (here) by other authors.)
+"""
+
+import numpy as np
+
+
+__doctest_requires__ = {("learn_gmm", "fisher_vector"): ["sklearn"]}
+
+
+class FisherVectorException(Exception):
+    pass
+
+
+class DescriptorException(FisherVectorException):
+    pass
+
+
+def learn_gmm(descriptors, *, n_modes=32, gm_args=None):
+    """Estimate a Gaussian mixture model (GMM) given a set of descriptors and
+    number of modes (i.e. Gaussians). This function is essentially a wrapper
+    around the scikit-learn implementation of GMM, namely the
+    :class:`sklearn.mixture.GaussianMixture` class.
+
+    Due to the nature of the Fisher vector, the only enforced parameter of the
+    underlying scikit-learn class is the covariance_type, which must be 'diag'.
+
+    There is no simple way to know what value to use for `n_modes` a-priori.
+    Typically, the value is usually one of ``{16, 32, 64, 128}``. One may train
+    a few GMMs and choose the one that maximises the log probability of the
+    GMM, or choose `n_modes` such that the downstream classifier trained on
+    the resultant Fisher vectors has maximal performance.
+
+    Parameters
+    ----------
+    descriptors : np.ndarray (N, M) or list [(N1, M), (N2, M), ...]
+        List of NumPy arrays, or a single NumPy array, of the descriptors
+        used to estimate the GMM. The reason a list of NumPy arrays is
+        permissible is because often when using a Fisher vector encoding,
+        descriptors/vectors are computed separately for each sample/image in
+        the dataset, such as SIFT vectors for each image. If a list if passed
+        in, then each element must be a NumPy array in which the number of
+        rows may differ (e.g. different number of SIFT vector for each image),
+        but the number of columns for each must be the same (i.e. the
+        dimensionality must be the same).
+    n_modes : int
+        The number of modes/Gaussians to estimate during the GMM estimate.
+    gm_args : dict
+        Keyword arguments that can be passed into the underlying scikit-learn
+        :class:`sklearn.mixture.GaussianMixture` class.
+
+    Returns
+    -------
+    gmm : :class:`sklearn.mixture.GaussianMixture`
+        The estimated GMM object, which contains the necessary parameters
+        needed to compute the Fisher vector.
+
+    References
+    ----------
+    .. [1] https://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html
+
+    Examples
+    --------
+    >>> from skimage.feature import fisher_vector
+    >>> rng = np.random.Generator(np.random.PCG64())
+    >>> sift_for_images = [rng.standard_normal((10, 128)) for _ in range(10)]
+    >>> num_modes = 16
+    >>> # Estimate 16-mode GMM with these synthetic SIFT vectors
+    >>> gmm = learn_gmm(sift_for_images, n_modes=num_modes)
+    """
+
+    try:
+        from sklearn.mixture import GaussianMixture
+    except ImportError:
+        raise ImportError(
+            'scikit-learn is not installed. Please ensure it is installed in '
+            'order to use the Fisher vector functionality.'
+        )
+
+    if not isinstance(descriptors, (list, np.ndarray)):
+        raise DescriptorException(
+            'Please ensure descriptors are either a NumPy array, '
+            'or a list of NumPy arrays.'
+        )
+
+    d_mat_1 = descriptors[0]
+    if isinstance(descriptors, list) and not isinstance(d_mat_1, np.ndarray):
+        raise DescriptorException(
+            'Please ensure descriptors are a list of NumPy arrays.'
+        )
+
+    if isinstance(descriptors, list):
+        expected_shape = descriptors[0].shape
+        ranks = [len(e.shape) == len(expected_shape) for e in descriptors]
+        if not all(ranks):
+            raise DescriptorException(
+                'Please ensure all elements of your descriptor list ' 'are of rank 2.'
+            )
+        dims = [e.shape[1] == descriptors[0].shape[1] for e in descriptors]
+        if not all(dims):
+            raise DescriptorException(
+                'Please ensure all descriptors are of the same dimensionality.'
+            )
+
+    if not isinstance(n_modes, int) or n_modes <= 0:
+        raise FisherVectorException('Please ensure n_modes is a positive integer.')
+
+    if gm_args:
+        has_cov_type = 'covariance_type' in gm_args
+        cov_type_not_diag = gm_args['covariance_type'] != 'diag'
+        if has_cov_type and cov_type_not_diag:
+            raise FisherVectorException('Covariance type must be "diag".')
+
+    if isinstance(descriptors, list):
+        descriptors = np.vstack(descriptors)
+
+    if gm_args:
+        has_cov_type = 'covariance_type' in gm_args
+        if has_cov_type:
+            gmm = GaussianMixture(n_components=n_modes, **gm_args)
+        else:
+            gmm = GaussianMixture(
+                n_components=n_modes, covariance_type='diag', **gm_args
+            )
+    else:
+        gmm = GaussianMixture(n_components=n_modes, covariance_type='diag')
+
+    gmm.fit(descriptors)
+
+    return gmm
+
+
+def fisher_vector(descriptors, gmm, *, improved=False, alpha=0.5):
+    """Compute the Fisher vector given some descriptors/vectors,
+    and an associated estimated GMM.
+
+    Parameters
+    ----------
+    descriptors : np.ndarray, shape=(n_descriptors, descriptor_length)
+        NumPy array of the descriptors for which the Fisher vector
+        representation is to be computed.
+    gmm : :class:`sklearn.mixture.GaussianMixture`
+        An estimated GMM object, which contains the necessary parameters needed
+        to compute the Fisher vector.
+    improved : bool, default=False
+        Flag denoting whether to compute improved Fisher vectors or not.
+        Improved Fisher vectors are L2 and power normalized. Power
+        normalization is simply f(z) = sign(z) pow(abs(z), alpha) for some
+        0 <= alpha <= 1.
+    alpha : float, default=0.5
+        The parameter for the power normalization step. Ignored if
+        improved=False.
+
+    Returns
+    -------
+    fisher_vector : np.ndarray
+        The computation Fisher vector, which is given by a concatenation of the
+        gradients of a GMM with respect to its parameters (mixture weights,
+        means, and covariance matrices). For D-dimensional input descriptors or
+        vectors, and a K-mode GMM, the Fisher vector dimensionality will be
+        2KD + K. Thus, its dimensionality is invariant to the number of
+        descriptors/vectors.
+
+    References
+    ----------
+    .. [1] Perronnin, F. and Dance, C. Fisher kernels on Visual Vocabularies
+           for Image Categorization, IEEE Conference on Computer Vision and
+           Pattern Recognition, 2007
+    .. [2] Perronnin, F. and Sanchez, J. and Mensink T. Improving the Fisher
+           Kernel for Large-Scale Image Classification, ECCV, 2010
+
+    Examples
+    --------
+    >>> from skimage.feature import fisher_vector, learn_gmm
+    >>> sift_for_images = [np.random.random((10, 128)) for _ in range(10)]
+    >>> num_modes = 16
+    >>> # Estimate 16-mode GMM with these synthetic SIFT vectors
+    >>> gmm = learn_gmm(sift_for_images, n_modes=num_modes)
+    >>> test_image_descriptors = np.random.random((25, 128))
+    >>> # Compute the Fisher vector
+    >>> fv = fisher_vector(test_image_descriptors, gmm)
+    """
+    try:
+        from sklearn.mixture import GaussianMixture
+    except ImportError:
+        raise ImportError(
+            'scikit-learn is not installed. Please ensure it is installed in '
+            'order to use the Fisher vector functionality.'
+        )
+
+    if not isinstance(descriptors, np.ndarray):
+        raise DescriptorException('Please ensure descriptors is a NumPy array.')
+
+    if not isinstance(gmm, GaussianMixture):
+        raise FisherVectorException(
+            'Please ensure gmm is a sklearn.mixture.GaussianMixture object.'
+        )
+
+    if improved and not isinstance(alpha, float):
+        raise FisherVectorException(
+            'Please ensure that the alpha parameter is a float.'
+        )
+
+    num_descriptors = len(descriptors)
+
+    mixture_weights = gmm.weights_
+    means = gmm.means_
+    covariances = gmm.covariances_
+
+    posterior_probabilities = gmm.predict_proba(descriptors)
+
+    # Statistics necessary to compute GMM gradients wrt its parameters
+    pp_sum = posterior_probabilities.mean(axis=0, keepdims=True).T
+    pp_x = posterior_probabilities.T.dot(descriptors) / num_descriptors
+    pp_x_2 = posterior_probabilities.T.dot(np.power(descriptors, 2)) / num_descriptors
+
+    # Compute GMM gradients wrt its parameters
+    d_pi = pp_sum.squeeze() - mixture_weights
+
+    d_mu = pp_x - pp_sum * means
+
+    d_sigma_t1 = pp_sum * np.power(means, 2)
+    d_sigma_t2 = pp_sum * covariances
+    d_sigma_t3 = 2 * pp_x * means
+    d_sigma = -pp_x_2 - d_sigma_t1 + d_sigma_t2 + d_sigma_t3
+
+    # Apply analytical diagonal normalization
+    sqrt_mixture_weights = np.sqrt(mixture_weights)
+    d_pi /= sqrt_mixture_weights
+    d_mu /= sqrt_mixture_weights[:, np.newaxis] * np.sqrt(covariances)
+    d_sigma /= np.sqrt(2) * sqrt_mixture_weights[:, np.newaxis] * covariances
+
+    # Concatenate GMM gradients to form Fisher vector representation
+    fisher_vector = np.hstack((d_pi, d_mu.ravel(), d_sigma.ravel()))
+
+    if improved:
+        fisher_vector = np.sign(fisher_vector) * np.power(np.abs(fisher_vector), alpha)
+        fisher_vector = fisher_vector / np.linalg.norm(fisher_vector)
+
+    return fisher_vector

envs/kitoverlay/skimage/feature/_hog.py

@@ -0,0 +1,341 @@
+import numpy as np
+
+from . import _hoghistogram
+from .._shared import utils
+
+
+def _hog_normalize_block(block, method, eps=1e-5):
+    if method == 'L1':
+        out = block / (np.sum(np.abs(block)) + eps)
+    elif method == 'L1-sqrt':
+        out = np.sqrt(block / (np.sum(np.abs(block)) + eps))
+    elif method == 'L2':
+        out = block / np.sqrt(np.sum(block**2) + eps**2)
+    elif method == 'L2-Hys':
+        out = block / np.sqrt(np.sum(block**2) + eps**2)
+        out = np.minimum(out, 0.2)
+        out = out / np.sqrt(np.sum(out**2) + eps**2)
+    else:
+        raise ValueError('Selected block normalization method is invalid.')
+
+    return out
+
+
+def _hog_channel_gradient(channel):
+    """Compute unnormalized gradient image along `row` and `col` axes.
+
+    Parameters
+    ----------
+    channel : (M, N) ndarray
+        Grayscale image or one of image channel.
+
+    Returns
+    -------
+    g_row, g_col : channel gradient along `row` and `col` axes correspondingly.
+    """
+    g_row = np.empty(channel.shape, dtype=channel.dtype)
+    g_row[0, :] = 0
+    g_row[-1, :] = 0
+    g_row[1:-1, :] = channel[2:, :] - channel[:-2, :]
+    g_col = np.empty(channel.shape, dtype=channel.dtype)
+    g_col[:, 0] = 0
+    g_col[:, -1] = 0
+    g_col[:, 1:-1] = channel[:, 2:] - channel[:, :-2]
+
+    return g_row, g_col
+
+
+@utils.channel_as_last_axis(multichannel_output=False)
+def hog(
+    image,
+    orientations=9,
+    pixels_per_cell=(8, 8),
+    cells_per_block=(3, 3),
+    block_norm='L2-Hys',
+    visualize=False,
+    transform_sqrt=False,
+    feature_vector=True,
+    *,
+    channel_axis=None,
+):
+    """Extract Histogram of Oriented Gradients (HOG) for a given image.
+
+    Compute a Histogram of Oriented Gradients (HOG) by
+
+        1. (optional) global image normalization
+        2. computing the gradient image in `row` and `col`
+        3. computing gradient histograms
+        4. normalizing across blocks
+        5. flattening into a feature vector
+
+    Parameters
+    ----------
+    image : (M, N[, C]) ndarray
+        Input image.
+    orientations : int, optional
+        Number of orientation bins.
+    pixels_per_cell : 2-tuple (int, int), optional
+        Size (in pixels) of a cell.
+    cells_per_block : 2-tuple (int, int), optional
+        Number of cells in each block.
+    block_norm : str {'L1', 'L1-sqrt', 'L2', 'L2-Hys'}, optional
+        Block normalization method:
+
+        ``L1``
+           Normalization using L1-norm.
+        ``L1-sqrt``
+           Normalization using L1-norm, followed by square root.
+        ``L2``
+           Normalization using L2-norm.
+        ``L2-Hys``
+           Normalization using L2-norm, followed by limiting the
+           maximum values to 0.2 (`Hys` stands for `hysteresis`) and
+           renormalization using L2-norm. (default)
+           For details, see [3]_, [4]_.
+
+    visualize : bool, optional
+        Also return an image of the HOG.  For each cell and orientation bin,
+        the image contains a line segment that is centered at the cell center,
+        is perpendicular to the midpoint of the range of angles spanned by the
+        orientation bin, and has intensity proportional to the corresponding
+        histogram value.
+    transform_sqrt : bool, optional
+        Apply power law compression to normalize the image before
+        processing. DO NOT use this if the image contains negative
+        values. Also see `notes` section below.
+    feature_vector : bool, optional
+        Return the data as a feature vector by calling .ravel() on the result
+        just before returning.
+    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.
+
+    Returns
+    -------
+    out : (n_blocks_row, n_blocks_col, n_cells_row, n_cells_col, n_orient) ndarray
+        HOG descriptor for the image. If `feature_vector` is True, a 1D
+        (flattened) array is returned.
+    hog_image : (M, N) ndarray, optional
+        A visualisation of the HOG image. Only provided if `visualize` is True.
+
+    Raises
+    ------
+    ValueError
+        If the image is too small given the values of pixels_per_cell and
+        cells_per_block.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Histogram_of_oriented_gradients
+
+    .. [2] Dalal, N and Triggs, B, Histograms of Oriented Gradients for
+           Human Detection, IEEE Computer Society Conference on Computer
+           Vision and Pattern Recognition 2005 San Diego, CA, USA,
+           https://lear.inrialpes.fr/people/triggs/pubs/Dalal-cvpr05.pdf,
+           :DOI:`10.1109/CVPR.2005.177`
+
+    .. [3] Lowe, D.G., Distinctive image features from scale-invatiant
+           keypoints, International Journal of Computer Vision (2004) 60: 91,
+           http://www.cs.ubc.ca/~lowe/papers/ijcv04.pdf,
+           :DOI:`10.1023/B:VISI.0000029664.99615.94`
+
+    .. [4] Dalal, N, Finding People in Images and Videos,
+           Human-Computer Interaction [cs.HC], Institut National Polytechnique
+           de Grenoble - INPG, 2006,
+           https://tel.archives-ouvertes.fr/tel-00390303/file/NavneetDalalThesis.pdf
+
+    Notes
+    -----
+    The presented code implements the HOG extraction method from [2]_ with
+    the following changes: (I) blocks of (3, 3) cells are used ((2, 2) in the
+    paper); (II) no smoothing within cells (Gaussian spatial window with sigma=8pix
+    in the paper); (III) L1 block normalization is used (L2-Hys in the paper).
+
+    Power law compression, also known as Gamma correction, is used to reduce
+    the effects of shadowing and illumination variations. The compression makes
+    the dark regions lighter. When the kwarg `transform_sqrt` is set to
+    ``True``, the function computes the square root of each color channel
+    and then applies the hog algorithm to the image.
+    """
+    image = np.atleast_2d(image)
+    float_dtype = utils._supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+
+    multichannel = channel_axis is not None
+    ndim_spatial = image.ndim - 1 if multichannel else image.ndim
+    if ndim_spatial != 2:
+        raise ValueError(
+            'Only images with two spatial dimensions are '
+            'supported. If using with color/multichannel '
+            'images, specify `channel_axis`.'
+        )
+
+    """
+    The first stage applies an optional global image normalization
+    equalisation that is designed to reduce the influence of illumination
+    effects. In practice we use gamma (power law) compression, either
+    computing the square root or the log of each color channel.
+    Image texture strength is typically proportional to the local surface
+    illumination so this compression helps to reduce the effects of local
+    shadowing and illumination variations.
+    """
+
+    if transform_sqrt:
+        image = np.sqrt(image)
+
+    """
+    The second stage computes first order image gradients. These capture
+    contour, silhouette and some texture information, while providing
+    further resistance to illumination variations. The locally dominant
+    color channel is used, which provides color invariance to a large
+    extent. Variant methods may also include second order image derivatives,
+    which act as primitive bar detectors - a useful feature for capturing,
+    e.g. bar like structures in bicycles and limbs in humans.
+    """
+
+    if multichannel:
+        g_row_by_ch = np.empty_like(image, dtype=float_dtype)
+        g_col_by_ch = np.empty_like(image, dtype=float_dtype)
+        g_magn = np.empty_like(image, dtype=float_dtype)
+
+        for idx_ch in range(image.shape[2]):
+            (
+                g_row_by_ch[:, :, idx_ch],
+                g_col_by_ch[:, :, idx_ch],
+            ) = _hog_channel_gradient(image[:, :, idx_ch])
+            g_magn[:, :, idx_ch] = np.hypot(
+                g_row_by_ch[:, :, idx_ch], g_col_by_ch[:, :, idx_ch]
+            )
+
+        # For each pixel select the channel with the highest gradient magnitude
+        idcs_max = g_magn.argmax(axis=2)
+        rr, cc = np.meshgrid(
+            np.arange(image.shape[0]),
+            np.arange(image.shape[1]),
+            indexing='ij',
+            sparse=True,
+        )
+        g_row = g_row_by_ch[rr, cc, idcs_max]
+        g_col = g_col_by_ch[rr, cc, idcs_max]
+    else:
+        g_row, g_col = _hog_channel_gradient(image)
+
+    """
+    The third stage aims to produce an encoding that is sensitive to
+    local image content while remaining resistant to small changes in
+    pose or appearance. The adopted method pools gradient orientation
+    information locally in the same way as the SIFT [Lowe 2004]
+    feature. The image window is divided into small spatial regions,
+    called "cells". For each cell we accumulate a local 1-D histogram
+    of gradient or edge orientations over all the pixels in the
+    cell. This combined cell-level 1-D histogram forms the basic
+    "orientation histogram" representation. Each orientation histogram
+    divides the gradient angle range into a fixed number of
+    predetermined bins. The gradient magnitudes of the pixels in the
+    cell are used to vote into the orientation histogram.
+    """
+
+    s_row, s_col = image.shape[:2]
+    c_row, c_col = pixels_per_cell
+    b_row, b_col = cells_per_block
+
+    n_cells_row = int(s_row // c_row)  # number of cells along row-axis
+    n_cells_col = int(s_col // c_col)  # number of cells along col-axis
+
+    # compute orientations integral images
+    orientation_histogram = np.zeros(
+        (n_cells_row, n_cells_col, orientations), dtype=float
+    )
+    g_row = g_row.astype(float, copy=False)
+    g_col = g_col.astype(float, copy=False)
+
+    _hoghistogram.hog_histograms(
+        g_col,
+        g_row,
+        c_col,
+        c_row,
+        s_col,
+        s_row,
+        n_cells_col,
+        n_cells_row,
+        orientations,
+        orientation_histogram,
+    )
+
+    # now compute the histogram for each cell
+    hog_image = None
+
+    if visualize:
+        from .. import draw
+
+        radius = min(c_row, c_col) // 2 - 1
+        orientations_arr = np.arange(orientations)
+        # set dr_arr, dc_arr to correspond to midpoints of orientation bins
+        orientation_bin_midpoints = np.pi * (orientations_arr + 0.5) / orientations
+        dr_arr = radius * np.sin(orientation_bin_midpoints)
+        dc_arr = radius * np.cos(orientation_bin_midpoints)
+        hog_image = np.zeros((s_row, s_col), dtype=float_dtype)
+        for r in range(n_cells_row):
+            for c in range(n_cells_col):
+                for o, dr, dc in zip(orientations_arr, dr_arr, dc_arr):
+                    centre = tuple([r * c_row + c_row // 2, c * c_col + c_col // 2])
+                    rr, cc = draw.line(
+                        int(centre[0] - dc),
+                        int(centre[1] + dr),
+                        int(centre[0] + dc),
+                        int(centre[1] - dr),
+                    )
+                    hog_image[rr, cc] += orientation_histogram[r, c, o]
+
+    """
+    The fourth stage computes normalization, which takes local groups of
+    cells and contrast normalizes their overall responses before passing
+    to next stage. Normalization introduces better invariance to illumination,
+    shadowing, and edge contrast. It is performed by accumulating a measure
+    of local histogram "energy" over local groups of cells that we call
+    "blocks". The result is used to normalize each cell in the block.
+    Typically each individual cell is shared between several blocks, but
+    its normalizations are block dependent and thus different. The cell
+    thus appears several times in the final output vector with different
+    normalizations. This may seem redundant but it improves the performance.
+    We refer to the normalized block descriptors as Histogram of Oriented
+    Gradient (HOG) descriptors.
+    """
+
+    n_blocks_row = (n_cells_row - b_row) + 1
+    n_blocks_col = (n_cells_col - b_col) + 1
+    if n_blocks_col <= 0 or n_blocks_row <= 0:
+        min_row = b_row * c_row
+        min_col = b_col * c_col
+        raise ValueError(
+            'The input image is too small given the values of '
+            'pixels_per_cell and cells_per_block. '
+            'It should have at least: '
+            f'{min_row} rows and {min_col} cols.'
+        )
+    normalized_blocks = np.zeros(
+        (n_blocks_row, n_blocks_col, b_row, b_col, orientations), dtype=float_dtype
+    )
+
+    for r in range(n_blocks_row):
+        for c in range(n_blocks_col):
+            block = orientation_histogram[r : r + b_row, c : c + b_col, :]
+            normalized_blocks[r, c, :] = _hog_normalize_block(block, method=block_norm)
+
+    """
+    The final step collects the HOG descriptors from all blocks of a dense
+    overlapping grid of blocks covering the detection window into a combined
+    feature vector for use in the window classifier.
+    """
+
+    if feature_vector:
+        normalized_blocks = normalized_blocks.ravel()
+
+    if visualize:
+        return normalized_blocks, hog_image
+    else:
+        return normalized_blocks

envs/kitoverlay/skimage/feature/_orb_descriptor_positions.py

@@ -0,0 +1,10 @@
+import os
+import numpy as np
+
+# Putting this in cython was giving strange bugs for different versions
+# of cython which seemed to indicate troubles with the __file__ variable
+# not being defined. Keeping it in pure python makes it more reliable
+this_dir = os.path.dirname(__file__)
+POS = np.loadtxt(os.path.join(this_dir, "orb_descriptor_positions.txt"), dtype=np.int8)
+POS0 = np.ascontiguousarray(POS[:, :2])
+POS1 = np.ascontiguousarray(POS[:, 2:])

envs/kitoverlay/skimage/feature/blob.py

@@ -0,0 +1,723 @@
+import math
+
+import numpy as np
+import scipy.ndimage as ndi
+from scipy import spatial
+
+from .._shared.filters import gaussian
+from .._shared.utils import _supported_float_type, check_nD
+from ..transform import integral_image
+from ..util import img_as_float
+from ._hessian_det_appx import _hessian_matrix_det
+from .peak import peak_local_max
+
+# This basic blob detection algorithm is based on:
+# http://www.cs.utah.edu/~jfishbau/advimproc/project1/ (04.04.2013)
+# Theory behind: https://en.wikipedia.org/wiki/Blob_detection (04.04.2013)
+
+
+def _compute_disk_overlap(d, r1, r2):
+    """
+    Compute fraction of surface overlap between two disks of radii
+    ``r1`` and ``r2``, with centers separated by a distance ``d``.
+
+    Parameters
+    ----------
+    d : float
+        Distance between centers.
+    r1 : float
+        Radius of the first disk.
+    r2 : float
+        Radius of the second disk.
+
+    Returns
+    -------
+    fraction: float
+        Fraction of area of the overlap between the two disks.
+    """
+
+    ratio1 = (d**2 + r1**2 - r2**2) / (2 * d * r1)
+    ratio1 = np.clip(ratio1, -1, 1)
+    acos1 = math.acos(ratio1)
+
+    ratio2 = (d**2 + r2**2 - r1**2) / (2 * d * r2)
+    ratio2 = np.clip(ratio2, -1, 1)
+    acos2 = math.acos(ratio2)
+
+    a = -d + r2 + r1
+    b = d - r2 + r1
+    c = d + r2 - r1
+    d = d + r2 + r1
+    area = r1**2 * acos1 + r2**2 * acos2 - 0.5 * math.sqrt(abs(a * b * c * d))
+    return area / (math.pi * (min(r1, r2) ** 2))
+
+
+def _compute_sphere_overlap(d, r1, r2):
+    """
+    Compute volume overlap fraction between two spheres of radii
+    ``r1`` and ``r2``, with centers separated by a distance ``d``.
+
+    Parameters
+    ----------
+    d : float
+        Distance between centers.
+    r1 : float
+        Radius of the first sphere.
+    r2 : float
+        Radius of the second sphere.
+
+    Returns
+    -------
+    fraction: float
+        Fraction of volume of the overlap between the two spheres.
+
+    Notes
+    -----
+    See for example http://mathworld.wolfram.com/Sphere-SphereIntersection.html
+    for more details.
+    """
+    vol = (
+        math.pi
+        / (12 * d)
+        * (r1 + r2 - d) ** 2
+        * (d**2 + 2 * d * (r1 + r2) - 3 * (r1**2 + r2**2) + 6 * r1 * r2)
+    )
+    return vol / (4.0 / 3 * math.pi * min(r1, r2) ** 3)
+
+
+def _blob_overlap(blob1, blob2, *, sigma_dim=1):
+    """Finds the overlapping area fraction between two blobs.
+
+    Returns a float representing fraction of overlapped area. Note that 0.0
+    is *always* returned for dimension greater than 3.
+
+    Parameters
+    ----------
+    blob1 : sequence of arrays
+        A sequence of ``(row, col, sigma)`` or ``(pln, row, col, sigma)``,
+        where ``row, col`` (or ``(pln, row, col)``) are coordinates
+        of blob and ``sigma`` is the standard deviation of the Gaussian kernel
+        which detected the blob.
+    blob2 : sequence of arrays
+        A sequence of ``(row, col, sigma)`` or ``(pln, row, col, sigma)``,
+        where ``row, col`` (or ``(pln, row, col)``) are coordinates
+        of blob and ``sigma`` is the standard deviation of the Gaussian kernel
+        which detected the blob.
+    sigma_dim : int, optional
+        The dimensionality of the sigma value. Can be 1 or the same as the
+        dimensionality of the blob space (2 or 3).
+
+    Returns
+    -------
+    f : float
+        Fraction of overlapped area (or volume in 3D).
+    """
+    ndim = len(blob1) - sigma_dim
+    if ndim > 3:
+        return 0.0
+    root_ndim = math.sqrt(ndim)
+
+    # we divide coordinates by sigma * sqrt(ndim) to rescale space to isotropy,
+    # giving spheres of radius = 1 or < 1.
+    if blob1[-1] == blob2[-1] == 0:
+        return 0.0
+    elif blob1[-1] > blob2[-1]:
+        max_sigma = blob1[-sigma_dim:]
+        r1 = 1
+        r2 = blob2[-1] / blob1[-1]
+    else:
+        max_sigma = blob2[-sigma_dim:]
+        r2 = 1
+        r1 = blob1[-1] / blob2[-1]
+    pos1 = blob1[:ndim] / (max_sigma * root_ndim)
+    pos2 = blob2[:ndim] / (max_sigma * root_ndim)
+
+    d = np.sqrt(np.sum((pos2 - pos1) ** 2))
+    if d > r1 + r2:  # centers farther than sum of radii, so no overlap
+        return 0.0
+
+    # one blob is inside the other
+    if d <= abs(r1 - r2):
+        return 1.0
+
+    if ndim == 2:
+        return _compute_disk_overlap(d, r1, r2)
+
+    else:  # ndim=3 http://mathworld.wolfram.com/Sphere-SphereIntersection.html
+        return _compute_sphere_overlap(d, r1, r2)
+
+
+def _prune_blobs(blobs_array, overlap, *, sigma_dim=1):
+    """Eliminated blobs with area overlap.
+
+    Parameters
+    ----------
+    blobs_array : ndarray
+        A 2d array with each row representing 3 (or 4) values,
+        ``(row, col, sigma)`` or ``(pln, row, col, sigma)`` in 3D,
+        where ``(row, col)`` (``(pln, row, col)``) are coordinates of the blob
+        and ``sigma`` is the standard deviation of the Gaussian kernel which
+        detected the blob.
+        This array must not have a dimension of size 0.
+    overlap : float
+        A value between 0 and 1. If the fraction of area overlapping for 2
+        blobs is greater than `overlap` the smaller blob is eliminated.
+    sigma_dim : int, optional
+        The number of columns in ``blobs_array`` corresponding to sigmas rather
+        than positions.
+
+    Returns
+    -------
+    A : ndarray
+        `array` with overlapping blobs removed.
+    """
+    sigma = blobs_array[:, -sigma_dim:].max()
+    distance = 2 * sigma * math.sqrt(blobs_array.shape[1] - sigma_dim)
+    tree = spatial.cKDTree(blobs_array[:, :-sigma_dim])
+    pairs = np.array(list(tree.query_pairs(distance)))
+    if len(pairs) == 0:
+        return blobs_array
+    else:
+        for i, j in pairs:
+            blob1, blob2 = blobs_array[i], blobs_array[j]
+            if _blob_overlap(blob1, blob2, sigma_dim=sigma_dim) > overlap:
+                # note: this test works even in the anisotropic case because
+                # all sigmas increase together.
+                if blob1[-1] > blob2[-1]:
+                    blob2[-1] = 0
+                else:
+                    blob1[-1] = 0
+
+    return np.stack([b for b in blobs_array if b[-1] > 0])
+
+
+def _format_exclude_border(img_ndim, exclude_border):
+    """Format an ``exclude_border`` argument as a tuple of ints for calling
+    ``peak_local_max``.
+    """
+    if isinstance(exclude_border, tuple):
+        if len(exclude_border) != img_ndim:
+            raise ValueError(
+                "`exclude_border` should have the same length as the "
+                "dimensionality of the image."
+            )
+        for exclude in exclude_border:
+            if not isinstance(exclude, int):
+                raise ValueError(
+                    "exclude border, when expressed as a tuple, must only "
+                    "contain ints."
+                )
+        return exclude_border + (0,)
+    elif isinstance(exclude_border, int):
+        return (exclude_border,) * img_ndim + (0,)
+    elif exclude_border is True:
+        raise ValueError("exclude_border cannot be True")
+    elif exclude_border is False:
+        return (0,) * (img_ndim + 1)
+    else:
+        raise ValueError(f'Unsupported value ({exclude_border}) for exclude_border')
+
+
+def blob_dog(
+    image,
+    min_sigma=1,
+    max_sigma=50,
+    sigma_ratio=1.6,
+    threshold=0.5,
+    overlap=0.5,
+    *,
+    threshold_rel=None,
+    exclude_border=False,
+):
+    r"""Finds blobs in the given grayscale image.
+
+    Blobs are found using the Difference of Gaussian (DoG) method [1]_, [2]_.
+    For each blob found, the method returns its coordinates and the standard
+    deviation of the Gaussian kernel that detected the blob.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input grayscale image, blobs are assumed to be light on dark
+        background (white on black).
+    min_sigma : scalar or sequence of scalars, optional
+        Minimum standard deviation for Gaussian kernel. Keep this value low to
+        detect smaller blobs. The standard deviation of the Gaussian kernel
+        is given either as a sequence for each axis, or as a single number, in
+        which case it is equal for all axes.
+    max_sigma : scalar or sequence of scalars, optional
+        The maximum standard deviation for Gaussian kernel. Keep this high to
+        detect larger blobs. The standard deviation of the Gaussian kernel
+        is given either as a sequence for each axis, or as a single number, in
+        which case it is equal for all axes.
+    sigma_ratio : float, optional
+        The ratio between the standard deviation of Gaussian Kernels used for
+        computing the Difference of Gaussians
+    threshold : float or None, optional
+        The absolute lower bound for scale space maxima. Local maxima smaller
+        than `threshold` are ignored. Reduce this to detect blobs with lower
+        intensities. If `threshold_rel` is also specified, whichever threshold
+        is larger will be used. If None, `threshold_rel` is used instead.
+    overlap : float, optional
+        A value between 0 and 1. If the area of two blobs overlaps by a
+        fraction greater than `threshold`, the smaller blob is eliminated.
+    threshold_rel : float or None, optional
+        Minimum intensity of peaks, calculated as
+        ``max(dog_space) * threshold_rel``, where ``dog_space`` refers to the
+        stack of Difference-of-Gaussian (DoG) images computed internally. This
+        should have a value between 0 and 1. If None, `threshold` is used
+        instead.
+    exclude_border : tuple of ints, int, or False, optional
+        If tuple of ints, the length of the tuple must match the input array's
+        dimensionality.  Each element of the tuple will exclude peaks from
+        within `exclude_border`-pixels of the border of the image along that
+        dimension.
+        If nonzero int, `exclude_border` excludes peaks from within
+        `exclude_border`-pixels of the border of the image.
+        If zero or False, peaks are identified regardless of their
+        distance from the border.
+
+    Returns
+    -------
+    A : (n, image.ndim + sigma) ndarray
+        A 2d array with each row representing 2 coordinate values for a 2D
+        image, or 3 coordinate values for a 3D image, plus the sigma(s) used.
+        When a single sigma is passed, outputs are:
+        ``(r, c, sigma)`` or ``(p, r, c, sigma)`` where ``(r, c)`` or
+        ``(p, r, c)`` are coordinates of the blob and ``sigma`` is the standard
+        deviation of the Gaussian kernel which detected the blob. When an
+        anisotropic gaussian is used (sigmas per dimension), the detected sigma
+        is returned for each dimension.
+
+    See also
+    --------
+    skimage.filters.difference_of_gaussians
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Blob_detection#The_difference_of_Gaussians_approach
+    .. [2] Lowe, D. G. "Distinctive Image Features from Scale-Invariant
+        Keypoints." International Journal of Computer Vision 60, 91–110 (2004).
+        https://www.cs.ubc.ca/~lowe/papers/ijcv04.pdf
+        :DOI:`10.1023/B:VISI.0000029664.99615.94`
+
+    Examples
+    --------
+    >>> from skimage import data, feature
+    >>> coins = data.coins()
+    >>> feature.blob_dog(coins, threshold=.05, min_sigma=10, max_sigma=40)
+    array([[128., 155.,  10.],
+           [198., 155.,  10.],
+           [124., 338.,  10.],
+           [127., 102.,  10.],
+           [193., 281.,  10.],
+           [126., 208.,  10.],
+           [267., 115.,  10.],
+           [197., 102.,  10.],
+           [198., 215.,  10.],
+           [123., 279.,  10.],
+           [126.,  46.,  10.],
+           [259., 247.,  10.],
+           [196.,  43.,  10.],
+           [ 54., 276.,  10.],
+           [267., 358.,  10.],
+           [ 58., 100.,  10.],
+           [259., 305.,  10.],
+           [185., 347.,  16.],
+           [261., 174.,  16.],
+           [ 46., 336.,  16.],
+           [ 54., 217.,  10.],
+           [ 55., 157.,  10.],
+           [ 57.,  41.,  10.],
+           [260.,  47.,  16.]])
+
+    Notes
+    -----
+    The radius of each blob is approximately :math:`\sqrt{2}\sigma` for
+    a 2-D image and :math:`\sqrt{3}\sigma` for a 3-D image.
+    """
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+
+    # if both min and max sigma are scalar, function returns only one sigma
+    scalar_sigma = np.isscalar(max_sigma) and np.isscalar(min_sigma)
+
+    # Gaussian filter requires that sequence-type sigmas have same
+    # dimensionality as image. This broadcasts scalar kernels
+    if np.isscalar(max_sigma):
+        max_sigma = np.full(image.ndim, max_sigma, dtype=float_dtype)
+    if np.isscalar(min_sigma):
+        min_sigma = np.full(image.ndim, min_sigma, dtype=float_dtype)
+
+    # Convert sequence types to array
+    min_sigma = np.asarray(min_sigma, dtype=float_dtype)
+    max_sigma = np.asarray(max_sigma, dtype=float_dtype)
+
+    if sigma_ratio <= 1.0:
+        raise ValueError('sigma_ratio must be > 1.0')
+
+    # k such that min_sigma*(sigma_ratio**k) > max_sigma
+    k = int(np.mean(np.log(max_sigma / min_sigma) / np.log(sigma_ratio) + 1))
+
+    # a geometric progression of standard deviations for gaussian kernels
+    sigma_list = np.array([min_sigma * (sigma_ratio**i) for i in range(k + 1)])
+
+    # computing difference between two successive Gaussian blurred images
+    # to obtain an approximation of the scale invariant Laplacian of the
+    # Gaussian operator
+    dog_image_cube = np.empty(image.shape + (k,), dtype=float_dtype)
+    gaussian_previous = gaussian(image, sigma=sigma_list[0], mode='reflect')
+    for i, s in enumerate(sigma_list[1:]):
+        gaussian_current = gaussian(image, sigma=s, mode='reflect')
+        dog_image_cube[..., i] = gaussian_previous - gaussian_current
+        gaussian_previous = gaussian_current
+
+    # normalization factor for consistency in DoG magnitude
+    sf = 1 / (sigma_ratio - 1)
+    dog_image_cube *= sf
+
+    exclude_border = _format_exclude_border(image.ndim, exclude_border)
+    local_maxima = peak_local_max(
+        dog_image_cube,
+        threshold_abs=threshold,
+        threshold_rel=threshold_rel,
+        exclude_border=exclude_border,
+        footprint=np.ones((3,) * (image.ndim + 1)),
+    )
+
+    # Catch no peaks
+    if local_maxima.size == 0:
+        return np.empty((0, image.ndim + (1 if scalar_sigma else image.ndim)))
+
+    # Convert local_maxima to float64
+    lm = local_maxima.astype(float_dtype)
+
+    # translate final column of lm, which contains the index of the
+    # sigma that produced the maximum intensity value, into the sigma
+    sigmas_of_peaks = sigma_list[local_maxima[:, -1]]
+
+    if scalar_sigma:
+        # select one sigma column, keeping dimension
+        sigmas_of_peaks = sigmas_of_peaks[:, 0:1]
+
+    # Remove sigma index and replace with sigmas
+    lm = np.hstack([lm[:, :-1], sigmas_of_peaks])
+
+    sigma_dim = sigmas_of_peaks.shape[1]
+
+    return _prune_blobs(lm, overlap, sigma_dim=sigma_dim)
+
+
+def blob_log(
+    image,
+    min_sigma=1,
+    max_sigma=50,
+    num_sigma=10,
+    threshold=0.2,
+    overlap=0.5,
+    log_scale=False,
+    *,
+    threshold_rel=None,
+    exclude_border=False,
+):
+    r"""Finds blobs in the given grayscale image.
+
+    Blobs are found using the Laplacian of Gaussian (LoG) method [1]_.
+    For each blob found, the method returns its coordinates and the standard
+    deviation of the Gaussian kernel that detected the blob.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input grayscale image, blobs are assumed to be light on dark
+        background (white on black).
+    min_sigma : scalar or sequence of scalars, optional
+        Minimum standard deviation for Gaussian kernel. Keep this value low to
+        detect smaller blobs. The standard deviation of the Gaussian kernel
+        is given either as a sequence for each axis, or as a single number, in
+        which case it is equal for all axes.
+    max_sigma : scalar or sequence of scalars, optional
+        The maximum standard deviation for Gaussian kernel. Keep this high to
+        detect larger blobs. The standard deviation of the Gaussian kernel
+        is given either as a sequence for each axis, or as a single number, in
+        which case it is equal for all axes.
+    num_sigma : int, optional
+        The number of evenly spaced values for standard deviation of the
+        Gaussian kernel to consider on the closed interval
+        ``[min_sigma, max_sigma]``.
+    threshold : float or None, optional
+        The absolute lower bound for scale space maxima. Local maxima smaller
+        than `threshold` are ignored. Reduce this to detect blobs with lower
+        intensities. If `threshold_rel` is also specified, whichever threshold
+        is larger will be used. If None, `threshold_rel` is used instead.
+    overlap : float, optional
+        A value between 0 and 1. If the area of two blobs overlaps by a
+        fraction greater than `threshold`, the smaller blob is eliminated.
+    log_scale : bool, optional
+        If set intermediate values of standard deviations are interpolated
+        using a logarithmic scale to the base `10`. If not, linear
+        interpolation is used.
+    threshold_rel : float or None, optional
+        Minimum intensity of peaks, calculated as
+        ``max(log_space) * threshold_rel``, where ``log_space`` refers to the
+        stack of Laplacian-of-Gaussian (LoG) images computed internally. This
+        should have a value between 0 and 1. If None, `threshold` is used
+        instead.
+    exclude_border : tuple of ints, int, or False, optional
+        If tuple of ints, the length of the tuple must match the input array's
+        dimensionality.  Each element of the tuple will exclude peaks from
+        within `exclude_border`-pixels of the border of the image along that
+        dimension.
+        If nonzero int, `exclude_border` excludes peaks from within
+        `exclude_border`-pixels of the border of the image.
+        If zero or False, peaks are identified regardless of their
+        distance from the border.
+
+    Returns
+    -------
+    A : (n, image.ndim + sigma) ndarray
+        A 2d array with each row representing 2 coordinate values for a 2D
+        image, or 3 coordinate values for a 3D image, plus the sigma(s) used.
+        When a single sigma is passed, outputs are:
+        ``(r, c, sigma)`` or ``(p, r, c, sigma)`` where ``(r, c)`` or
+        ``(p, r, c)`` are coordinates of the blob and ``sigma`` is the standard
+        deviation of the Gaussian kernel which detected the blob. When an
+        anisotropic gaussian is used (sigmas per dimension), the detected sigma
+        is returned for each dimension.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Blob_detection#The_Laplacian_of_Gaussian
+
+    Examples
+    --------
+    >>> from skimage import data, feature, exposure
+    >>> img = data.coins()
+    >>> img = exposure.equalize_hist(img)  # improves detection
+    >>> feature.blob_log(img, threshold = .3)
+    array([[124.        , 336.        ,  11.88888889],
+           [198.        , 155.        ,  11.88888889],
+           [194.        , 213.        ,  17.33333333],
+           [121.        , 272.        ,  17.33333333],
+           [263.        , 244.        ,  17.33333333],
+           [194.        , 276.        ,  17.33333333],
+           [266.        , 115.        ,  11.88888889],
+           [128.        , 154.        ,  11.88888889],
+           [260.        , 174.        ,  17.33333333],
+           [198.        , 103.        ,  11.88888889],
+           [126.        , 208.        ,  11.88888889],
+           [127.        , 102.        ,  11.88888889],
+           [263.        , 302.        ,  17.33333333],
+           [197.        ,  44.        ,  11.88888889],
+           [185.        , 344.        ,  17.33333333],
+           [126.        ,  46.        ,  11.88888889],
+           [113.        , 323.        ,   1.        ]])
+
+    Notes
+    -----
+    The radius of each blob is approximately :math:`\sqrt{2}\sigma` for
+    a 2-D image and :math:`\sqrt{3}\sigma` for a 3-D image.
+    """
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+
+    # if both min and max sigma are scalar, function returns only one sigma
+    scalar_sigma = True if np.isscalar(max_sigma) and np.isscalar(min_sigma) else False
+
+    # Gaussian filter requires that sequence-type sigmas have same
+    # dimensionality as image. This broadcasts scalar kernels
+    if np.isscalar(max_sigma):
+        max_sigma = np.full(image.ndim, max_sigma, dtype=float_dtype)
+    if np.isscalar(min_sigma):
+        min_sigma = np.full(image.ndim, min_sigma, dtype=float_dtype)
+
+    # Convert sequence types to array
+    min_sigma = np.asarray(min_sigma, dtype=float_dtype)
+    max_sigma = np.asarray(max_sigma, dtype=float_dtype)
+
+    if log_scale:
+        start = np.log10(min_sigma)
+        stop = np.log10(max_sigma)
+        sigma_list = np.logspace(start, stop, num_sigma)
+    else:
+        sigma_list = np.linspace(min_sigma, max_sigma, num_sigma)
+
+    # computing gaussian laplace
+    image_cube = np.empty(image.shape + (len(sigma_list),), dtype=float_dtype)
+    for i, s in enumerate(sigma_list):
+        # average s**2 provides scale invariance
+        image_cube[..., i] = -ndi.gaussian_laplace(image, s) * np.mean(s) ** 2
+
+    exclude_border = _format_exclude_border(image.ndim, exclude_border)
+    local_maxima = peak_local_max(
+        image_cube,
+        threshold_abs=threshold,
+        threshold_rel=threshold_rel,
+        exclude_border=exclude_border,
+        footprint=np.ones((3,) * (image.ndim + 1)),
+    )
+
+    # Catch no peaks
+    if local_maxima.size == 0:
+        return np.empty((0, image.ndim + (1 if scalar_sigma else image.ndim)))
+
+    # Convert local_maxima to float64
+    lm = local_maxima.astype(float_dtype)
+
+    # translate final column of lm, which contains the index of the
+    # sigma that produced the maximum intensity value, into the sigma
+    sigmas_of_peaks = sigma_list[local_maxima[:, -1]]
+
+    if scalar_sigma:
+        # select one sigma column, keeping dimension
+        sigmas_of_peaks = sigmas_of_peaks[:, 0:1]
+
+    # Remove sigma index and replace with sigmas
+    lm = np.hstack([lm[:, :-1], sigmas_of_peaks])
+
+    sigma_dim = sigmas_of_peaks.shape[1]
+
+    return _prune_blobs(lm, overlap, sigma_dim=sigma_dim)
+
+
+def blob_doh(
+    image,
+    min_sigma=1,
+    max_sigma=30,
+    num_sigma=10,
+    threshold=0.01,
+    overlap=0.5,
+    log_scale=False,
+    *,
+    threshold_rel=None,
+):
+    """Finds blobs in the given grayscale image.
+
+    Blobs are found using the Determinant of Hessian method [1]_. For each blob
+    found, the method returns its coordinates and the standard deviation
+    of the Gaussian Kernel used for the Hessian matrix whose determinant
+    detected the blob. Determinant of Hessians is approximated using [2]_.
+
+    Parameters
+    ----------
+    image : 2D ndarray
+        Input grayscale image. Blobs can either be light on dark or vice versa.
+    min_sigma : float, optional
+        The minimum standard deviation for Gaussian Kernel used to compute
+        Hessian matrix. Keep this value low to detect smaller blobs.
+        The standard deviation of the Gaussian kernel is given either as a
+        sequence for each axis, or as a single number, in which case it is
+        equal for all axes.
+    max_sigma : float, optional
+        The maximum standard deviation for Gaussian Kernel used to compute
+        Hessian matrix. Keep this value high to detect larger blobs.
+        The standard deviation of the Gaussian kernel is given either as a
+        sequence for each axis, or as a single number, in which case it is
+        equal for all axes.
+    num_sigma : int, optional
+        The number of evenly spaced values for standard deviation of the
+        Gaussian kernel to consider on the closed interval
+        ``[min_sigma, max_sigma]``.
+    threshold : float or None, optional
+        The absolute lower bound for scale space maxima. Local maxima smaller
+        than `threshold` are ignored. Reduce this to detect blobs with lower
+        intensities. If `threshold_rel` is also specified, whichever threshold
+        is larger will be used. If None, `threshold_rel` is used instead.
+    overlap : float, optional
+        A value between 0 and 1. If the area of two blobs overlaps by a
+        fraction greater than `threshold`, the smaller blob is eliminated.
+    log_scale : bool, optional
+        If set intermediate values of standard deviations are interpolated
+        using a logarithmic scale to the base `10`. If not, linear
+        interpolation is used.
+    threshold_rel : float or None, optional
+        Minimum intensity of peaks, calculated as
+        ``max(doh_space) * threshold_rel``, where ``doh_space`` refers to the
+        stack of Determinant-of-Hessian (DoH) images computed internally. This
+        should have a value between 0 and 1. If None, `threshold` is used
+        instead.
+
+    Returns
+    -------
+    A : (n, 3) ndarray
+        A 2d array with each row representing 3 values, ``(y,x,sigma)``
+        where ``(y,x)`` are coordinates of the blob and ``sigma`` is the
+        standard deviation of the Gaussian kernel of the Hessian Matrix whose
+        determinant detected the blob.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Blob_detection#The_determinant_of_the_Hessian
+    .. [2] Herbert Bay, Andreas Ess, Tinne Tuytelaars, Luc Van Gool,
+           "SURF: Speeded Up Robust Features"
+           ftp://ftp.vision.ee.ethz.ch/publications/articles/eth_biwi_00517.pdf
+
+    Examples
+    --------
+    >>> from skimage import data, feature
+    >>> img = data.coins()
+    >>> feature.blob_doh(img)
+    array([[197.        , 153.        ,  20.33333333],
+           [124.        , 336.        ,  20.33333333],
+           [126.        , 153.        ,  20.33333333],
+           [195.        , 100.        ,  23.55555556],
+           [192.        , 212.        ,  23.55555556],
+           [121.        , 271.        ,  30.        ],
+           [126.        , 101.        ,  20.33333333],
+           [193.        , 275.        ,  23.55555556],
+           [123.        , 205.        ,  20.33333333],
+           [270.        , 363.        ,  30.        ],
+           [265.        , 113.        ,  23.55555556],
+           [262.        , 243.        ,  23.55555556],
+           [185.        , 348.        ,  30.        ],
+           [156.        , 302.        ,  30.        ],
+           [123.        ,  44.        ,  23.55555556],
+           [260.        , 173.        ,  30.        ],
+           [197.        ,  44.        ,  20.33333333]])
+
+    Notes
+    -----
+    The radius of each blob is approximately `sigma`.
+    Computation of Determinant of Hessians is independent of the standard
+    deviation. Therefore detecting larger blobs won't take more time. In
+    methods line :py:meth:`blob_dog` and :py:meth:`blob_log` the computation
+    of Gaussians for larger `sigma` takes more time. The downside is that
+    this method can't be used for detecting blobs of radius less than `3px`
+    due to the box filters used in the approximation of Hessian Determinant.
+    """
+    check_nD(image, 2)
+
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+
+    image = integral_image(image)
+
+    if log_scale:
+        start, stop = math.log(min_sigma, 10), math.log(max_sigma, 10)
+        sigma_list = np.logspace(start, stop, num_sigma)
+    else:
+        sigma_list = np.linspace(min_sigma, max_sigma, num_sigma)
+
+    image_cube = np.empty(shape=image.shape + (len(sigma_list),), dtype=float_dtype)
+    for j, s in enumerate(sigma_list):
+        image_cube[..., j] = _hessian_matrix_det(image, s)
+
+    local_maxima = peak_local_max(
+        image_cube,
+        threshold_abs=threshold,
+        threshold_rel=threshold_rel,
+        exclude_border=False,
+        footprint=np.ones((3,) * image_cube.ndim),
+    )
+
+    # Catch no peaks
+    if local_maxima.size == 0:
+        return np.empty((0, 3))
+    # Convert local_maxima to float64
+    lm = local_maxima.astype(np.float64)
+    # Convert the last index to its corresponding scale value
+    lm[:, -1] = sigma_list[local_maxima[:, -1]]
+    return _prune_blobs(lm, overlap)

envs/kitoverlay/skimage/feature/brief.py

@@ -0,0 +1,216 @@
+import copy
+
+import numpy as np
+from packaging.version import Version
+
+from .._shared.filters import gaussian
+from .._shared.utils import check_nD
+from .brief_cy import _brief_loop
+from .util import (
+    DescriptorExtractor,
+    _mask_border_keypoints,
+    _prepare_grayscale_input_2D,
+)
+
+
+np2 = Version(np.__version__) >= Version('2')
+
+
+class BRIEF(DescriptorExtractor):
+    """BRIEF binary descriptor extractor.
+
+    BRIEF (Binary Robust Independent Elementary Features) is an efficient
+    feature point descriptor. It is highly discriminative even when using
+    relatively few bits and is computed using simple intensity difference
+    tests.
+
+    For each keypoint, intensity comparisons are carried out for a specifically
+    distributed number N of pixel-pairs resulting in a binary descriptor of
+    length N. For binary descriptors the Hamming distance can be used for
+    feature matching, which leads to lower computational cost in comparison to
+    the L2 norm.
+
+    Parameters
+    ----------
+    descriptor_size : int, optional
+        Size of BRIEF descriptor for each keypoint. Sizes 128, 256 and 512
+        recommended by the authors. Default is 256.
+    patch_size : int, optional
+        Length of the two dimensional square patch sampling region around
+        the keypoints. Default is 49.
+    mode : {'normal', 'uniform'}, optional
+        Probability distribution for sampling location of decision pixel-pairs
+        around keypoints.
+    rng : {`numpy.random.Generator`, int}, optional
+        Pseudo-random number generator (RNG).
+        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 PRNG is used for the random sampling of the decision
+        pixel-pairs. From a square window with length `patch_size`,
+        pixel pairs are sampled using the `mode` parameter to build
+        the descriptors using intensity comparison.
+
+        For matching across images, the same `rng` should be used to construct
+        descriptors. To facilitate this:
+
+        (a) `rng` defaults to 1
+        (b) Subsequent calls of the ``extract`` method will use the same rng/seed.
+    sigma : float, optional
+        Standard deviation of the Gaussian low-pass filter applied to the image
+        to alleviate noise sensitivity, which is strongly recommended to obtain
+        discriminative and good descriptors.
+
+    Attributes
+    ----------
+    descriptors : (Q, `descriptor_size`) array of dtype bool
+        2D ndarray of binary descriptors of size `descriptor_size` for Q
+        keypoints after filtering out border keypoints with value at an
+        index ``(i, j)`` either being ``True`` or ``False`` representing
+        the outcome of the intensity comparison for i-th keypoint on j-th
+        decision pixel-pair. It is ``Q == np.sum(mask)``.
+    mask : (N,) array of dtype bool
+        Mask indicating whether a keypoint has been filtered out
+        (``False``) or is described in the `descriptors` array (``True``).
+
+    Examples
+    --------
+    >>> from skimage.feature import (corner_harris, corner_peaks, BRIEF,
+    ...                              match_descriptors)
+    >>> import numpy as np
+    >>> square1 = np.zeros((8, 8), dtype=np.int32)
+    >>> square1[2:6, 2:6] = 1
+    >>> square1
+    array([[0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32)
+    >>> square2 = np.zeros((9, 9), dtype=np.int32)
+    >>> square2[2:7, 2:7] = 1
+    >>> square2
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32)
+    >>> keypoints1 = corner_peaks(corner_harris(square1), min_distance=1)
+    >>> keypoints2 = corner_peaks(corner_harris(square2), min_distance=1)
+    >>> extractor = BRIEF(patch_size=5)
+    >>> extractor.extract(square1, keypoints1)
+    >>> descriptors1 = extractor.descriptors
+    >>> extractor.extract(square2, keypoints2)
+    >>> descriptors2 = extractor.descriptors
+    >>> matches = match_descriptors(descriptors1, descriptors2)
+    >>> matches
+    array([[0, 0],
+           [1, 1],
+           [2, 2],
+           [3, 3]])
+    >>> keypoints1[matches[:, 0]]
+    array([[2, 2],
+           [2, 5],
+           [5, 2],
+           [5, 5]])
+    >>> keypoints2[matches[:, 1]]
+    array([[2, 2],
+           [2, 6],
+           [6, 2],
+           [6, 6]])
+
+    """
+
+    def __init__(
+        self, descriptor_size=256, patch_size=49, mode='normal', sigma=1, rng=1
+    ):
+        mode = mode.lower()
+        if mode not in ('normal', 'uniform'):
+            raise ValueError("`mode` must be 'normal' or 'uniform'.")
+
+        self.descriptor_size = descriptor_size
+        self.patch_size = patch_size
+        self.mode = mode
+        self.sigma = sigma
+
+        if isinstance(rng, np.random.Generator):
+            # Spawn an independent RNG from parent RNG provided by the user.
+            # This is necessary so that we can safely deepcopy the RNG.
+            # See https://github.com/scikit-learn/scikit-learn/issues/16988#issuecomment-1518037853
+            bg = rng._bit_generator
+            ss = bg._seed_seq
+            (child_ss,) = ss.spawn(1)
+            self.rng = np.random.Generator(type(bg)(child_ss))
+        elif rng is None:
+            self.rng = np.random.default_rng(np.random.SeedSequence())
+        else:
+            self.rng = np.random.default_rng(rng)
+
+        self.descriptors = None
+        self.mask = None
+
+    def extract(self, image, keypoints):
+        """Extract BRIEF binary descriptors for given keypoints in image.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+        keypoints : (N, 2) array
+            Keypoint coordinates as ``(row, col)``.
+
+        """
+        check_nD(image, 2)
+
+        # Copy RNG so we can repeatedly call extract with the same random values
+        rng = copy.deepcopy(self.rng)
+
+        image = _prepare_grayscale_input_2D(image)
+
+        # Gaussian low-pass filtering to alleviate noise sensitivity
+        image = np.ascontiguousarray(gaussian(image, sigma=self.sigma, mode='reflect'))
+
+        # Sampling pairs of decision pixels in patch_size x patch_size window
+        desc_size = self.descriptor_size
+        patch_size = self.patch_size
+        if self.mode == 'normal':
+            samples = (patch_size / 5.0) * rng.standard_normal(desc_size * 8)
+            samples = np.array(samples, dtype=np.int32)
+            samples = samples[
+                (samples < (patch_size // 2)) & (samples > -(patch_size - 2) // 2)
+            ]
+
+            pos1 = samples[: desc_size * 2].reshape(desc_size, 2)
+            pos2 = samples[desc_size * 2 : desc_size * 4].reshape(desc_size, 2)
+        elif self.mode == 'uniform':
+            samples = rng.integers(
+                -(patch_size - 2) // 2, (patch_size // 2) + 1, (desc_size * 2, 2)
+            )
+            samples = np.array(samples, dtype=np.int32)
+            pos1, pos2 = np.split(samples, 2)
+
+        pos1 = np.ascontiguousarray(pos1)
+        pos2 = np.ascontiguousarray(pos2)
+
+        # Removing keypoints that are within (patch_size / 2) distance from the
+        # image border
+        self.mask = _mask_border_keypoints(image.shape, keypoints, patch_size // 2)
+
+        keypoints = np.array(
+            keypoints[self.mask, :],
+            dtype=np.int64,
+            order='C',
+            copy=None if np2 else False,
+        )
+
+        self.descriptors = np.zeros(
+            (keypoints.shape[0], desc_size), dtype=bool, order='C'
+        )
+
+        _brief_loop(image, self.descriptors.view(np.uint8), keypoints, pos1, pos2)

envs/kitoverlay/skimage/feature/censure.py

@@ -0,0 +1,346 @@
+import numpy as np
+from scipy.ndimage import maximum_filter, minimum_filter, convolve
+
+from ..transform import integral_image
+from .corner import structure_tensor
+from ..morphology import octagon, star
+from .censure_cy import _censure_dob_loop
+from ..feature.util import (
+    FeatureDetector,
+    _prepare_grayscale_input_2D,
+    _mask_border_keypoints,
+)
+from .._shared.utils import check_nD
+
+# The paper(Reference [1]) mentions the sizes of the Octagon shaped filter
+# kernel for the first seven scales only. The sizes of the later scales
+# have been extrapolated based on the following statement in the paper.
+# "These octagons scale linearly and were experimentally chosen to correspond
+# to the seven DOBs described in the previous section."
+OCTAGON_OUTER_SHAPE = [
+    (5, 2),
+    (5, 3),
+    (7, 3),
+    (9, 4),
+    (9, 7),
+    (13, 7),
+    (15, 10),
+    (15, 11),
+    (15, 12),
+    (17, 13),
+    (17, 14),
+]
+OCTAGON_INNER_SHAPE = [
+    (3, 0),
+    (3, 1),
+    (3, 2),
+    (5, 2),
+    (5, 3),
+    (5, 4),
+    (5, 5),
+    (7, 5),
+    (7, 6),
+    (9, 6),
+    (9, 7),
+]
+
+# The sizes for the STAR shaped filter kernel for different scales have been
+# taken from the OpenCV implementation.
+STAR_SHAPE = [1, 2, 3, 4, 6, 8, 11, 12, 16, 22, 23, 32, 45, 46, 64, 90, 128]
+STAR_FILTER_SHAPE = [
+    (1, 0),
+    (3, 1),
+    (4, 2),
+    (5, 3),
+    (7, 4),
+    (8, 5),
+    (9, 6),
+    (11, 8),
+    (13, 10),
+    (14, 11),
+    (15, 12),
+    (16, 14),
+]
+
+
+def _filter_image(image, min_scale, max_scale, mode):
+    response = np.zeros(
+        (image.shape[0], image.shape[1], max_scale - min_scale + 1), dtype=np.float64
+    )
+
+    if mode == 'dob':
+        # make response[:, :, i] contiguous memory block
+        item_size = response.itemsize
+        response = np.lib.stride_tricks.as_strided(
+            response,
+            strides=(
+                item_size * response.shape[1],
+                item_size,
+                item_size * response.shape[0] * response.shape[1],
+            ),
+        )
+
+        integral_img = integral_image(image)
+
+        for i in range(max_scale - min_scale + 1):
+            n = min_scale + i
+
+            # Constant multipliers for the outer region and the inner region
+            # of the bi-level filters with the constraint of keeping the
+            # DC bias 0.
+            inner_weight = 1.0 / (2 * n + 1) ** 2
+            outer_weight = 1.0 / (12 * n**2 + 4 * n)
+
+            _censure_dob_loop(
+                n, integral_img, response[:, :, i], inner_weight, outer_weight
+            )
+
+    # NOTE : For the Octagon shaped filter, we implemented and evaluated the
+    # slanted integral image based image filtering but the performance was
+    # more or less equal to image filtering using
+    # scipy.ndimage.filters.convolve(). Hence we have decided to use the
+    # later for a much cleaner implementation.
+    elif mode == 'octagon':
+        # TODO : Decide the shapes of Octagon filters for scales > 7
+
+        for i in range(max_scale - min_scale + 1):
+            mo, no = OCTAGON_OUTER_SHAPE[min_scale + i - 1]
+            mi, ni = OCTAGON_INNER_SHAPE[min_scale + i - 1]
+            response[:, :, i] = convolve(image, _octagon_kernel(mo, no, mi, ni))
+
+    elif mode == 'star':
+        for i in range(max_scale - min_scale + 1):
+            m = STAR_SHAPE[STAR_FILTER_SHAPE[min_scale + i - 1][0]]
+            n = STAR_SHAPE[STAR_FILTER_SHAPE[min_scale + i - 1][1]]
+            response[:, :, i] = convolve(image, _star_kernel(m, n))
+
+    return response
+
+
+def _octagon_kernel(mo, no, mi, ni):
+    outer = (mo + 2 * no) ** 2 - 2 * no * (no + 1)
+    inner = (mi + 2 * ni) ** 2 - 2 * ni * (ni + 1)
+    outer_weight = 1.0 / (outer - inner)
+    inner_weight = 1.0 / inner
+    c = ((mo + 2 * no) - (mi + 2 * ni)) // 2
+    outer_oct = octagon(mo, no)
+    inner_oct = np.zeros((mo + 2 * no, mo + 2 * no))
+    inner_oct[c:-c, c:-c] = octagon(mi, ni)
+    bfilter = outer_weight * outer_oct - (outer_weight + inner_weight) * inner_oct
+    return bfilter
+
+
+def _star_kernel(m, n):
+    c = m + m // 2 - n - n // 2
+    outer_star = star(m)
+    inner_star = np.zeros_like(outer_star)
+    inner_star[c:-c, c:-c] = star(n)
+    outer_weight = 1.0 / (np.sum(outer_star - inner_star))
+    inner_weight = 1.0 / np.sum(inner_star)
+    bfilter = outer_weight * outer_star - (outer_weight + inner_weight) * inner_star
+    return bfilter
+
+
+def _suppress_lines(feature_mask, image, sigma, line_threshold):
+    Arr, Arc, Acc = structure_tensor(image, sigma, order='rc')
+    feature_mask[(Arr + Acc) ** 2 > line_threshold * (Arr * Acc - Arc**2)] = False
+
+
+class CENSURE(FeatureDetector):
+    """CENSURE keypoint detector.
+
+    min_scale : int, optional
+        Minimum scale to extract keypoints from.
+    max_scale : int, optional
+        Maximum scale to extract keypoints from. The keypoints will be
+        extracted from all the scales except the first and the last i.e.
+        from the scales in the range [min_scale + 1, max_scale - 1]. The filter
+        sizes for different scales is such that the two adjacent scales
+        comprise of an octave.
+    mode : {'DoB', 'Octagon', 'STAR'}, optional
+        Type of bi-level filter used to get the scales of the input image.
+        Possible values are 'DoB', 'Octagon' and 'STAR'. The three modes
+        represent the shape of the bi-level filters i.e. box(square), octagon
+        and star respectively. For instance, a bi-level octagon filter consists
+        of a smaller inner octagon and a larger outer octagon with the filter
+        weights being uniformly negative in both the inner octagon while
+        uniformly positive in the difference region. Use STAR and Octagon for
+        better features and DoB for better performance.
+    non_max_threshold : float, optional
+        Threshold value used to suppress maximas and minimas with a weak
+        magnitude response obtained after Non-Maximal Suppression.
+    line_threshold : float, optional
+        Threshold for rejecting interest points which have ratio of principal
+        curvatures greater than this value.
+
+    Attributes
+    ----------
+    keypoints : (N, 2) array
+        Keypoint coordinates as ``(row, col)``.
+    scales : (N,) array
+        Corresponding scales.
+
+    References
+    ----------
+    .. [1] Motilal Agrawal, Kurt Konolige and Morten Rufus Blas
+           "CENSURE: Center Surround Extremas for Realtime Feature
+           Detection and Matching",
+           https://link.springer.com/chapter/10.1007/978-3-540-88693-8_8
+           :DOI:`10.1007/978-3-540-88693-8_8`
+
+    .. [2] Adam Schmidt, Marek Kraft, Michal Fularz and Zuzanna Domagala
+           "Comparative Assessment of Point Feature Detectors and
+           Descriptors in the Context of Robot Navigation"
+           http://yadda.icm.edu.pl/yadda/element/bwmeta1.element.baztech-268aaf28-0faf-4872-a4df-7e2e61cb364c/c/Schmidt_comparative.pdf
+           :DOI:`10.1.1.465.1117`
+
+    Examples
+    --------
+    >>> from skimage.data import astronaut
+    >>> from skimage.color import rgb2gray
+    >>> from skimage.feature import CENSURE
+    >>> img = rgb2gray(astronaut()[100:300, 100:300])
+    >>> censure = CENSURE()
+    >>> censure.detect(img)
+    >>> censure.keypoints
+    array([[  4, 148],
+           [ 12,  73],
+           [ 21, 176],
+           [ 91,  22],
+           [ 93,  56],
+           [ 94,  22],
+           [ 95,  54],
+           [100,  51],
+           [103,  51],
+           [106,  67],
+           [108,  15],
+           [117,  20],
+           [122,  60],
+           [125,  37],
+           [129,  37],
+           [133,  76],
+           [145,  44],
+           [146,  94],
+           [150, 114],
+           [153,  33],
+           [154, 156],
+           [155, 151],
+           [184,  63]])
+    >>> censure.scales
+    array([2, 6, 6, 2, 4, 3, 2, 3, 2, 6, 3, 2, 2, 3, 2, 2, 2, 3, 2, 2, 4, 2,
+           2])
+
+    """
+
+    def __init__(
+        self,
+        min_scale=1,
+        max_scale=7,
+        mode='DoB',
+        non_max_threshold=0.15,
+        line_threshold=10,
+    ):
+        mode = mode.lower()
+        if mode not in ('dob', 'octagon', 'star'):
+            raise ValueError("`mode` must be one of 'DoB', 'Octagon', 'STAR'.")
+
+        if min_scale < 1 or max_scale < 1 or max_scale - min_scale < 2:
+            raise ValueError(
+                'The scales must be >= 1 and the number of ' 'scales should be >= 3.'
+            )
+
+        self.min_scale = min_scale
+        self.max_scale = max_scale
+        self.mode = mode
+        self.non_max_threshold = non_max_threshold
+        self.line_threshold = line_threshold
+
+        self.keypoints = None
+        self.scales = None
+
+    def detect(self, image):
+        """Detect CENSURE keypoints along with the corresponding scale.
+
+        Parameters
+        ----------
+        image : 2D ndarray
+            Input image.
+
+        """
+
+        # (1) First we generate the required scales on the input grayscale
+        # image using a bi-level filter and stack them up in `filter_response`.
+
+        # (2) We then perform Non-Maximal suppression in 3 x 3 x 3 window on
+        # the filter_response to suppress points that are neither minima or
+        # maxima in 3 x 3 x 3 neighborhood. We obtain a boolean ndarray
+        # `feature_mask` containing all the minimas and maximas in
+        # `filter_response` as True.
+        # (3) Then we suppress all the points in the `feature_mask` for which
+        # the corresponding point in the image at a particular scale has the
+        # ratio of principal curvatures greater than `line_threshold`.
+        # (4) Finally, we remove the border keypoints and return the keypoints
+        # along with its corresponding scale.
+
+        check_nD(image, 2)
+
+        num_scales = self.max_scale - self.min_scale
+
+        image = np.ascontiguousarray(_prepare_grayscale_input_2D(image))
+
+        # Generating all the scales
+        filter_response = _filter_image(
+            image, self.min_scale, self.max_scale, self.mode
+        )
+
+        # Suppressing points that are neither minima or maxima in their
+        # 3 x 3 x 3 neighborhood to zero
+        minimas = minimum_filter(filter_response, (3, 3, 3)) == filter_response
+        maximas = maximum_filter(filter_response, (3, 3, 3)) == filter_response
+
+        feature_mask = minimas | maximas
+        feature_mask[filter_response < self.non_max_threshold] = False
+
+        for i in range(1, num_scales):
+            # sigma = (window_size - 1) / 6.0, so the window covers > 99% of
+            #                                  the kernel's distribution
+            # window_size = 7 + 2 * (min_scale - 1 + i)
+            # Hence sigma = 1 + (min_scale - 1 + i)/ 3.0
+            _suppress_lines(
+                feature_mask[:, :, i],
+                image,
+                (1 + (self.min_scale + i - 1) / 3.0),
+                self.line_threshold,
+            )
+
+        rows, cols, scales = np.nonzero(feature_mask[..., 1:num_scales])
+        keypoints = np.column_stack([rows, cols])
+        scales = scales + self.min_scale + 1
+
+        if self.mode == 'dob':
+            self.keypoints = keypoints
+            self.scales = scales
+            return
+
+        cumulative_mask = np.zeros(keypoints.shape[0], dtype=bool)
+
+        if self.mode == 'octagon':
+            for i in range(self.min_scale + 1, self.max_scale):
+                c = (OCTAGON_OUTER_SHAPE[i - 1][0] - 1) // 2 + OCTAGON_OUTER_SHAPE[
+                    i - 1
+                ][1]
+                cumulative_mask |= _mask_border_keypoints(image.shape, keypoints, c) & (
+                    scales == i
+                )
+        elif self.mode == 'star':
+            for i in range(self.min_scale + 1, self.max_scale):
+                c = (
+                    STAR_SHAPE[STAR_FILTER_SHAPE[i - 1][0]]
+                    + STAR_SHAPE[STAR_FILTER_SHAPE[i - 1][0]] // 2
+                )
+                cumulative_mask |= _mask_border_keypoints(image.shape, keypoints, c) & (
+                    scales == i
+                )
+
+        self.keypoints = keypoints[cumulative_mask]
+        self.scales = scales[cumulative_mask]

envs/kitoverlay/skimage/feature/corner.py

@@ -0,0 +1,1355 @@
+import functools
+import math
+from itertools import combinations_with_replacement
+
+import numpy as np
+from scipy import ndimage as ndi
+from scipy import spatial, stats
+
+from .._shared.filters import gaussian
+from .._shared.utils import _supported_float_type, safe_as_int, warn
+from ..transform import integral_image
+from ..util import img_as_float
+from ._hessian_det_appx import _hessian_matrix_det
+from .corner_cy import _corner_fast, _corner_moravec, _corner_orientations
+from .peak import peak_local_max
+from .util import _prepare_grayscale_input_2D, _prepare_grayscale_input_nD
+
+
+def _compute_derivatives(image, mode='constant', cval=0):
+    """Compute derivatives in axis directions using the Sobel operator.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional
+        How to handle values outside the image borders.
+    cval : float, optional
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+
+    Returns
+    -------
+    derivatives : list of ndarray
+        Derivatives in each axis direction.
+
+    """
+
+    derivatives = [
+        ndi.sobel(image, axis=i, mode=mode, cval=cval) for i in range(image.ndim)
+    ]
+
+    return derivatives
+
+
+def structure_tensor(image, sigma=1, mode='constant', cval=0, order='rc'):
+    """Compute structure tensor using sum of squared differences.
+
+    The (2-dimensional) structure tensor A is defined as::
+
+        A = [Arr Arc]
+            [Arc Acc]
+
+    which is approximated by the weighted sum of squared differences in a local
+    window around each pixel in the image. This formula can be extended to a
+    larger number of dimensions (see [1]_).
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    sigma : float or array-like of float, optional
+        Standard deviation used for the Gaussian kernel, which is used as a
+        weighting function for the local summation of squared differences.
+        If sigma is an iterable, its length must be equal to `image.ndim` and
+        each element is used for the Gaussian kernel applied along its
+        respective axis.
+    mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional
+        How to handle values outside the image borders.
+    cval : float, optional
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+    order : {'rc', 'xy'}, optional
+        NOTE: 'xy' is only an option for 2D images, higher dimensions must
+        always use 'rc' order. This parameter allows for the use of reverse or
+        forward order of the image axes in gradient computation. 'rc' indicates
+        the use of the first axis initially (Arr, Arc, Acc), whilst 'xy'
+        indicates the usage of the last axis initially (Axx, Axy, Ayy).
+
+    Returns
+    -------
+    A_elems : list of ndarray
+        Upper-diagonal elements of the structure tensor for each pixel in the
+        input image.
+
+    Examples
+    --------
+    >>> from skimage.feature import structure_tensor
+    >>> square = np.zeros((5, 5))
+    >>> square[2, 2] = 1
+    >>> Arr, Arc, Acc = structure_tensor(square, sigma=0.1, order='rc')
+    >>> Acc
+    array([[0., 0., 0., 0., 0.],
+           [0., 1., 0., 1., 0.],
+           [0., 4., 0., 4., 0.],
+           [0., 1., 0., 1., 0.],
+           [0., 0., 0., 0., 0.]])
+
+    See also
+    --------
+    structure_tensor_eigenvalues
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Structure_tensor
+    """
+    if order == 'xy' and image.ndim > 2:
+        raise ValueError('Only "rc" order is supported for dim > 2.')
+
+    if order not in ['rc', 'xy']:
+        raise ValueError(f'order {order} is invalid. Must be either "rc" or "xy"')
+
+    if not np.isscalar(sigma):
+        sigma = tuple(sigma)
+        if len(sigma) != image.ndim:
+            raise ValueError('sigma must have as many elements as image ' 'has axes')
+
+    image = _prepare_grayscale_input_nD(image)
+
+    derivatives = _compute_derivatives(image, mode=mode, cval=cval)
+
+    if order == 'xy':
+        derivatives = reversed(derivatives)
+
+    # structure tensor
+    A_elems = [
+        gaussian(der0 * der1, sigma=sigma, mode=mode, cval=cval)
+        for der0, der1 in combinations_with_replacement(derivatives, 2)
+    ]
+
+    return A_elems
+
+
+def _hessian_matrix_with_gaussian(image, sigma=1, mode='reflect', cval=0, order='rc'):
+    """Compute the Hessian via convolutions with Gaussian derivatives.
+
+    In 2D, the Hessian matrix is defined as:
+        H = [Hrr Hrc]
+            [Hrc Hcc]
+
+    which is computed by convolving the image with the second derivatives
+    of the Gaussian kernel in the respective r- and c-directions.
+
+    The implementation here also supports n-dimensional data.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    sigma : float or sequence of float, optional
+        Standard deviation used for the Gaussian kernel, which sets the
+        amount of smoothing in terms of pixel-distances. It is
+        advised to not choose a sigma much less than 1.0, otherwise
+        aliasing artifacts may occur.
+    mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional
+        How to handle values outside the image borders.
+    cval : float, optional
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+    order : {'rc', 'xy'}, optional
+        This parameter allows for the use of reverse or forward order of
+        the image axes in gradient computation. 'rc' indicates the use of
+        the first axis initially (Hrr, Hrc, Hcc), whilst 'xy' indicates the
+        usage of the last axis initially (Hxx, Hxy, Hyy)
+
+    Returns
+    -------
+    H_elems : list of ndarray
+        Upper-diagonal elements of the hessian matrix for each pixel in the
+        input image. In 2D, this will be a three element list containing [Hrr,
+        Hrc, Hcc]. In nD, the list will contain ``(n**2 + n) / 2`` arrays.
+
+    """
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+    if image.ndim > 2 and order == "xy":
+        raise ValueError("order='xy' is only supported for 2D images.")
+    if order not in ["rc", "xy"]:
+        raise ValueError(f"unrecognized order: {order}")
+
+    if np.isscalar(sigma):
+        sigma = (sigma,) * image.ndim
+
+    # This function uses `scipy.ndimage.gaussian_filter` with the order
+    # argument to compute convolutions. For example, specifying
+    # ``order=[1, 0]`` would apply convolution with a first-order derivative of
+    # the Gaussian along the first axis and simple Gaussian smoothing along the
+    # second.
+
+    # For small sigma, the SciPy Gaussian filter suffers from aliasing and edge
+    # artifacts, given that the filter will approximate a sinc or sinc
+    # derivative which only goes to 0 very slowly (order 1/n**2). Thus, we use
+    # a much larger truncate value to reduce any edge artifacts.
+    truncate = 8 if all(s > 1 for s in sigma) else 100
+    sq1_2 = 1 / math.sqrt(2)
+    sigma_scaled = tuple(sq1_2 * s for s in sigma)
+    common_kwargs = dict(sigma=sigma_scaled, mode=mode, cval=cval, truncate=truncate)
+    gaussian_ = functools.partial(ndi.gaussian_filter, **common_kwargs)
+
+    # Apply two successive first order Gaussian derivative operations, as
+    # detailed in:
+    # https://dsp.stackexchange.com/questions/78280/are-scipy-second-order-gaussian-derivatives-correct
+
+    # 1.) First order along one axis while smoothing (order=0) along the other
+    ndim = image.ndim
+
+    # orders in 2D = ([1, 0], [0, 1])
+    #        in 3D = ([1, 0, 0], [0, 1, 0], [0, 0, 1])
+    #        etc.
+    orders = tuple([0] * d + [1] + [0] * (ndim - d - 1) for d in range(ndim))
+    gradients = [gaussian_(image, order=orders[d]) for d in range(ndim)]
+
+    # 2.) apply the derivative along another axis as well
+    axes = range(ndim)
+    if order == 'xy':
+        axes = reversed(axes)
+    H_elems = [
+        gaussian_(gradients[ax0], order=orders[ax1])
+        for ax0, ax1 in combinations_with_replacement(axes, 2)
+    ]
+    return H_elems
+
+
+def hessian_matrix(
+    image, sigma=1, mode='constant', cval=0, order='rc', use_gaussian_derivatives=None
+):
+    r"""Compute the Hessian matrix.
+
+    In 2D, the Hessian matrix is defined as::
+
+        H = [Hrr Hrc]
+            [Hrc Hcc]
+
+    which is computed by convolving the image with the second derivatives
+    of the Gaussian kernel in the respective r- and c-directions.
+
+    The implementation here also supports n-dimensional data.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    sigma : float
+        Standard deviation used for the Gaussian kernel, which is used as
+        weighting function for the auto-correlation matrix.
+    mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional
+        How to handle values outside the image borders.
+    cval : float, optional
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+    order : {'rc', 'xy'}, optional
+        For 2D images, this parameter allows for the use of reverse or forward
+        order of the image axes in gradient computation. 'rc' indicates the use
+        of the first axis initially (Hrr, Hrc, Hcc), whilst 'xy' indicates the
+        usage of the last axis initially (Hxx, Hxy, Hyy). Images with higher
+        dimension must always use 'rc' order.
+    use_gaussian_derivatives : bool, optional
+        Indicates whether the Hessian is computed by convolving with Gaussian
+        derivatives, or by a simple finite-difference operation.
+
+    Returns
+    -------
+    H_elems : list of ndarray
+        Upper-diagonal elements of the hessian matrix for each pixel in the
+        input image. In 2D, this will be a three element list containing [Hrr,
+        Hrc, Hcc]. In nD, the list will contain ``(n**2 + n) / 2`` arrays.
+
+
+    Notes
+    -----
+    The distributive property of derivatives and convolutions allows us to
+    restate the derivative of an image, I, smoothed with a Gaussian kernel, G,
+    as the convolution of the image with the derivative of G.
+
+    .. math::
+
+        \frac{\partial }{\partial x_i}(I * G) =
+        I * \left( \frac{\partial }{\partial x_i} G \right)
+
+    When ``use_gaussian_derivatives`` is ``True``, this property is used to
+    compute the second order derivatives that make up the Hessian matrix.
+
+    When ``use_gaussian_derivatives`` is ``False``, simple finite differences
+    on a Gaussian-smoothed image are used instead.
+
+    Examples
+    --------
+    >>> from skimage.feature import hessian_matrix
+    >>> square = np.zeros((5, 5))
+    >>> square[2, 2] = 4
+    >>> Hrr, Hrc, Hcc = hessian_matrix(square, sigma=0.1, order='rc',
+    ...                                use_gaussian_derivatives=False)
+    >>> Hrc
+    array([[ 0.,  0.,  0.,  0.,  0.],
+           [ 0.,  1.,  0., -1.,  0.],
+           [ 0.,  0.,  0.,  0.,  0.],
+           [ 0., -1.,  0.,  1.,  0.],
+           [ 0.,  0.,  0.,  0.,  0.]])
+
+    """
+
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+    if image.ndim > 2 and order == "xy":
+        raise ValueError("order='xy' is only supported for 2D images.")
+    if order not in ["rc", "xy"]:
+        raise ValueError(f"unrecognized order: {order}")
+
+    if use_gaussian_derivatives is None:
+        use_gaussian_derivatives = False
+        warn(
+            "use_gaussian_derivatives currently defaults to False, but will "
+            "change to True in a future version. Please specify this "
+            "argument explicitly to maintain the current behavior",
+            category=FutureWarning,
+            stacklevel=2,
+        )
+
+    if use_gaussian_derivatives:
+        return _hessian_matrix_with_gaussian(
+            image, sigma=sigma, mode=mode, cval=cval, order=order
+        )
+
+    gaussian_filtered = gaussian(image, sigma=sigma, mode=mode, cval=cval)
+
+    gradients = np.gradient(gaussian_filtered)
+    axes = range(image.ndim)
+
+    if order == 'xy':
+        axes = reversed(axes)
+
+    H_elems = [
+        np.gradient(gradients[ax0], axis=ax1)
+        for ax0, ax1 in combinations_with_replacement(axes, 2)
+    ]
+    return H_elems
+
+
+def hessian_matrix_det(image, sigma=1, approximate=True):
+    """Compute the approximate Hessian Determinant over an image.
+
+    The 2D approximate method uses box filters over integral images to
+    compute the approximate Hessian Determinant.
+
+    Parameters
+    ----------
+    image : ndarray
+        The image over which to compute the Hessian Determinant.
+    sigma : float, optional
+        Standard deviation of the Gaussian kernel used for the Hessian
+        matrix.
+    approximate : bool, optional
+        If ``True`` and the image is 2D, use a much faster approximate
+        computation. This argument has no effect on 3D and higher images.
+
+    Returns
+    -------
+    out : array
+        The array of the Determinant of Hessians.
+
+    References
+    ----------
+    .. [1] Herbert Bay, Andreas Ess, Tinne Tuytelaars, Luc Van Gool,
+           "SURF: Speeded Up Robust Features"
+           ftp://ftp.vision.ee.ethz.ch/publications/articles/eth_biwi_00517.pdf
+
+    Notes
+    -----
+    For 2D images when ``approximate=True``, the running time of this method
+    only depends on size of the image. It is independent of `sigma` as one
+    would expect. The downside is that the result for `sigma` less than `3`
+    is not accurate, i.e., not similar to the result obtained if someone
+    computed the Hessian and took its determinant.
+    """
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+    if image.ndim == 2 and approximate:
+        integral = integral_image(image)
+        return np.array(_hessian_matrix_det(integral, sigma))
+    else:  # slower brute-force implementation for nD images
+        hessian_mat_array = _symmetric_image(
+            hessian_matrix(image, sigma, use_gaussian_derivatives=False)
+        )
+        return np.linalg.det(hessian_mat_array)
+
+
+def _symmetric_compute_eigenvalues(S_elems):
+    """Compute eigenvalues from the upper-diagonal entries of a symmetric
+    matrix.
+
+    Parameters
+    ----------
+    S_elems : list of ndarray
+        The upper-diagonal elements of the matrix, as returned by
+        `hessian_matrix` or `structure_tensor`.
+
+    Returns
+    -------
+    eigs : ndarray
+        The eigenvalues of the matrix, in decreasing order. The eigenvalues are
+        the leading dimension. That is, ``eigs[i, j, k]`` contains the
+        ith-largest eigenvalue at position (j, k).
+    """
+
+    if len(S_elems) == 3:  # Fast explicit formulas for 2D.
+        M00, M01, M11 = S_elems
+        eigs = np.empty((2, *M00.shape), M00.dtype)
+        eigs[:] = (M00 + M11) / 2
+        hsqrtdet = np.sqrt(M01**2 + ((M00 - M11) / 2) ** 2)
+        eigs[0] += hsqrtdet
+        eigs[1] -= hsqrtdet
+        return eigs
+    else:
+        matrices = _symmetric_image(S_elems)
+        # eigvalsh returns eigenvalues in increasing order. We want decreasing
+        eigs = np.linalg.eigvalsh(matrices)[..., ::-1]
+        leading_axes = tuple(range(eigs.ndim - 1))
+        return np.transpose(eigs, (eigs.ndim - 1,) + leading_axes)
+
+
+def _symmetric_image(S_elems):
+    """Convert the upper-diagonal elements of a matrix to the full
+    symmetric matrix.
+
+    Parameters
+    ----------
+    S_elems : list of array
+        The upper-diagonal elements of the matrix, as returned by
+        `hessian_matrix` or `structure_tensor`.
+
+    Returns
+    -------
+    image : array
+        An array of shape ``(M, N[, ...], image.ndim, image.ndim)``,
+        containing the matrix corresponding to each coordinate.
+    """
+    image = S_elems[0]
+    symmetric_image = np.zeros(
+        image.shape + (image.ndim, image.ndim), dtype=S_elems[0].dtype
+    )
+    for idx, (row, col) in enumerate(
+        combinations_with_replacement(range(image.ndim), 2)
+    ):
+        symmetric_image[..., row, col] = S_elems[idx]
+        symmetric_image[..., col, row] = S_elems[idx]
+    return symmetric_image
+
+
+def structure_tensor_eigenvalues(A_elems):
+    """Compute eigenvalues of structure tensor.
+
+    Parameters
+    ----------
+    A_elems : list of ndarray
+        The upper-diagonal elements of the structure tensor, as returned
+        by `structure_tensor`.
+
+    Returns
+    -------
+    ndarray
+        The eigenvalues of the structure tensor, in decreasing order. The
+        eigenvalues are the leading dimension. That is, the coordinate
+        [i, j, k] corresponds to the ith-largest eigenvalue at position (j, k).
+
+    Examples
+    --------
+    >>> from skimage.feature import structure_tensor
+    >>> from skimage.feature import structure_tensor_eigenvalues
+    >>> square = np.zeros((5, 5))
+    >>> square[2, 2] = 1
+    >>> A_elems = structure_tensor(square, sigma=0.1, order='rc')
+    >>> structure_tensor_eigenvalues(A_elems)[0]
+    array([[0., 0., 0., 0., 0.],
+           [0., 2., 4., 2., 0.],
+           [0., 4., 0., 4., 0.],
+           [0., 2., 4., 2., 0.],
+           [0., 0., 0., 0., 0.]])
+
+    See also
+    --------
+    structure_tensor
+    """
+    return _symmetric_compute_eigenvalues(A_elems)
+
+
+def hessian_matrix_eigvals(H_elems):
+    """Compute eigenvalues of Hessian matrix.
+
+    Parameters
+    ----------
+    H_elems : list of ndarray
+        The upper-diagonal elements of the Hessian matrix, as returned
+        by `hessian_matrix`.
+
+    Returns
+    -------
+    eigs : ndarray
+        The eigenvalues of the Hessian matrix, in decreasing order. The
+        eigenvalues are the leading dimension. That is, ``eigs[i, j, k]``
+        contains the ith-largest eigenvalue at position (j, k).
+
+    Examples
+    --------
+    >>> from skimage.feature import hessian_matrix, hessian_matrix_eigvals
+    >>> square = np.zeros((5, 5))
+    >>> square[2, 2] = 4
+    >>> H_elems = hessian_matrix(square, sigma=0.1, order='rc',
+    ...                          use_gaussian_derivatives=False)
+    >>> hessian_matrix_eigvals(H_elems)[0]
+    array([[ 0.,  0.,  2.,  0.,  0.],
+           [ 0.,  1.,  0.,  1.,  0.],
+           [ 2.,  0., -2.,  0.,  2.],
+           [ 0.,  1.,  0.,  1.,  0.],
+           [ 0.,  0.,  2.,  0.,  0.]])
+    """
+    return _symmetric_compute_eigenvalues(H_elems)
+
+
+def shape_index(image, sigma=1, mode='constant', cval=0):
+    """Compute the shape index.
+
+    The shape index, as defined by Koenderink & van Doorn [1]_, is a
+    single valued measure of local curvature, assuming the image as a 3D plane
+    with intensities representing heights.
+
+    It is derived from the eigenvalues of the Hessian, and its
+    value ranges from -1 to 1 (and is undefined (=NaN) in *flat* regions),
+    with following ranges representing following shapes:
+
+    .. table:: Ranges of the shape index and corresponding shapes.
+
+      ===================  =============
+      Interval (s in ...)  Shape
+      ===================  =============
+      [  -1, -7/8)         Spherical cup
+      [-7/8, -5/8)         Through
+      [-5/8, -3/8)         Rut
+      [-3/8, -1/8)         Saddle rut
+      [-1/8, +1/8)         Saddle
+      [+1/8, +3/8)         Saddle ridge
+      [+3/8, +5/8)         Ridge
+      [+5/8, +7/8)         Dome
+      [+7/8,   +1]         Spherical cap
+      ===================  =============
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    sigma : float, optional
+        Standard deviation used for the Gaussian kernel, which is used for
+        smoothing the input data before Hessian eigen value calculation.
+    mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional
+        How to handle values outside the image borders
+    cval : float, optional
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+
+    Returns
+    -------
+    s : ndarray
+        Shape index
+
+    References
+    ----------
+    .. [1] Koenderink, J. J. & van Doorn, A. J.,
+           "Surface shape and curvature scales",
+           Image and Vision Computing, 1992, 10, 557-564.
+           :DOI:`10.1016/0262-8856(92)90076-F`
+
+    Examples
+    --------
+    >>> from skimage.feature import shape_index
+    >>> square = np.zeros((5, 5))
+    >>> square[2, 2] = 4
+    >>> s = shape_index(square, sigma=0.1)
+    >>> s
+    array([[ nan,  nan, -0.5,  nan,  nan],
+           [ nan, -0. ,  nan, -0. ,  nan],
+           [-0.5,  nan, -1. ,  nan, -0.5],
+           [ nan, -0. ,  nan, -0. ,  nan],
+           [ nan,  nan, -0.5,  nan,  nan]])
+    """
+
+    H = hessian_matrix(
+        image,
+        sigma=sigma,
+        mode=mode,
+        cval=cval,
+        order='rc',
+        use_gaussian_derivatives=False,
+    )
+    l1, l2 = hessian_matrix_eigvals(H)
+
+    # don't warn on divide by 0 as occurs in the docstring example
+    with np.errstate(divide='ignore', invalid='ignore'):
+        return (2.0 / np.pi) * np.arctan((l2 + l1) / (l2 - l1))
+
+
+def corner_kitchen_rosenfeld(image, mode='constant', cval=0):
+    """Compute Kitchen and Rosenfeld corner measure response image.
+
+    The corner measure is calculated as follows::
+
+        (imxx * imy**2 + imyy * imx**2 - 2 * imxy * imx * imy)
+            / (imx**2 + imy**2)
+
+    Where imx and imy are the first and imxx, imxy, imyy the second
+    derivatives.
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional
+        How to handle values outside the image borders.
+    cval : float, optional
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+
+    Returns
+    -------
+    response : ndarray
+        Kitchen and Rosenfeld response image.
+
+    References
+    ----------
+    .. [1] Kitchen, L., & Rosenfeld, A. (1982). Gray-level corner detection.
+           Pattern recognition letters, 1(2), 95-102.
+           :DOI:`10.1016/0167-8655(82)90020-4`
+    """
+
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+
+    imy, imx = _compute_derivatives(image, mode=mode, cval=cval)
+    imxy, imxx = _compute_derivatives(imx, mode=mode, cval=cval)
+    imyy, imyx = _compute_derivatives(imy, mode=mode, cval=cval)
+
+    numerator = imxx * imy**2 + imyy * imx**2 - 2 * imxy * imx * imy
+    denominator = imx**2 + imy**2
+
+    response = np.zeros_like(image, dtype=float_dtype)
+
+    mask = denominator != 0
+    response[mask] = numerator[mask] / denominator[mask]
+
+    return response
+
+
+def corner_harris(image, method='k', k=0.05, eps=1e-6, sigma=1):
+    """Compute Harris corner measure response image.
+
+    This corner detector uses information from the auto-correlation matrix A::
+
+        A = [(imx**2)   (imx*imy)] = [Axx Axy]
+            [(imx*imy)   (imy**2)]   [Axy Ayy]
+
+    Where imx and imy are first derivatives, averaged with a gaussian filter.
+    The corner measure is then defined as::
+
+        det(A) - k * trace(A)**2
+
+    or::
+
+        2 * det(A) / (trace(A) + eps)
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    method : {'k', 'eps'}, optional
+        Method to compute the response image from the auto-correlation matrix.
+    k : float, optional
+        Sensitivity factor to separate corners from edges, typically in range
+        `[0, 0.2]`. Small values of k result in detection of sharp corners.
+    eps : float, optional
+        Normalisation factor (Noble's corner measure).
+    sigma : float, optional
+        Standard deviation used for the Gaussian kernel, which is used as
+        weighting function for the auto-correlation matrix.
+
+    Returns
+    -------
+    response : ndarray
+        Harris response image.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Corner_detection
+
+    Examples
+    --------
+    >>> from skimage.feature import corner_harris, corner_peaks
+    >>> square = np.zeros([10, 10])
+    >>> square[2:8, 2:8] = 1
+    >>> square.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    >>> corner_peaks(corner_harris(square), min_distance=1)
+    array([[2, 2],
+           [2, 7],
+           [7, 2],
+           [7, 7]])
+
+    """
+
+    Arr, Arc, Acc = structure_tensor(image, sigma, order='rc')
+
+    # determinant
+    detA = Arr * Acc - Arc**2
+    # trace
+    traceA = Arr + Acc
+
+    if method == 'k':
+        response = detA - k * traceA**2
+    else:
+        response = 2 * detA / (traceA + eps)
+
+    return response
+
+
+def corner_shi_tomasi(image, sigma=1):
+    """Compute Shi-Tomasi (Kanade-Tomasi) corner measure response image.
+
+    This corner detector uses information from the auto-correlation matrix A::
+
+        A = [(imx**2)   (imx*imy)] = [Axx Axy]
+            [(imx*imy)   (imy**2)]   [Axy Ayy]
+
+    Where imx and imy are first derivatives, averaged with a gaussian filter.
+    The corner measure is then defined as the smaller eigenvalue of A::
+
+        ((Axx + Ayy) - sqrt((Axx - Ayy)**2 + 4 * Axy**2)) / 2
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    sigma : float, optional
+        Standard deviation used for the Gaussian kernel, which is used as
+        weighting function for the auto-correlation matrix.
+
+    Returns
+    -------
+    response : ndarray
+        Shi-Tomasi response image.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Corner_detection
+
+    Examples
+    --------
+    >>> from skimage.feature import corner_shi_tomasi, corner_peaks
+    >>> square = np.zeros([10, 10])
+    >>> square[2:8, 2:8] = 1
+    >>> square.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    >>> corner_peaks(corner_shi_tomasi(square), min_distance=1)
+    array([[2, 2],
+           [2, 7],
+           [7, 2],
+           [7, 7]])
+
+    """
+
+    Arr, Arc, Acc = structure_tensor(image, sigma, order='rc')
+
+    # minimum eigenvalue of A
+    response = ((Arr + Acc) - np.sqrt((Arr - Acc) ** 2 + 4 * Arc**2)) / 2
+
+    return response
+
+
+def corner_foerstner(image, sigma=1):
+    """Compute Foerstner corner measure response image.
+
+    This corner detector uses information from the auto-correlation matrix A::
+
+        A = [(imx**2)   (imx*imy)] = [Axx Axy]
+            [(imx*imy)   (imy**2)]   [Axy Ayy]
+
+    Where imx and imy are first derivatives, averaged with a gaussian filter.
+    The corner measure is then defined as::
+
+        w = det(A) / trace(A)           (size of error ellipse)
+        q = 4 * det(A) / trace(A)**2    (roundness of error ellipse)
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    sigma : float, optional
+        Standard deviation used for the Gaussian kernel, which is used as
+        weighting function for the auto-correlation matrix.
+
+    Returns
+    -------
+    w : ndarray
+        Error ellipse sizes.
+    q : ndarray
+        Roundness of error ellipse.
+
+    References
+    ----------
+    .. [1] Förstner, W., & Gülch, E. (1987, June). A fast operator for
+           detection and precise location of distinct points, corners and
+           centres of circular features. In Proc. ISPRS intercommission
+           conference on fast processing of photogrammetric data (pp. 281-305).
+           https://cseweb.ucsd.edu/classes/sp02/cse252/foerstner/foerstner.pdf
+    .. [2] https://en.wikipedia.org/wiki/Corner_detection
+
+    Examples
+    --------
+    >>> from skimage.feature import corner_foerstner, corner_peaks
+    >>> square = np.zeros([10, 10])
+    >>> square[2:8, 2:8] = 1
+    >>> square.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    >>> w, q = corner_foerstner(square)
+    >>> accuracy_thresh = 0.5
+    >>> roundness_thresh = 0.3
+    >>> foerstner = (q > roundness_thresh) * (w > accuracy_thresh) * w
+    >>> corner_peaks(foerstner, min_distance=1)
+    array([[2, 2],
+           [2, 7],
+           [7, 2],
+           [7, 7]])
+
+    """
+
+    Arr, Arc, Acc = structure_tensor(image, sigma, order='rc')
+
+    # determinant
+    detA = Arr * Acc - Arc**2
+    # trace
+    traceA = Arr + Acc
+
+    w = np.zeros_like(image, dtype=detA.dtype)
+    q = np.zeros_like(w)
+
+    mask = traceA != 0
+
+    w[mask] = detA[mask] / traceA[mask]
+    q[mask] = 4 * detA[mask] / traceA[mask] ** 2
+
+    return w, q
+
+
+def corner_fast(image, n=12, threshold=0.15):
+    """Extract FAST corners for a given image.
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    n : int, optional
+        Minimum number of consecutive pixels out of 16 pixels on the circle
+        that should all be either brighter or darker w.r.t testpixel.
+        A point c on the circle is darker w.r.t test pixel p if
+        `Ic < Ip - threshold` and brighter if `Ic > Ip + threshold`. Also
+        stands for the n in `FAST-n` corner detector.
+    threshold : float, optional
+        Threshold used in deciding whether the pixels on the circle are
+        brighter, darker or similar w.r.t. the test pixel. Decrease the
+        threshold when more corners are desired and vice-versa.
+
+    Returns
+    -------
+    response : ndarray
+        FAST corner response image.
+
+    References
+    ----------
+    .. [1] Rosten, E., & Drummond, T. (2006, May). Machine learning for
+           high-speed corner detection. In European conference on computer
+           vision (pp. 430-443). Springer, Berlin, Heidelberg.
+           :DOI:`10.1007/11744023_34`
+           http://www.edwardrosten.com/work/rosten_2006_machine.pdf
+    .. [2] Wikipedia, "Features from accelerated segment test",
+           https://en.wikipedia.org/wiki/Features_from_accelerated_segment_test
+
+    Examples
+    --------
+    >>> from skimage.feature import corner_fast, corner_peaks
+    >>> square = np.zeros((12, 12))
+    >>> square[3:9, 3:9] = 1
+    >>> square.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    >>> corner_peaks(corner_fast(square, 9), min_distance=1)
+    array([[3, 3],
+           [3, 8],
+           [8, 3],
+           [8, 8]])
+
+    """
+    image = _prepare_grayscale_input_2D(image)
+
+    image = np.ascontiguousarray(image)
+    response = _corner_fast(image, n, threshold)
+    return response
+
+
+def corner_subpix(image, corners, window_size=11, alpha=0.99):
+    """Determine subpixel position of corners.
+
+    A statistical test decides whether the corner is defined as the
+    intersection of two edges or a single peak. Depending on the classification
+    result, the subpixel corner location is determined based on the local
+    covariance of the grey-values. If the significance level for either
+    statistical test is not sufficient, the corner cannot be classified, and
+    the output subpixel position is set to NaN.
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    corners : (K, 2) ndarray
+        Corner coordinates `(row, col)`.
+    window_size : int, optional
+        Search window size for subpixel estimation.
+    alpha : float, optional
+        Significance level for corner classification.
+
+    Returns
+    -------
+    positions : (K, 2) ndarray
+        Subpixel corner positions. NaN for "not classified" corners.
+
+    References
+    ----------
+    .. [1] Förstner, W., & Gülch, E. (1987, June). A fast operator for
+           detection and precise location of distinct points, corners and
+           centres of circular features. In Proc. ISPRS intercommission
+           conference on fast processing of photogrammetric data (pp. 281-305).
+           https://cseweb.ucsd.edu/classes/sp02/cse252/foerstner/foerstner.pdf
+    .. [2] https://en.wikipedia.org/wiki/Corner_detection
+
+    Examples
+    --------
+    >>> from skimage.feature import corner_harris, corner_peaks, corner_subpix
+    >>> img = np.zeros((10, 10))
+    >>> img[:5, :5] = 1
+    >>> img[5:, 5:] = 1
+    >>> img.astype(int)
+    array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
+           [1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
+           [1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
+           [1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
+           [1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]])
+    >>> coords = corner_peaks(corner_harris(img), min_distance=2)
+    >>> coords_subpix = corner_subpix(img, coords, window_size=7)
+    >>> coords_subpix
+    array([[4.5, 4.5]])
+
+    """
+
+    # window extent in one direction
+    wext = (window_size - 1) // 2
+
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+    image = np.pad(image, pad_width=wext, mode='constant', constant_values=0)
+
+    # add pad width, make sure to not modify the input values in-place
+    corners = safe_as_int(corners + wext)
+
+    # normal equation arrays
+    N_dot = np.zeros((2, 2), dtype=float_dtype)
+    N_edge = np.zeros((2, 2), dtype=float_dtype)
+    b_dot = np.zeros((2,), dtype=float_dtype)
+    b_edge = np.zeros((2,), dtype=float_dtype)
+
+    # critical statistical test values
+    redundancy = window_size**2 - 2
+    t_crit_dot = stats.f.isf(1 - alpha, redundancy, redundancy)
+    t_crit_edge = stats.f.isf(alpha, redundancy, redundancy)
+
+    # coordinates of pixels within window
+    y, x = np.mgrid[-wext : wext + 1, -wext : wext + 1]
+
+    corners_subpix = np.zeros_like(corners, dtype=float_dtype)
+
+    for i, (y0, x0) in enumerate(corners):
+        # crop window around corner + border for sobel operator
+        miny = y0 - wext - 1
+        maxy = y0 + wext + 2
+        minx = x0 - wext - 1
+        maxx = x0 + wext + 2
+        window = image[miny:maxy, minx:maxx]
+
+        winy, winx = _compute_derivatives(window, mode='constant', cval=0)
+
+        # compute gradient squares and remove border
+        winx_winx = (winx * winx)[1:-1, 1:-1]
+        winx_winy = (winx * winy)[1:-1, 1:-1]
+        winy_winy = (winy * winy)[1:-1, 1:-1]
+
+        # sum of squared differences (mean instead of gaussian filter)
+        Axx = np.sum(winx_winx)
+        Axy = np.sum(winx_winy)
+        Ayy = np.sum(winy_winy)
+
+        # sum of squared differences weighted with coordinates
+        # (mean instead of gaussian filter)
+        bxx_x = np.sum(winx_winx * x)
+        bxx_y = np.sum(winx_winx * y)
+        bxy_x = np.sum(winx_winy * x)
+        bxy_y = np.sum(winx_winy * y)
+        byy_x = np.sum(winy_winy * x)
+        byy_y = np.sum(winy_winy * y)
+
+        # normal equations for subpixel position
+        N_dot[0, 0] = Axx
+        N_dot[0, 1] = N_dot[1, 0] = -Axy
+        N_dot[1, 1] = Ayy
+
+        N_edge[0, 0] = Ayy
+        N_edge[0, 1] = N_edge[1, 0] = Axy
+        N_edge[1, 1] = Axx
+
+        b_dot[:] = bxx_y - bxy_x, byy_x - bxy_y
+        b_edge[:] = byy_y + bxy_x, bxx_x + bxy_y
+
+        # estimated positions
+        try:
+            est_dot = np.linalg.solve(N_dot, b_dot)
+            est_edge = np.linalg.solve(N_edge, b_edge)
+        except np.linalg.LinAlgError:
+            # if image is constant the system is singular
+            corners_subpix[i, :] = np.nan, np.nan
+            continue
+
+        # residuals
+        ry_dot = y - est_dot[0]
+        rx_dot = x - est_dot[1]
+        ry_edge = y - est_edge[0]
+        rx_edge = x - est_edge[1]
+        # squared residuals
+        rxx_dot = rx_dot * rx_dot
+        rxy_dot = rx_dot * ry_dot
+        ryy_dot = ry_dot * ry_dot
+        rxx_edge = rx_edge * rx_edge
+        rxy_edge = rx_edge * ry_edge
+        ryy_edge = ry_edge * ry_edge
+
+        # determine corner class (dot or edge)
+        # variance for different models
+        var_dot = np.sum(
+            winx_winx * ryy_dot - 2 * winx_winy * rxy_dot + winy_winy * rxx_dot
+        )
+        var_edge = np.sum(
+            winy_winy * ryy_edge + 2 * winx_winy * rxy_edge + winx_winx * rxx_edge
+        )
+
+        # test value (F-distributed)
+        if var_dot < np.spacing(1) and var_edge < np.spacing(1):
+            t = np.nan
+        elif var_dot == 0:
+            t = np.inf
+        else:
+            t = var_edge / var_dot
+
+        # 1 for edge, -1 for dot, 0 for "not classified"
+        corner_class = int(t < t_crit_edge) - int(t > t_crit_dot)
+
+        if corner_class == -1:
+            corners_subpix[i, :] = y0 + est_dot[0], x0 + est_dot[1]
+        elif corner_class == 0:
+            corners_subpix[i, :] = np.nan, np.nan
+        elif corner_class == 1:
+            corners_subpix[i, :] = y0 + est_edge[0], x0 + est_edge[1]
+
+    # subtract pad width
+    corners_subpix -= wext
+
+    return corners_subpix
+
+
+def corner_peaks(
+    image,
+    min_distance=1,
+    threshold_abs=None,
+    threshold_rel=None,
+    exclude_border=True,
+    indices=True,
+    num_peaks=np.inf,
+    footprint=None,
+    labels=None,
+    *,
+    num_peaks_per_label=np.inf,
+    p_norm=np.inf,
+):
+    """Find peaks in corner measure response image.
+
+    This differs from `skimage.feature.peak_local_max` in that it suppresses
+    multiple connected peaks with the same accumulator value.
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    min_distance : int, optional
+        The minimal allowed distance separating peaks.
+    * : *
+        See :py:meth:`skimage.feature.peak_local_max`.
+    p_norm : float
+        Which Minkowski p-norm to use. Should be in the range [1, inf].
+        A finite large p may cause a ValueError if overflow can occur.
+        ``inf`` corresponds to the Chebyshev distance and 2 to the
+        Euclidean distance.
+
+    Returns
+    -------
+    output : ndarray or ndarray of bools
+
+        * If `indices = True`  : (row, column, ...) coordinates of peaks.
+        * If `indices = False` : Boolean array shaped like `image`, with peaks
+          represented by True values.
+
+    See also
+    --------
+    skimage.feature.peak_local_max
+
+    Notes
+    -----
+    .. versionchanged:: 0.18
+        The default value of `threshold_rel` has changed to None, which
+        corresponds to letting `skimage.feature.peak_local_max` decide on the
+        default. This is equivalent to `threshold_rel=0`.
+
+    The `num_peaks` limit is applied before suppression of connected peaks.
+    To limit the number of peaks after suppression, set `num_peaks=np.inf` and
+    post-process the output of this function.
+
+    Examples
+    --------
+    >>> from skimage.feature import peak_local_max
+    >>> response = np.zeros((5, 5))
+    >>> response[2:4, 2:4] = 1
+    >>> response
+    array([[0., 0., 0., 0., 0.],
+           [0., 0., 0., 0., 0.],
+           [0., 0., 1., 1., 0.],
+           [0., 0., 1., 1., 0.],
+           [0., 0., 0., 0., 0.]])
+    >>> peak_local_max(response)
+    array([[2, 2],
+           [2, 3],
+           [3, 2],
+           [3, 3]])
+    >>> corner_peaks(response)
+    array([[2, 2]])
+
+    """
+    if np.isinf(num_peaks):
+        num_peaks = None
+
+    # Get the coordinates of the detected peaks
+    coords = peak_local_max(
+        image,
+        min_distance=min_distance,
+        threshold_abs=threshold_abs,
+        threshold_rel=threshold_rel,
+        exclude_border=exclude_border,
+        num_peaks=np.inf,
+        footprint=footprint,
+        labels=labels,
+        num_peaks_per_label=num_peaks_per_label,
+    )
+
+    if len(coords):
+        # Use KDtree to find the peaks that are too close to each other
+        tree = spatial.cKDTree(coords)
+
+        rejected_peaks_indices = set()
+        for idx, point in enumerate(coords):
+            if idx not in rejected_peaks_indices:
+                candidates = tree.query_ball_point(point, r=min_distance, p=p_norm)
+                candidates.remove(idx)
+                rejected_peaks_indices.update(candidates)
+
+        # Remove the peaks that are too close to each other
+        coords = np.delete(coords, tuple(rejected_peaks_indices), axis=0)[:num_peaks]
+
+    if indices:
+        return coords
+
+    peaks = np.zeros_like(image, dtype=bool)
+    peaks[tuple(coords.T)] = True
+
+    return peaks
+
+
+def corner_moravec(image, window_size=1):
+    """Compute Moravec corner measure response image.
+
+    This is one of the simplest corner detectors and is comparatively fast but
+    has several limitations (e.g. not rotation invariant).
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    window_size : int, optional
+        Window size.
+
+    Returns
+    -------
+    response : ndarray
+        Moravec response image.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Corner_detection
+
+    Examples
+    --------
+    >>> from skimage.feature import corner_moravec
+    >>> square = np.zeros([7, 7])
+    >>> square[3, 3] = 1
+    >>> square.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0]])
+    >>> corner_moravec(square).astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 2, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0]])
+    """
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+    return _corner_moravec(np.ascontiguousarray(image), window_size)
+
+
+def corner_orientations(image, corners, mask):
+    """Compute the orientation of corners.
+
+    The orientation of corners is computed using the first order central moment
+    i.e. the center of mass approach. The corner orientation is the angle of
+    the vector from the corner coordinate to the intensity centroid in the
+    local neighborhood around the corner calculated using first order central
+    moment.
+
+    Parameters
+    ----------
+    image : (M, N) array
+        Input grayscale image.
+    corners : (K, 2) array
+        Corner coordinates as ``(row, col)``.
+    mask : 2D array
+        Mask defining the local neighborhood of the corner used for the
+        calculation of the central moment.
+
+    Returns
+    -------
+    orientations : (K, 1) array
+        Orientations of corners in the range [-pi, pi].
+
+    References
+    ----------
+    .. [1] Ethan Rublee, Vincent Rabaud, Kurt Konolige and Gary Bradski
+          "ORB : An efficient alternative to SIFT and SURF"
+          http://www.vision.cs.chubu.ac.jp/CV-R/pdf/Rublee_iccv2011.pdf
+    .. [2] Paul L. Rosin, "Measuring Corner Properties"
+          http://users.cs.cf.ac.uk/Paul.Rosin/corner2.pdf
+
+    Examples
+    --------
+    >>> from skimage.morphology import octagon
+    >>> from skimage.feature import (corner_fast, corner_peaks,
+    ...                              corner_orientations)
+    >>> square = np.zeros((12, 12))
+    >>> square[3:9, 3:9] = 1
+    >>> square.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    >>> corners = corner_peaks(corner_fast(square, 9), min_distance=1)
+    >>> corners
+    array([[3, 3],
+           [3, 8],
+           [8, 3],
+           [8, 8]])
+    >>> orientations = corner_orientations(square, corners, octagon(3, 2))
+    >>> np.rad2deg(orientations)
+    array([  45.,  135.,  -45., -135.])
+
+    """
+    image = _prepare_grayscale_input_2D(image)
+    return _corner_orientations(image, corners, mask)

envs/kitoverlay/skimage/feature/haar.py

@@ -0,0 +1,339 @@
+from itertools import chain
+from operator import add
+
+import numpy as np
+
+from ._haar import haar_like_feature_coord_wrapper
+from ._haar import haar_like_feature_wrapper
+from ..color import gray2rgb
+from ..draw import rectangle
+from ..util import img_as_float
+
+FEATURE_TYPE = ('type-2-x', 'type-2-y', 'type-3-x', 'type-3-y', 'type-4')
+
+
+def _validate_feature_type(feature_type):
+    """Transform feature type to an iterable and check that it exists."""
+    if feature_type is None:
+        feature_type_ = FEATURE_TYPE
+    else:
+        if isinstance(feature_type, str):
+            feature_type_ = [feature_type]
+        else:
+            feature_type_ = feature_type
+        for feat_t in feature_type_:
+            if feat_t not in FEATURE_TYPE:
+                raise ValueError(
+                    f'The given feature type is unknown. Got {feat_t} instead of one '
+                    f'of {FEATURE_TYPE}.'
+                )
+    return feature_type_
+
+
+def haar_like_feature_coord(width, height, feature_type=None):
+    """Compute the coordinates of Haar-like features.
+
+    Parameters
+    ----------
+    width : int
+        Width of the detection window.
+    height : int
+        Height of the detection window.
+    feature_type : str or list of str or None, optional
+        The type of feature to consider:
+
+        - 'type-2-x': 2 rectangles varying along the x axis;
+        - 'type-2-y': 2 rectangles varying along the y axis;
+        - 'type-3-x': 3 rectangles varying along the x axis;
+        - 'type-3-y': 3 rectangles varying along the y axis;
+        - 'type-4': 4 rectangles varying along x and y axis.
+
+        By default all features are extracted.
+
+    Returns
+    -------
+    feature_coord : (n_features, n_rectangles, 2, 2), ndarray of list of \
+tuple coord
+        Coordinates of the rectangles for each feature.
+    feature_type : (n_features,), ndarray of str
+        The corresponding type for each feature.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.transform import integral_image
+    >>> from skimage.feature import haar_like_feature_coord
+    >>> feat_coord, feat_type = haar_like_feature_coord(2, 2, 'type-4')
+    >>> feat_coord # doctest: +SKIP
+    array([ list([[(0, 0), (0, 0)], [(0, 1), (0, 1)],
+                  [(1, 1), (1, 1)], [(1, 0), (1, 0)]])], dtype=object)
+    >>> feat_type
+    array(['type-4'], dtype=object)
+
+    """
+    feature_type_ = _validate_feature_type(feature_type)
+
+    feat_coord, feat_type = zip(
+        *[
+            haar_like_feature_coord_wrapper(width, height, feat_t)
+            for feat_t in feature_type_
+        ]
+    )
+
+    return np.concatenate(feat_coord), np.hstack(feat_type)
+
+
+def haar_like_feature(
+    int_image, r, c, width, height, feature_type=None, feature_coord=None
+):
+    """Compute the Haar-like features for a region of interest (ROI) of an
+    integral image.
+
+    Haar-like features have been successfully used for image classification and
+    object detection [1]_. It has been used for real-time face detection
+    algorithm proposed in [2]_.
+
+    Parameters
+    ----------
+    int_image : (M, N) ndarray
+        Integral image for which the features need to be computed.
+    r : int
+        Row-coordinate of top left corner of the detection window.
+    c : int
+        Column-coordinate of top left corner of the detection window.
+    width : int
+        Width of the detection window.
+    height : int
+        Height of the detection window.
+    feature_type : str or list of str or None, optional
+        The type of feature to consider:
+
+        - 'type-2-x': 2 rectangles varying along the x axis;
+        - 'type-2-y': 2 rectangles varying along the y axis;
+        - 'type-3-x': 3 rectangles varying along the x axis;
+        - 'type-3-y': 3 rectangles varying along the y axis;
+        - 'type-4': 4 rectangles varying along x and y axis.
+
+        By default all features are extracted.
+
+        If using with `feature_coord`, it should correspond to the feature
+        type of each associated coordinate feature.
+    feature_coord : ndarray of list of tuples or None, optional
+        The array of coordinates to be extracted. This is useful when you want
+        to recompute only a subset of features. In this case `feature_type`
+        needs to be an array containing the type of each feature, as returned
+        by :func:`haar_like_feature_coord`. By default, all coordinates are
+        computed.
+
+    Returns
+    -------
+    haar_features : (n_features,) ndarray of int or float
+        Resulting Haar-like features. Each value is equal to the subtraction of
+        sums of the positive and negative rectangles. The data type depends of
+        the data type of `int_image`: `int` when the data type of `int_image`
+        is `uint` or `int` and `float` when the data type of `int_image` is
+        `float`.
+
+    Notes
+    -----
+    When extracting those features in parallel, be aware that the choice of the
+    backend (i.e. multiprocessing vs threading) will have an impact on the
+    performance. The rule of thumb is as follows: use multiprocessing when
+    extracting features for all possible ROI in an image; use threading when
+    extracting the feature at specific location for a limited number of ROIs.
+    Refer to the example
+    :ref:`sphx_glr_auto_examples_applications_plot_haar_extraction_selection_classification.py`
+    for more insights.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.transform import integral_image
+    >>> from skimage.feature import haar_like_feature
+    >>> img = np.ones((5, 5), dtype=np.uint8)
+    >>> img_ii = integral_image(img)
+    >>> feature = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-3-x')
+    >>> feature
+    array([-1, -2, -3, -4, -5, -1, -2, -3, -4, -5, -1, -2, -3, -4, -5, -1, -2,
+           -3, -4, -1, -2, -3, -4, -1, -2, -3, -4, -1, -2, -3, -1, -2, -3, -1,
+           -2, -3, -1, -2, -1, -2, -1, -2, -1, -1, -1])
+
+    You can compute the feature for some pre-computed coordinates.
+
+    >>> from skimage.feature import haar_like_feature_coord
+    >>> feature_coord, feature_type = zip(
+    ...     *[haar_like_feature_coord(5, 5, feat_t)
+    ...       for feat_t in ('type-2-x', 'type-3-x')])
+    >>> # only select one feature over two
+    >>> feature_coord = np.concatenate([x[::2] for x in feature_coord])
+    >>> feature_type = np.concatenate([x[::2] for x in feature_type])
+    >>> feature = haar_like_feature(img_ii, 0, 0, 5, 5,
+    ...                             feature_type=feature_type,
+    ...                             feature_coord=feature_coord)
+    >>> feature
+    array([ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+            0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+            0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1, -3, -5, -2, -4, -1,
+           -3, -5, -2, -4, -2, -4, -2, -4, -2, -1, -3, -2, -1, -1, -1, -1, -1])
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Haar-like_feature
+    .. [2] Oren, M., Papageorgiou, C., Sinha, P., Osuna, E., & Poggio, T.
+           (1997, June). Pedestrian detection using wavelet templates.
+           In Computer Vision and Pattern Recognition, 1997. Proceedings.,
+           1997 IEEE Computer Society Conference on (pp. 193-199). IEEE.
+           http://tinyurl.com/y6ulxfta
+           :DOI:`10.1109/CVPR.1997.609319`
+    .. [3] Viola, Paul, and Michael J. Jones. "Robust real-time face
+           detection." International journal of computer vision 57.2
+           (2004): 137-154.
+           https://www.merl.com/publications/docs/TR2004-043.pdf
+           :DOI:`10.1109/CVPR.2001.990517`
+
+    """
+    if feature_coord is None:
+        feature_type_ = _validate_feature_type(feature_type)
+
+        return np.hstack(
+            list(
+                chain.from_iterable(
+                    haar_like_feature_wrapper(
+                        int_image, r, c, width, height, feat_t, feature_coord
+                    )
+                    for feat_t in feature_type_
+                )
+            )
+        )
+    else:
+        if feature_coord.shape[0] != feature_type.shape[0]:
+            raise ValueError(
+                "Inconsistent size between feature coordinates" "and feature types."
+            )
+
+        mask_feature = [feature_type == feat_t for feat_t in FEATURE_TYPE]
+        haar_feature_idx, haar_feature = zip(
+            *[
+                (
+                    np.flatnonzero(mask),
+                    haar_like_feature_wrapper(
+                        int_image, r, c, width, height, feat_t, feature_coord[mask]
+                    ),
+                )
+                for mask, feat_t in zip(mask_feature, FEATURE_TYPE)
+                if np.count_nonzero(mask)
+            ]
+        )
+
+        haar_feature_idx = np.concatenate(haar_feature_idx)
+        haar_feature = np.concatenate(haar_feature)
+
+        haar_feature[haar_feature_idx] = haar_feature.copy()
+        return haar_feature
+
+
+def draw_haar_like_feature(
+    image,
+    r,
+    c,
+    width,
+    height,
+    feature_coord,
+    color_positive_block=(1.0, 0.0, 0.0),
+    color_negative_block=(0.0, 1.0, 0.0),
+    alpha=0.5,
+    max_n_features=None,
+    rng=None,
+):
+    """Visualization of Haar-like features.
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        The region of an integral image for which the features need to be
+        computed.
+    r : int
+        Row-coordinate of top left corner of the detection window.
+    c : int
+        Column-coordinate of top left corner of the detection window.
+    width : int
+        Width of the detection window.
+    height : int
+        Height of the detection window.
+    feature_coord : ndarray of list of tuples or None, optional
+        The array of coordinates to be extracted. This is useful when you want
+        to recompute only a subset of features. In this case `feature_type`
+        needs to be an array containing the type of each feature, as returned
+        by :func:`haar_like_feature_coord`. By default, all coordinates are
+        computed.
+    color_positive_block : tuple of 3 floats
+        Floats specifying the color for the positive block. Corresponding
+        values define (R, G, B) values. Default value is red (1, 0, 0).
+    color_negative_block : tuple of 3 floats
+        Floats specifying the color for the negative block Corresponding values
+        define (R, G, B) values. Default value is blue (0, 1, 0).
+    alpha : float
+        Value in the range [0, 1] that specifies opacity of visualization. 1 -
+        fully transparent, 0 - opaque.
+    max_n_features : int, default=None
+        The maximum number of features to be returned.
+        By default, all features are returned.
+    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 when generating a set of features smaller than
+        the total number of available features.
+
+    Returns
+    -------
+    features : (M, N), ndarray
+        An image in which the different features will be added.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.feature import haar_like_feature_coord
+    >>> from skimage.feature import draw_haar_like_feature
+    >>> feature_coord, _ = haar_like_feature_coord(2, 2, 'type-4')
+    >>> image = draw_haar_like_feature(np.zeros((2, 2)),
+    ...                                0, 0, 2, 2,
+    ...                                feature_coord,
+    ...                                max_n_features=1)
+    >>> image
+    array([[[0. , 0.5, 0. ],
+            [0.5, 0. , 0. ]],
+    <BLANKLINE>
+           [[0.5, 0. , 0. ],
+            [0. , 0.5, 0. ]]])
+
+    """
+    rng = np.random.default_rng(rng)
+    color_positive_block = np.asarray(color_positive_block, dtype=np.float64)
+    color_negative_block = np.asarray(color_negative_block, dtype=np.float64)
+
+    if max_n_features is None:
+        feature_coord_ = feature_coord
+    else:
+        feature_coord_ = rng.choice(feature_coord, size=max_n_features, replace=False)
+
+    output = np.copy(image)
+    if len(image.shape) < 3:
+        output = gray2rgb(image)
+    output = img_as_float(output)
+
+    for coord in feature_coord_:
+        for idx_rect, rect in enumerate(coord):
+            coord_start, coord_end = rect
+            coord_start = tuple(map(add, coord_start, [r, c]))
+            coord_end = tuple(map(add, coord_end, [r, c]))
+            rr, cc = rectangle(coord_start, coord_end)
+
+            if ((idx_rect + 1) % 2) == 0:
+                new_value = (1 - alpha) * output[rr, cc] + alpha * color_positive_block
+            else:
+                new_value = (1 - alpha) * output[rr, cc] + alpha * color_negative_block
+            output[rr, cc] = new_value
+
+    return output

envs/kitoverlay/skimage/feature/match.py

@@ -0,0 +1,103 @@
+import numpy as np
+from scipy.spatial.distance import cdist
+
+
+def match_descriptors(
+    descriptors1,
+    descriptors2,
+    metric=None,
+    p=2,
+    max_distance=np.inf,
+    cross_check=True,
+    max_ratio=1.0,
+):
+    """Brute-force matching of descriptors.
+
+    For each descriptor in the first set this matcher finds the closest
+    descriptor in the second set (and vice-versa in the case of enabled
+    cross-checking).
+
+    Parameters
+    ----------
+    descriptors1 : (M, P) array
+        Descriptors of size P about M keypoints in the first image.
+    descriptors2 : (N, P) array
+        Descriptors of size P about N keypoints in the second image.
+    metric : {'euclidean', 'cityblock', 'minkowski', 'hamming', ...} , optional
+        The metric to compute the distance between two descriptors. See
+        `scipy.spatial.distance.cdist` for all possible types. The hamming
+        distance should be used for binary descriptors. By default the L2-norm
+        is used for all descriptors of dtype float or double and the Hamming
+        distance is used for binary descriptors automatically.
+    p : int, optional
+        The p-norm to apply for ``metric='minkowski'``.
+    max_distance : float, optional
+        Maximum allowed distance between descriptors of two keypoints
+        in separate images to be regarded as a match.
+    cross_check : bool, optional
+        If True, the matched keypoints are returned after cross checking i.e. a
+        matched pair (keypoint1, keypoint2) is returned if keypoint2 is the
+        best match for keypoint1 in second image and keypoint1 is the best
+        match for keypoint2 in first image.
+    max_ratio : float, optional
+        Maximum ratio of distances between first and second closest descriptor
+        in the second set of descriptors. This threshold is useful to filter
+        ambiguous matches between the two descriptor sets. The choice of this
+        value depends on the statistics of the chosen descriptor, e.g.,
+        for SIFT descriptors a value of 0.8 is usually chosen, see
+        D.G. Lowe, "Distinctive Image Features from Scale-Invariant Keypoints",
+        International Journal of Computer Vision, 2004.
+
+    Returns
+    -------
+    matches : (Q, 2) array
+        Indices of corresponding matches in first and second set of
+        descriptors, where ``matches[:, 0]`` denote the indices in the first
+        and ``matches[:, 1]`` the indices in the second set of descriptors.
+
+    """
+
+    if descriptors1.shape[1] != descriptors2.shape[1]:
+        raise ValueError("Descriptor length must equal.")
+
+    if metric is None:
+        if np.issubdtype(descriptors1.dtype, bool):
+            metric = 'hamming'
+        else:
+            metric = 'euclidean'
+
+    kwargs = {}
+    # Scipy raises an error if p is passed as an extra argument when it isn't
+    # necessary for the chosen metric.
+    if metric == 'minkowski':
+        kwargs['p'] = p
+    distances = cdist(descriptors1, descriptors2, metric=metric, **kwargs)
+
+    indices1 = np.arange(descriptors1.shape[0])
+    indices2 = np.argmin(distances, axis=1)
+
+    if cross_check:
+        matches1 = np.argmin(distances, axis=0)
+        mask = indices1 == matches1[indices2]
+        indices1 = indices1[mask]
+        indices2 = indices2[mask]
+
+    if max_distance < np.inf:
+        mask = distances[indices1, indices2] < max_distance
+        indices1 = indices1[mask]
+        indices2 = indices2[mask]
+
+    if max_ratio < 1.0:
+        best_distances = distances[indices1, indices2]
+        distances[indices1, indices2] = np.inf
+        second_best_indices2 = np.argmin(distances[indices1], axis=1)
+        second_best_distances = distances[indices1, second_best_indices2]
+        second_best_distances[second_best_distances == 0] = np.finfo(np.float64).eps
+        ratio = best_distances / second_best_distances
+        mask = ratio < max_ratio
+        indices1 = indices1[mask]
+        indices2 = indices2[mask]
+
+    matches = np.column_stack((indices1, indices2))
+
+    return matches

envs/kitoverlay/skimage/feature/orb.py

@@ -0,0 +1,366 @@
+import numpy as np
+
+from ..feature.util import (
+    FeatureDetector,
+    DescriptorExtractor,
+    _mask_border_keypoints,
+    _prepare_grayscale_input_2D,
+)
+
+from .corner import corner_fast, corner_orientations, corner_peaks, corner_harris
+from ..transform import pyramid_gaussian
+from .._shared.utils import check_nD
+from .._shared.compat import NP_COPY_IF_NEEDED
+
+from .orb_cy import _orb_loop
+
+
+OFAST_MASK = np.zeros((31, 31))
+OFAST_UMAX = [15, 15, 15, 15, 14, 14, 14, 13, 13, 12, 11, 10, 9, 8, 6, 3]
+for i in range(-15, 16):
+    for j in range(-OFAST_UMAX[abs(i)], OFAST_UMAX[abs(i)] + 1):
+        OFAST_MASK[15 + j, 15 + i] = 1
+
+
+class ORB(FeatureDetector, DescriptorExtractor):
+    """Oriented FAST and rotated BRIEF feature detector and binary descriptor
+    extractor.
+
+    Parameters
+    ----------
+    n_keypoints : int, optional
+        Number of keypoints to be returned. The function will return the best
+        `n_keypoints` according to the Harris corner response if more than
+        `n_keypoints` are detected. If not, then all the detected keypoints
+        are returned.
+    fast_n : int, optional
+        The `n` parameter in `skimage.feature.corner_fast`. Minimum number of
+        consecutive pixels out of 16 pixels on the circle that should all be
+        either brighter or darker w.r.t test-pixel. A point c on the circle is
+        darker w.r.t test pixel p if ``Ic < Ip - threshold`` and brighter if
+        ``Ic > Ip + threshold``. Also stands for the n in ``FAST-n`` corner
+        detector.
+    fast_threshold : float, optional
+        The ``threshold`` parameter in ``feature.corner_fast``. Threshold used
+        to decide whether the pixels on the circle are brighter, darker or
+        similar w.r.t. the test pixel. Decrease the threshold when more
+        corners are desired and vice-versa.
+    harris_k : float, optional
+        The `k` parameter in `skimage.feature.corner_harris`. Sensitivity
+        factor to separate corners from edges, typically in range ``[0, 0.2]``.
+        Small values of `k` result in detection of sharp corners.
+    downscale : float, optional
+        Downscale factor for the image pyramid. Default value 1.2 is chosen so
+        that there are more dense scales which enable robust scale invariance
+        for a subsequent feature description.
+    n_scales : int, optional
+        Maximum number of scales from the bottom of the image pyramid to
+        extract the features from.
+
+    Attributes
+    ----------
+    keypoints : (N, 2) array
+        Keypoint coordinates as ``(row, col)``.
+    scales : (N,) array
+        Corresponding scales.
+    orientations : (N,) array
+        Corresponding orientations in radians.
+    responses : (N,) array
+        Corresponding Harris corner responses.
+    descriptors : (Q, `descriptor_size`) array of dtype bool
+        2D array of binary descriptors of size `descriptor_size` for Q
+        keypoints after filtering out border keypoints with value at an
+        index ``(i, j)`` either being ``True`` or ``False`` representing
+        the outcome of the intensity comparison for i-th keypoint on j-th
+        decision pixel-pair. It is ``Q == np.sum(mask)``.
+
+    References
+    ----------
+    .. [1] Ethan Rublee, Vincent Rabaud, Kurt Konolige and Gary Bradski
+          "ORB: An efficient alternative to SIFT and SURF"
+          http://www.vision.cs.chubu.ac.jp/CV-R/pdf/Rublee_iccv2011.pdf
+
+    Examples
+    --------
+    >>> from skimage.feature import ORB, match_descriptors
+    >>> img1 = np.zeros((100, 100))
+    >>> img2 = np.zeros_like(img1)
+    >>> rng = np.random.default_rng(19481137)  # do not copy this value
+    >>> square = rng.random((20, 20))
+    >>> img1[40:60, 40:60] = square
+    >>> img2[53:73, 53:73] = square
+    >>> detector_extractor1 = ORB(n_keypoints=5)
+    >>> detector_extractor2 = ORB(n_keypoints=5)
+    >>> detector_extractor1.detect_and_extract(img1)
+    >>> detector_extractor2.detect_and_extract(img2)
+    >>> matches = match_descriptors(detector_extractor1.descriptors,
+    ...                             detector_extractor2.descriptors)
+    >>> matches
+    array([[0, 0],
+           [1, 1],
+           [2, 2],
+           [3, 4],
+           [4, 3]])
+    >>> detector_extractor1.keypoints[matches[:, 0]]
+    array([[59. , 59. ],
+           [40. , 40. ],
+           [57. , 40. ],
+           [46. , 58. ],
+           [58.8, 58.8]])
+    >>> detector_extractor2.keypoints[matches[:, 1]]
+    array([[72., 72.],
+           [53., 53.],
+           [70., 53.],
+           [59., 71.],
+           [72., 72.]])
+
+    """
+
+    def __init__(
+        self,
+        downscale=1.2,
+        n_scales=8,
+        n_keypoints=500,
+        fast_n=9,
+        fast_threshold=0.08,
+        harris_k=0.04,
+    ):
+        self.downscale = downscale
+        self.n_scales = n_scales
+        self.n_keypoints = n_keypoints
+        self.fast_n = fast_n
+        self.fast_threshold = fast_threshold
+        self.harris_k = harris_k
+
+        self.keypoints = None
+        self.scales = None
+        self.responses = None
+        self.orientations = None
+        self.descriptors = None
+
+    def _build_pyramid(self, image):
+        image = _prepare_grayscale_input_2D(image)
+        return list(
+            pyramid_gaussian(
+                image, self.n_scales - 1, self.downscale, channel_axis=None
+            )
+        )
+
+    def _detect_octave(self, octave_image):
+        dtype = octave_image.dtype
+        # Extract keypoints for current octave
+        fast_response = corner_fast(octave_image, self.fast_n, self.fast_threshold)
+        keypoints = corner_peaks(fast_response, min_distance=1)
+
+        if len(keypoints) == 0:
+            return (
+                np.zeros((0, 2), dtype=dtype),
+                np.zeros((0,), dtype=dtype),
+                np.zeros((0,), dtype=dtype),
+            )
+
+        mask = _mask_border_keypoints(octave_image.shape, keypoints, distance=16)
+        keypoints = keypoints[mask]
+
+        orientations = corner_orientations(octave_image, keypoints, OFAST_MASK)
+
+        harris_response = corner_harris(octave_image, method='k', k=self.harris_k)
+        responses = harris_response[keypoints[:, 0], keypoints[:, 1]]
+
+        return keypoints, orientations, responses
+
+    def detect(self, image):
+        """Detect oriented FAST keypoints along with the corresponding scale.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+
+        """
+        check_nD(image, 2)
+
+        pyramid = self._build_pyramid(image)
+
+        keypoints_list = []
+        orientations_list = []
+        scales_list = []
+        responses_list = []
+
+        for octave in range(len(pyramid)):
+            octave_image = np.ascontiguousarray(pyramid[octave])
+
+            if np.squeeze(octave_image).ndim < 2:
+                # No further keypoints can be detected if the image is not really 2d
+                break
+
+            keypoints, orientations, responses = self._detect_octave(octave_image)
+
+            keypoints_list.append(keypoints * self.downscale**octave)
+            orientations_list.append(orientations)
+            scales_list.append(
+                np.full(
+                    keypoints.shape[0],
+                    self.downscale**octave,
+                    dtype=octave_image.dtype,
+                )
+            )
+            responses_list.append(responses)
+
+        keypoints = np.vstack(keypoints_list)
+        orientations = np.hstack(orientations_list)
+        scales = np.hstack(scales_list)
+        responses = np.hstack(responses_list)
+
+        if keypoints.shape[0] < self.n_keypoints:
+            self.keypoints = keypoints
+            self.scales = scales
+            self.orientations = orientations
+            self.responses = responses
+        else:
+            # Choose best n_keypoints according to Harris corner response
+            best_indices = responses.argsort()[::-1][: self.n_keypoints]
+            self.keypoints = keypoints[best_indices]
+            self.scales = scales[best_indices]
+            self.orientations = orientations[best_indices]
+            self.responses = responses[best_indices]
+
+    def _extract_octave(self, octave_image, keypoints, orientations):
+        mask = _mask_border_keypoints(octave_image.shape, keypoints, distance=20)
+        keypoints = np.array(
+            keypoints[mask], dtype=np.intp, order='C', copy=NP_COPY_IF_NEEDED
+        )
+        orientations = np.array(orientations[mask], order='C', copy=False)
+
+        descriptors = _orb_loop(octave_image, keypoints, orientations)
+
+        return descriptors, mask
+
+    def extract(self, image, keypoints, scales, orientations):
+        """Extract rBRIEF binary descriptors for given keypoints in image.
+
+        Note that the keypoints must be extracted using the same `downscale`
+        and `n_scales` parameters. Additionally, if you want to extract both
+        keypoints and descriptors you should use the faster
+        `detect_and_extract`.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+        keypoints : (N, 2) array
+            Keypoint coordinates as ``(row, col)``.
+        scales : (N,) array
+            Corresponding scales.
+        orientations : (N,) array
+            Corresponding orientations in radians.
+
+        """
+        check_nD(image, 2)
+
+        pyramid = self._build_pyramid(image)
+
+        descriptors_list = []
+        mask_list = []
+
+        # Determine octaves from scales
+        octaves = (np.log(scales) / np.log(self.downscale)).astype(np.intp)
+
+        for octave in range(len(pyramid)):
+            # Mask for all keypoints in current octave
+            octave_mask = octaves == octave
+
+            if np.sum(octave_mask) > 0:
+                octave_image = np.ascontiguousarray(pyramid[octave])
+
+                octave_keypoints = keypoints[octave_mask]
+                octave_keypoints /= self.downscale**octave
+                octave_orientations = orientations[octave_mask]
+
+                descriptors, mask = self._extract_octave(
+                    octave_image, octave_keypoints, octave_orientations
+                )
+
+                descriptors_list.append(descriptors)
+                mask_list.append(mask)
+
+        self.descriptors = np.vstack(descriptors_list).view(bool)
+        self.mask_ = np.hstack(mask_list)
+
+    def detect_and_extract(self, image):
+        """Detect oriented FAST keypoints and extract rBRIEF descriptors.
+
+        Note that this is faster than first calling `detect` and then
+        `extract`.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+
+        """
+        check_nD(image, 2)
+
+        pyramid = self._build_pyramid(image)
+
+        keypoints_list = []
+        responses_list = []
+        scales_list = []
+        orientations_list = []
+        descriptors_list = []
+
+        for octave in range(len(pyramid)):
+            octave_image = np.ascontiguousarray(pyramid[octave])
+
+            if np.squeeze(octave_image).ndim < 2:
+                # No further keypoints can be detected if the image is not really 2d
+                break
+
+            keypoints, orientations, responses = self._detect_octave(octave_image)
+
+            if len(keypoints) == 0:
+                keypoints_list.append(keypoints)
+                responses_list.append(responses)
+                descriptors_list.append(np.zeros((0, 256), dtype=bool))
+                continue
+
+            descriptors, mask = self._extract_octave(
+                octave_image, keypoints, orientations
+            )
+
+            scaled_keypoints = keypoints[mask] * self.downscale**octave
+            keypoints_list.append(scaled_keypoints)
+            responses_list.append(responses[mask])
+            orientations_list.append(orientations[mask])
+            scales_list.append(
+                self.downscale**octave
+                * np.ones(scaled_keypoints.shape[0], dtype=np.intp)
+            )
+            descriptors_list.append(descriptors)
+
+        if len(scales_list) == 0:
+            raise RuntimeError(
+                "ORB found no features. Try passing in an image containing "
+                "greater intensity contrasts between adjacent pixels."
+            )
+
+        keypoints = np.vstack(keypoints_list)
+        responses = np.hstack(responses_list)
+        scales = np.hstack(scales_list)
+        orientations = np.hstack(orientations_list)
+        descriptors = np.vstack(descriptors_list).view(bool)
+
+        if keypoints.shape[0] < self.n_keypoints:
+            self.keypoints = keypoints
+            self.scales = scales
+            self.orientations = orientations
+            self.responses = responses
+            self.descriptors = descriptors
+        else:
+            # Choose best n_keypoints according to Harris corner response
+            best_indices = responses.argsort()[::-1][: self.n_keypoints]
+            self.keypoints = keypoints[best_indices]
+            self.scales = scales[best_indices]
+            self.orientations = orientations[best_indices]
+            self.responses = responses[best_indices]
+            self.descriptors = descriptors[best_indices]

envs/kitoverlay/skimage/feature/orb_descriptor_positions.txt

@@ -0,0 +1,256 @@
+8 -3 9 5
+4 2 7 -12
+-11 9 -8 2
+7 -12 12 -13
+2 -13 2 12
+1 -7 1 6
+-2 -10 -2 -4
+-13 -13 -11 -8
+-13 -3 -12 -9
+10 4 11 9
+-13 -8 -8 -9
+-11 7 -9 12
+7 7 12 6
+-4 -5 -3 0
+-13 2 -12 -3
+-9 0 -7 5
+12 -6 12 -1
+-3 6 -2 12
+-6 -13 -4 -8
+11 -13 12 -8
+4 7 5 1
+5 -3 10 -3
+3 -7 6 12
+-8 -7 -6 -2
+-2 11 -1 -10
+-13 12 -8 10
+-7 3 -5 -3
+-4 2 -3 7
+-10 -12 -6 11
+5 -12 6 -7
+5 -6 7 -1
+1 0 4 -5
+9 11 11 -13
+4 7 4 12
+2 -1 4 4
+-4 -12 -2 7
+-8 -5 -7 -10
+4 11 9 12
+0 -8 1 -13
+-13 -2 -8 2
+-3 -2 -2 3
+-6 9 -4 -9
+8 12 10 7
+0 9 1 3
+7 -5 11 -10
+-13 -6 -11 0
+10 7 12 1
+-6 -3 -6 12
+10 -9 12 -4
+-13 8 -8 -12
+-13 0 -8 -4
+3 3 7 8
+5 7 10 -7
+-1 7 1 -12
+3 -10 5 6
+2 -4 3 -10
+-13 0 -13 5
+-13 -7 -12 12
+-13 3 -11 8
+-7 12 -4 7
+6 -10 12 8
+-9 -1 -7 -6
+-2 -5 0 12
+-12 5 -7 5
+3 -10 8 -13
+-7 -7 -4 5
+-3 -2 -1 -7
+2 9 5 -11
+-11 -13 -5 -13
+-1 6 0 -1
+5 -3 5 2
+-4 -13 -4 12
+-9 -6 -9 6
+-12 -10 -8 -4
+10 2 12 -3
+7 12 12 12
+-7 -13 -6 5
+-4 9 -3 4
+7 -1 12 2
+-7 6 -5 1
+-13 11 -12 5
+-3 7 -2 -6
+7 -8 12 -7
+-13 -7 -11 -12
+1 -3 12 12
+2 -6 3 0
+-4 3 -2 -13
+-1 -13 1 9
+7 1 8 -6
+1 -1 3 12
+9 1 12 6
+-1 -9 -1 3
+-13 -13 -10 5
+7 7 10 12
+12 -5 12 9
+6 3 7 11
+5 -13 6 10
+2 -12 2 3
+3 8 4 -6
+2 6 12 -13
+9 -12 10 3
+-8 4 -7 9
+-11 12 -4 -6
+1 12 2 -8
+6 -9 7 -4
+2 3 3 -2
+6 3 11 0
+3 -3 8 -8
+7 8 9 3
+-11 -5 -6 -4
+-10 11 -5 10
+-5 -8 -3 12
+-10 5 -9 0
+8 -1 12 -6
+4 -6 6 -11
+-10 12 -8 7
+4 -2 6 7
+-2 0 -2 12
+-5 -8 -5 2
+7 -6 10 12
+-9 -13 -8 -8
+-5 -13 -5 -2
+8 -8 9 -13
+-9 -11 -9 0
+1 -8 1 -2
+7 -4 9 1
+-2 1 -1 -4
+11 -6 12 -11
+-12 -9 -6 4
+3 7 7 12
+5 5 10 8
+0 -4 2 8
+-9 12 -5 -13
+0 7 2 12
+-1 2 1 7
+5 11 7 -9
+3 5 6 -8
+-13 -4 -8 9
+-5 9 -3 -3
+-4 -7 -3 -12
+6 5 8 0
+-7 6 -6 12
+-13 6 -5 -2
+1 -10 3 10
+4 1 8 -4
+-2 -2 2 -13
+2 -12 12 12
+-2 -13 0 -6
+4 1 9 3
+-6 -10 -3 -5
+-3 -13 -1 1
+7 5 12 -11
+4 -2 5 -7
+-13 9 -9 -5
+7 1 8 6
+7 -8 7 6
+-7 -4 -7 1
+-8 11 -7 -8
+-13 6 -12 -8
+2 4 3 9
+10 -5 12 3
+-6 -5 -6 7
+8 -3 9 -8
+2 -12 2 8
+-11 -2 -10 3
+-12 -13 -7 -9
+-11 0 -10 -5
+5 -3 11 8
+-2 -13 -1 12
+-1 -8 0 9
+-13 -11 -12 -5
+-10 -2 -10 11
+-3 9 -2 -13
+2 -3 3 2
+-9 -13 -4 0
+-4 6 -3 -10
+-4 12 -2 -7
+-6 -11 -4 9
+6 -3 6 11
+-13 11 -5 5
+11 11 12 6
+7 -5 12 -2
+-1 12 0 7
+-4 -8 -3 -2
+-7 1 -6 7
+-13 -12 -8 -13
+-7 -2 -6 -8
+-8 5 -6 -9
+-5 -1 -4 5
+-13 7 -8 10
+1 5 5 -13
+1 0 10 -13
+9 12 10 -1
+5 -8 10 -9
+-1 11 1 -13
+-9 -3 -6 2
+-1 -10 1 12
+-13 1 -8 -10
+8 -11 10 -6
+2 -13 3 -6
+7 -13 12 -9
+-10 -10 -5 -7
+-10 -8 -8 -13
+4 -6 8 5
+3 12 8 -13
+-4 2 -3 -3
+5 -13 10 -12
+4 -13 5 -1
+-9 9 -4 3
+0 3 3 -9
+-12 1 -6 1
+3 2 4 -8
+-10 -10 -10 9
+8 -13 12 12
+-8 -12 -6 -5
+2 2 3 7
+10 6 11 -8
+6 8 8 -12
+-7 10 -6 5
+-3 -9 -3 9
+-1 -13 -1 5
+-3 -7 -3 4
+-8 -2 -8 3
+4 2 12 12
+2 -5 3 11
+6 -9 11 -13
+3 -1 7 12
+11 -1 12 4
+-3 0 -3 6
+4 -11 4 12
+2 -4 2 1
+-10 -6 -8 1
+-13 7 -11 1
+-13 12 -11 -13
+6 0 11 -13
+0 -1 1 4
+-13 3 -9 -2
+-9 8 -6 -3
+-13 -6 -8 -2
+5 -9 8 10
+2 7 3 -9
+-1 -6 -1 -1
+9 5 11 -2
+11 -3 12 -8
+3 0 3 5
+-1 4 0 10
+3 -6 4 5
+-13 0 -10 5
+5 8 12 11
+8 9 9 -6
+7 -4 8 -12
+-10 4 -10 9
+7 3 12 4
+9 -7 10 -2
+7 0 12 -2
+-1 -6 0 -11

envs/kitoverlay/skimage/feature/peak.py

@@ -0,0 +1,420 @@
+from warnings import warn
+
+import numpy as np
+import scipy.ndimage as ndi
+
+from .. import measure
+from .._shared.coord import ensure_spacing
+
+
+def _get_high_intensity_peaks(image, mask, num_peaks, min_distance, p_norm):
+    """
+    Return the highest intensity peak coordinates.
+    """
+    # get coordinates of peaks
+    coord = np.nonzero(mask)
+    intensities = image[coord]
+    # Highest peak first
+    idx_maxsort = np.argsort(-intensities, kind="stable")
+    coord = np.transpose(coord)[idx_maxsort]
+
+    if np.isfinite(num_peaks):
+        max_out = int(num_peaks)
+    else:
+        max_out = None
+
+    if min_distance > 1:
+        coord = ensure_spacing(
+            coord, spacing=min_distance, p_norm=p_norm, max_out=max_out
+        )
+
+    if len(coord) > num_peaks:
+        coord = coord[:num_peaks]
+
+    return coord
+
+
+def _get_peak_mask(image, footprint, threshold, mask=None):
+    """
+    Return the mask containing all peak candidates above thresholds.
+    """
+    if footprint.size == 1 or image.size == 1:
+        return image > threshold
+
+    image_max = ndi.maximum_filter(image, footprint=footprint, mode='nearest')
+
+    out = image == image_max
+
+    # no peak for a trivial image
+    image_is_trivial = np.all(out) if mask is None else np.all(out[mask])
+    if image_is_trivial:
+        out[:] = False
+        if mask is not None:
+            # isolated pixels in masked area are returned as peaks
+            isolated_px = np.logical_xor(mask, ndi.binary_opening(mask))
+            out[isolated_px] = True
+
+    out &= image > threshold
+    return out
+
+
+def _exclude_border(label, border_width):
+    """Set label border values to 0."""
+    # zero out label borders
+    for i, width in enumerate(border_width):
+        if width == 0:
+            continue
+        label[(slice(None),) * i + (slice(None, width),)] = 0
+        label[(slice(None),) * i + (slice(-width, None),)] = 0
+    return label
+
+
+def _get_threshold(image, threshold_abs, threshold_rel):
+    """Return the threshold value according to an absolute and a relative
+    value.
+
+    """
+    threshold = threshold_abs if threshold_abs is not None else image.min()
+
+    if threshold_rel is not None:
+        threshold = max(threshold, threshold_rel * image.max())
+
+    return threshold
+
+
+def _get_excluded_border_width(image, min_distance, exclude_border):
+    """Return border_width values relative to a min_distance if requested."""
+
+    if isinstance(exclude_border, bool):
+        border_width = (min_distance if exclude_border else 0,) * image.ndim
+    elif isinstance(exclude_border, int):
+        if exclude_border < 0:
+            raise ValueError("`exclude_border` cannot be a negative value")
+        border_width = (exclude_border,) * image.ndim
+    elif isinstance(exclude_border, tuple):
+        if len(exclude_border) != image.ndim:
+            raise ValueError(
+                "`exclude_border` should have the same length as the "
+                "dimensionality of the image."
+            )
+        for exclude in exclude_border:
+            if not isinstance(exclude, int):
+                raise ValueError(
+                    "`exclude_border`, when expressed as a tuple, must only "
+                    "contain ints."
+                )
+            if exclude < 0:
+                raise ValueError("`exclude_border` can not be a negative value")
+        border_width = exclude_border
+    else:
+        raise TypeError(
+            "`exclude_border` must be bool, int, or tuple with the same "
+            "length as the dimensionality of the image."
+        )
+
+    return border_width
+
+
+def peak_local_max(
+    image,
+    min_distance=1,
+    threshold_abs=None,
+    threshold_rel=None,
+    exclude_border=True,
+    num_peaks=np.inf,
+    footprint=None,
+    labels=None,
+    num_peaks_per_label=np.inf,
+    p_norm=np.inf,
+):
+    """Find peaks in an image as coordinate list.
+
+    Peaks are the local maxima in a region of `2 * min_distance + 1`
+    (i.e. peaks are separated by at least `min_distance`).
+
+    If both `threshold_abs` and `threshold_rel` are provided, the maximum
+    of the two is chosen as the minimum intensity threshold of peaks.
+
+    .. versionchanged:: 0.18
+        Prior to version 0.18, peaks of the same height within a radius of
+        `min_distance` were all returned, but this could cause unexpected
+        behaviour. From 0.18 onwards, an arbitrary peak within the region is
+        returned. See issue gh-2592.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    min_distance : int, optional
+        The minimal allowed distance separating peaks. To find the
+        maximum number of peaks, use `min_distance=1`.
+    threshold_abs : float or None, optional
+        Minimum intensity of peaks. By default, the absolute threshold is
+        the minimum intensity of the image.
+    threshold_rel : float or None, optional
+        Minimum intensity of peaks, calculated as
+        ``max(image) * threshold_rel``.
+    exclude_border : int, tuple of ints, or bool, optional
+        If positive integer, `exclude_border` excludes peaks from within
+        `exclude_border`-pixels of the border of the image.
+        If tuple of non-negative ints, the length of the tuple must match the
+        input array's dimensionality.  Each element of the tuple will exclude
+        peaks from within `exclude_border`-pixels of the border of the image
+        along that dimension.
+        If True, takes the `min_distance` parameter as value.
+        If zero or False, peaks are identified regardless of their distance
+        from the border.
+    num_peaks : int, optional
+        Maximum number of peaks. When the number of peaks exceeds `num_peaks`,
+        return `num_peaks` peaks based on highest peak intensity.
+    footprint : ndarray of bools, optional
+        If provided, `footprint == 1` represents the local region within which
+        to search for peaks at every point in `image`.
+    labels : ndarray of ints, optional
+        If provided, each unique region `labels == value` represents a unique
+        region to search for peaks. Zero is reserved for background.
+    num_peaks_per_label : int, optional
+        Maximum number of peaks for each label.
+    p_norm : float
+        Which Minkowski p-norm to use. Should be in the range [1, inf].
+        A finite large p may cause a ValueError if overflow can occur.
+        ``inf`` corresponds to the Chebyshev distance and 2 to the
+        Euclidean distance.
+
+    Returns
+    -------
+    output : ndarray
+        The coordinates of the peaks.
+
+    Notes
+    -----
+    The peak local maximum function returns the coordinates of local peaks
+    (maxima) in an image. Internally, a maximum filter is used for finding
+    local maxima. This operation dilates the original image. After comparison
+    of the dilated and original images, this function returns the coordinates
+    of the peaks where the dilated image equals the original image.
+
+    See also
+    --------
+    skimage.feature.corner_peaks
+
+    Examples
+    --------
+    >>> img1 = np.zeros((7, 7))
+    >>> img1[3, 4] = 1
+    >>> img1[3, 2] = 1.5
+    >>> img1
+    array([[0. , 0. , 0. , 0. , 0. , 0. , 0. ],
+           [0. , 0. , 0. , 0. , 0. , 0. , 0. ],
+           [0. , 0. , 0. , 0. , 0. , 0. , 0. ],
+           [0. , 0. , 1.5, 0. , 1. , 0. , 0. ],
+           [0. , 0. , 0. , 0. , 0. , 0. , 0. ],
+           [0. , 0. , 0. , 0. , 0. , 0. , 0. ],
+           [0. , 0. , 0. , 0. , 0. , 0. , 0. ]])
+
+    >>> peak_local_max(img1, min_distance=1)
+    array([[3, 2],
+           [3, 4]])
+
+    >>> peak_local_max(img1, min_distance=2)
+    array([[3, 2]])
+
+    >>> img2 = np.zeros((20, 20, 20))
+    >>> img2[10, 10, 10] = 1
+    >>> img2[15, 15, 15] = 1
+    >>> peak_idx = peak_local_max(img2, exclude_border=0)
+    >>> peak_idx
+    array([[10, 10, 10],
+           [15, 15, 15]])
+
+    >>> peak_mask = np.zeros_like(img2, dtype=bool)
+    >>> peak_mask[tuple(peak_idx.T)] = True
+    >>> np.argwhere(peak_mask)
+    array([[10, 10, 10],
+           [15, 15, 15]])
+
+    """
+    if (footprint is None or footprint.size == 1) and min_distance < 1:
+        warn(
+            "When min_distance < 1, peak_local_max acts as finding "
+            "image > max(threshold_abs, threshold_rel * max(image)).",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+    border_width = _get_excluded_border_width(image, min_distance, exclude_border)
+
+    threshold = _get_threshold(image, threshold_abs, threshold_rel)
+
+    if footprint is None:
+        size = 2 * min_distance + 1
+        footprint = np.ones((size,) * image.ndim, dtype=bool)
+    else:
+        footprint = np.asarray(footprint)
+
+    if labels is None:
+        # Non maximum filter
+        mask = _get_peak_mask(image, footprint, threshold)
+
+        mask = _exclude_border(mask, border_width)
+
+        # Select highest intensities (num_peaks)
+        coordinates = _get_high_intensity_peaks(
+            image, mask, num_peaks, min_distance, p_norm
+        )
+
+    else:
+        _labels = _exclude_border(labels.astype(int, casting="safe"), border_width)
+
+        if np.issubdtype(image.dtype, np.floating):
+            bg_val = np.finfo(image.dtype).min
+        else:
+            bg_val = np.iinfo(image.dtype).min
+
+        # For each label, extract a smaller image enclosing the object of
+        # interest, identify num_peaks_per_label peaks
+        labels_peak_coord = []
+
+        for label_idx, roi in enumerate(ndi.find_objects(_labels)):
+            if roi is None:
+                continue
+
+            # Get roi mask
+            label_mask = labels[roi] == label_idx + 1
+            # Extract image roi
+            img_object = image[roi].copy()
+            # Ensure masked values don't affect roi's local peaks
+            img_object[np.logical_not(label_mask)] = bg_val
+
+            mask = _get_peak_mask(img_object, footprint, threshold, label_mask)
+
+            coordinates = _get_high_intensity_peaks(
+                img_object, mask, num_peaks_per_label, min_distance, p_norm
+            )
+
+            # transform coordinates in global image indices space
+            for idx, s in enumerate(roi):
+                coordinates[:, idx] += s.start
+
+            labels_peak_coord.append(coordinates)
+
+        if labels_peak_coord:
+            coordinates = np.vstack(labels_peak_coord)
+        else:
+            coordinates = np.empty((0, 2), dtype=int)
+
+        if len(coordinates) > num_peaks:
+            out = np.zeros_like(image, dtype=bool)
+            out[tuple(coordinates.T)] = True
+            coordinates = _get_high_intensity_peaks(
+                image, out, num_peaks, min_distance, p_norm
+            )
+
+    return coordinates
+
+
+def _prominent_peaks(
+    image, min_xdistance=1, min_ydistance=1, threshold=None, num_peaks=np.inf
+):
+    """Return peaks with non-maximum suppression.
+
+    Identifies most prominent features separated by certain distances.
+    Non-maximum suppression with different sizes is applied separately
+    in the first and second dimension of the image to identify peaks.
+
+    Parameters
+    ----------
+    image : (M, N) ndarray
+        Input image.
+    min_xdistance : int
+        Minimum distance separating features in the x dimension.
+    min_ydistance : int
+        Minimum distance separating features in the y dimension.
+    threshold : float
+        Minimum intensity of peaks. Default is `0.5 * max(image)`.
+    num_peaks : int
+        Maximum number of peaks. When the number of peaks exceeds `num_peaks`,
+        return `num_peaks` coordinates based on peak intensity.
+
+    Returns
+    -------
+    intensity, xcoords, ycoords : tuple of array
+        Peak intensity values, x and y indices.
+    """
+
+    img = image.copy()
+    rows, cols = img.shape
+
+    if threshold is None:
+        threshold = 0.5 * np.max(img)
+
+    ycoords_size = 2 * min_ydistance + 1
+    xcoords_size = 2 * min_xdistance + 1
+    img_max = ndi.maximum_filter1d(
+        img, size=ycoords_size, axis=0, mode='constant', cval=0
+    )
+    img_max = ndi.maximum_filter1d(
+        img_max, size=xcoords_size, axis=1, mode='constant', cval=0
+    )
+    mask = img == img_max
+    img *= mask
+    img_t = img > threshold
+
+    label_img = measure.label(img_t)
+    props = measure.regionprops(label_img, img_max)
+
+    # Sort the list of peaks by intensity, not left-right, so larger peaks
+    # in Hough space cannot be arbitrarily suppressed by smaller neighbors
+    props = sorted(props, key=lambda x: x.intensity_max)[::-1]
+    coords = np.array([np.round(p.centroid) for p in props], dtype=int)
+
+    img_peaks = []
+    ycoords_peaks = []
+    xcoords_peaks = []
+
+    # relative coordinate grid for local neighborhood suppression
+    ycoords_ext, xcoords_ext = np.mgrid[
+        -min_ydistance : min_ydistance + 1, -min_xdistance : min_xdistance + 1
+    ]
+
+    for ycoords_idx, xcoords_idx in coords:
+        accum = img_max[ycoords_idx, xcoords_idx]
+        if accum > threshold:
+            # absolute coordinate grid for local neighborhood suppression
+            ycoords_nh = ycoords_idx + ycoords_ext
+            xcoords_nh = xcoords_idx + xcoords_ext
+
+            # no reflection for distance neighborhood
+            ycoords_in = np.logical_and(ycoords_nh > 0, ycoords_nh < rows)
+            ycoords_nh = ycoords_nh[ycoords_in]
+            xcoords_nh = xcoords_nh[ycoords_in]
+
+            # reflect xcoords and assume xcoords are continuous,
+            # e.g. for angles:
+            # (..., 88, 89, -90, -89, ..., 89, -90, -89, ...)
+            xcoords_low = xcoords_nh < 0
+            ycoords_nh[xcoords_low] = rows - ycoords_nh[xcoords_low]
+            xcoords_nh[xcoords_low] += cols
+            xcoords_high = xcoords_nh >= cols
+            ycoords_nh[xcoords_high] = rows - ycoords_nh[xcoords_high]
+            xcoords_nh[xcoords_high] -= cols
+
+            # suppress neighborhood
+            img_max[ycoords_nh, xcoords_nh] = 0
+
+            # add current feature to peaks
+            img_peaks.append(accum)
+            ycoords_peaks.append(ycoords_idx)
+            xcoords_peaks.append(xcoords_idx)
+
+    img_peaks = np.array(img_peaks)
+    ycoords_peaks = np.array(ycoords_peaks)
+    xcoords_peaks = np.array(xcoords_peaks)
+
+    if num_peaks < len(img_peaks):
+        idx_maxsort = np.argsort(img_peaks)[::-1][:num_peaks]
+        img_peaks = img_peaks[idx_maxsort]
+        ycoords_peaks = ycoords_peaks[idx_maxsort]
+        xcoords_peaks = xcoords_peaks[idx_maxsort]
+
+    return img_peaks, xcoords_peaks, ycoords_peaks

envs/kitoverlay/skimage/feature/sift.py

@@ -0,0 +1,771 @@
+import math
+
+import numpy as np
+import scipy.ndimage as ndi
+
+from .._shared.utils import check_nD, _supported_float_type
+from ..feature.util import DescriptorExtractor, FeatureDetector
+from .._shared.filters import gaussian
+from ..transform import rescale
+from ..util import img_as_float
+from ._sift import _local_max, _ori_distances, _update_histogram
+
+
+def _edgeness(hxx, hyy, hxy):
+    """Compute edgeness (eq. 18 of Otero et. al. IPOL paper)"""
+    trace = hxx + hyy
+    determinant = hxx * hyy - hxy * hxy
+    return (trace * trace) / determinant
+
+
+def _sparse_gradient(vol, positions):
+    """Gradient of a 3D volume at the provided `positions`.
+
+    For SIFT we only need the gradient at specific positions and do not need
+    the gradient at the edge positions, so can just use this simple
+    implementation instead of numpy.gradient.
+    """
+    p0 = positions[..., 0]
+    p1 = positions[..., 1]
+    p2 = positions[..., 2]
+    g0 = vol[p0 + 1, p1, p2] - vol[p0 - 1, p1, p2]
+    g0 *= 0.5
+    g1 = vol[p0, p1 + 1, p2] - vol[p0, p1 - 1, p2]
+    g1 *= 0.5
+    g2 = vol[p0, p1, p2 + 1] - vol[p0, p1, p2 - 1]
+    g2 *= 0.5
+    return g0, g1, g2
+
+
+def _hessian(d, positions):
+    """Compute the non-redundant 3D Hessian terms at the requested positions.
+
+    Source: "Anatomy of the SIFT Method"  p.380 (13)
+    """
+    p0 = positions[..., 0]
+    p1 = positions[..., 1]
+    p2 = positions[..., 2]
+    two_d0 = 2 * d[p0, p1, p2]
+    # 0 = row, 1 = col, 2 = octave
+    h00 = d[p0 - 1, p1, p2] + d[p0 + 1, p1, p2] - two_d0
+    h11 = d[p0, p1 - 1, p2] + d[p0, p1 + 1, p2] - two_d0
+    h22 = d[p0, p1, p2 - 1] + d[p0, p1, p2 + 1] - two_d0
+    h01 = 0.25 * (
+        d[p0 + 1, p1 + 1, p2]
+        - d[p0 - 1, p1 + 1, p2]
+        - d[p0 + 1, p1 - 1, p2]
+        + d[p0 - 1, p1 - 1, p2]
+    )
+    h02 = 0.25 * (
+        d[p0 + 1, p1, p2 + 1]
+        - d[p0 + 1, p1, p2 - 1]
+        + d[p0 - 1, p1, p2 - 1]
+        - d[p0 - 1, p1, p2 + 1]
+    )
+    h12 = 0.25 * (
+        d[p0, p1 + 1, p2 + 1]
+        - d[p0, p1 + 1, p2 - 1]
+        + d[p0, p1 - 1, p2 - 1]
+        - d[p0, p1 - 1, p2 + 1]
+    )
+    return (h00, h11, h22, h01, h02, h12)
+
+
+def _offsets(grad, hess):
+    """Compute position refinement offsets from gradient and Hessian.
+
+    This is equivalent to np.linalg.solve(-H, J) where H is the Hessian
+    matrix and J is the gradient (Jacobian).
+
+    This analytical solution is adapted from (BSD-licensed) C code by
+    Otero et. al (see SIFT docstring References).
+    """
+    h00, h11, h22, h01, h02, h12 = hess
+    g0, g1, g2 = grad
+    det = h00 * h11 * h22
+    det -= h00 * h12 * h12
+    det -= h01 * h01 * h22
+    det += 2 * h01 * h02 * h12
+    det -= h02 * h02 * h11
+    aa = (h11 * h22 - h12 * h12) / det
+    ab = (h02 * h12 - h01 * h22) / det
+    ac = (h01 * h12 - h02 * h11) / det
+    bb = (h00 * h22 - h02 * h02) / det
+    bc = (h01 * h02 - h00 * h12) / det
+    cc = (h00 * h11 - h01 * h01) / det
+    offset0 = -aa * g0 - ab * g1 - ac * g2
+    offset1 = -ab * g0 - bb * g1 - bc * g2
+    offset2 = -ac * g0 - bc * g1 - cc * g2
+    return np.stack((offset0, offset1, offset2), axis=-1)
+
+
+class SIFT(FeatureDetector, DescriptorExtractor):
+    """SIFT feature detection and descriptor extraction.
+
+    Parameters
+    ----------
+    upsampling : int, optional
+        Prior to the feature detection the image is upscaled by a factor
+        of 1 (no upscaling), 2 or 4. Method: Bi-cubic interpolation.
+    n_octaves : int, optional
+        Maximum number of octaves. With every octave the image size is
+        halved and the sigma doubled. The number of octaves will be
+        reduced as needed to keep at least 12 pixels along each dimension
+        at the smallest scale.
+    n_scales : int, optional
+        Maximum number of scales in every octave.
+    sigma_min : float, optional
+        The blur level of the seed image. If upsampling is enabled
+        sigma_min is scaled by factor 1/upsampling
+    sigma_in : float, optional
+        The assumed blur level of the input image.
+    c_dog : float, optional
+        Threshold to discard low contrast extrema in the DoG. It's final
+        value is dependent on n_scales by the relation:
+        final_c_dog = (2^(1/n_scales)-1) / (2^(1/3)-1) * c_dog
+    c_edge : float, optional
+        Threshold to discard extrema that lie in edges. If H is the
+        Hessian of an extremum, its "edgeness" is described by
+        tr(H)²/det(H). If the edgeness is higher than
+        (c_edge + 1)²/c_edge, the extremum is discarded.
+    n_bins : int, optional
+        Number of bins in the histogram that describes the gradient
+        orientations around keypoint.
+    lambda_ori : float, optional
+        The window used to find the reference orientation of a keypoint
+        has a width of 6 * lambda_ori * sigma and is weighted by a
+        standard deviation of 2 * lambda_ori * sigma.
+    c_max : float, optional
+        The threshold at which a secondary peak in the orientation
+        histogram is accepted as orientation
+    lambda_descr : float, optional
+        The window used to define the descriptor of a keypoint has a width
+        of 2 * lambda_descr * sigma * (n_hist+1)/n_hist and is weighted by
+        a standard deviation of lambda_descr * sigma.
+    n_hist : int, optional
+        The window used to define the descriptor of a keypoint consists of
+        n_hist * n_hist histograms.
+    n_ori : int, optional
+        The number of bins in the histograms of the descriptor patch.
+
+    Attributes
+    ----------
+    delta_min : float
+        The sampling distance of the first octave. It's final value is
+        1/upsampling.
+    float_dtype : type
+        The datatype of the image.
+    scalespace_sigmas : (n_octaves, n_scales + 3) array
+        The sigma value of all scales in all octaves.
+    keypoints : (N, 2) array
+        Keypoint coordinates as ``(row, col)``.
+    positions : (N, 2) array
+        Subpixel-precision keypoint coordinates as ``(row, col)``.
+    sigmas : (N,) array
+        The corresponding sigma (blur) value of a keypoint.
+    scales : (N,) array
+        The corresponding scale of a keypoint.
+    orientations : (N,) array
+        The orientations of the gradient around every keypoint.
+    octaves : (N,) array
+        The corresponding octave of a keypoint.
+    descriptors : (N, n_hist*n_hist*n_ori) array
+        The descriptors of a keypoint.
+
+    Notes
+    -----
+    The SIFT algorithm was developed by David Lowe [1]_, [2]_ and later
+    patented by the University of British Columbia. Since the patent expired in
+    2020 it's free to use. The implementation here closely follows the
+    detailed description in [3]_, including use of the same default parameters.
+
+    References
+    ----------
+    .. [1] D.G. Lowe. "Object recognition from local scale-invariant
+           features", Proceedings of the Seventh IEEE International
+           Conference on Computer Vision, 1999, vol.2, pp. 1150-1157.
+           :DOI:`10.1109/ICCV.1999.790410`
+
+    .. [2] D.G. Lowe. "Distinctive Image Features from Scale-Invariant
+           Keypoints", International Journal of Computer Vision, 2004,
+           vol. 60, pp. 91–110.
+           :DOI:`10.1023/B:VISI.0000029664.99615.94`
+
+    .. [3] I. R. Otero and M. Delbracio. "Anatomy of the SIFT Method",
+           Image Processing On Line, 4 (2014), pp. 370–396.
+           :DOI:`10.5201/ipol.2014.82`
+
+    Examples
+    --------
+    >>> from skimage.feature import SIFT, match_descriptors
+    >>> from skimage.data import camera
+    >>> from skimage.transform import rotate
+    >>> img1 = camera()
+    >>> img2 = rotate(camera(), 90)
+    >>> detector_extractor1 = SIFT()
+    >>> detector_extractor2 = SIFT()
+    >>> detector_extractor1.detect_and_extract(img1)
+    >>> detector_extractor2.detect_and_extract(img2)
+    >>> matches = match_descriptors(detector_extractor1.descriptors,
+    ...                             detector_extractor2.descriptors,
+    ...                             max_ratio=0.6)
+    >>> matches[10:15]
+    array([[ 10, 412],
+           [ 11, 417],
+           [ 12, 407],
+           [ 13, 411],
+           [ 14, 406]])
+    >>> detector_extractor1.keypoints[matches[10:15, 0]]
+    array([[ 95, 214],
+           [ 97, 211],
+           [ 97, 218],
+           [102, 215],
+           [104, 218]])
+    >>> detector_extractor2.keypoints[matches[10:15, 1]]
+    array([[297,  95],
+           [301,  97],
+           [294,  97],
+           [297, 102],
+           [293, 104]])
+
+    """
+
+    def __init__(
+        self,
+        upsampling=2,
+        n_octaves=8,
+        n_scales=3,
+        sigma_min=1.6,
+        sigma_in=0.5,
+        c_dog=0.04 / 3,
+        c_edge=10,
+        n_bins=36,
+        lambda_ori=1.5,
+        c_max=0.8,
+        lambda_descr=6,
+        n_hist=4,
+        n_ori=8,
+    ):
+        if upsampling in [1, 2, 4]:
+            self.upsampling = upsampling
+        else:
+            raise ValueError("upsampling must be 1, 2 or 4")
+        self.n_octaves = n_octaves
+        self.n_scales = n_scales
+        self.sigma_min = sigma_min / upsampling
+        self.sigma_in = sigma_in
+        self.c_dog = (2 ** (1 / n_scales) - 1) / (2 ** (1 / 3) - 1) * c_dog
+        self.c_edge = c_edge
+        self.n_bins = n_bins
+        self.lambda_ori = lambda_ori
+        self.c_max = c_max
+        self.lambda_descr = lambda_descr
+        self.n_hist = n_hist
+        self.n_ori = n_ori
+        self.delta_min = 1 / upsampling
+        self.float_dtype = None
+        self.scalespace_sigmas = None
+        self.keypoints = None
+        self.positions = None
+        self.sigmas = None
+        self.scales = None
+        self.orientations = None
+        self.octaves = None
+        self.descriptors = None
+
+    @property
+    def deltas(self):
+        """The sampling distances of all octaves"""
+        deltas = self.delta_min * np.power(
+            2, np.arange(self.n_octaves), dtype=self.float_dtype
+        )
+        return deltas
+
+    def _set_number_of_octaves(self, image_shape):
+        size_min = 12  # minimum size of last octave
+        s0 = min(image_shape) * self.upsampling
+        max_octaves = int(math.log2(s0 / size_min) + 1)
+        if max_octaves < self.n_octaves:
+            self.n_octaves = max_octaves
+
+    def _create_scalespace(self, image):
+        """Source: "Anatomy of the SIFT Method" Alg. 1
+        Construction of the scalespace by gradually blurring (scales) and
+        downscaling (octaves) the image.
+        """
+        scalespace = []
+        if self.upsampling > 1:
+            image = rescale(image, self.upsampling, order=1)
+
+        # smooth to sigma_min, assuming sigma_in
+        image = gaussian(
+            image,
+            sigma=self.upsampling * math.sqrt(self.sigma_min**2 - self.sigma_in**2),
+            mode='reflect',
+        )
+
+        # Eq. 10:  sigmas.shape = (n_octaves, n_scales + 3).
+        # The three extra scales are:
+        #    One for the differences needed for DoG and two auxiliary
+        #    images (one at either end) for peak_local_max with exclude
+        #    border = True (see Fig. 5)
+        # The smoothing doubles after n_scales steps.
+        tmp = np.power(2, np.arange(self.n_scales + 3) / self.n_scales)
+        tmp *= self.sigma_min
+        # all sigmas for the gaussian scalespace
+        sigmas = self.deltas[:, np.newaxis] / self.deltas[0] * tmp[np.newaxis, :]
+        self.scalespace_sigmas = sigmas
+
+        # Eq. 7: Gaussian smoothing depends on difference with previous sigma
+        #        gaussian_sigmas.shape = (n_octaves, n_scales + 2)
+        var_diff = np.diff(sigmas * sigmas, axis=1)
+        gaussian_sigmas = np.sqrt(var_diff) / self.deltas[:, np.newaxis]
+
+        # one octave is represented by a 3D image with depth (n_scales+x)
+        for o in range(self.n_octaves):
+            # Temporarily put scales axis first so octave[i] is C-contiguous
+            # (this makes Gaussian filtering faster).
+            octave = np.empty(
+                (self.n_scales + 3,) + image.shape, dtype=self.float_dtype, order='C'
+            )
+            octave[0] = image
+            for s in range(1, self.n_scales + 3):
+                # blur new scale assuming sigma of the last one
+                gaussian(
+                    octave[s - 1],
+                    sigma=gaussian_sigmas[o, s - 1],
+                    mode='reflect',
+                    out=octave[s],
+                )
+            # move scales to last axis as expected by other methods
+            scalespace.append(np.moveaxis(octave, 0, -1))
+            if o < self.n_octaves - 1:
+                # downscale the image by taking every second pixel
+                image = octave[self.n_scales][::2, ::2]
+        return scalespace
+
+    def _inrange(self, a, dim):
+        return (
+            (a[:, 0] > 0)
+            & (a[:, 0] < dim[0] - 1)
+            & (a[:, 1] > 0)
+            & (a[:, 1] < dim[1] - 1)
+        )
+
+    def _find_localize_evaluate(self, dogspace, img_shape):
+        """Source: "Anatomy of the SIFT Method" Alg. 4-9
+        1) first find all extrema of a (3, 3, 3) neighborhood
+        2) use second order Taylor development to refine the positions to
+           sub-pixel precision
+        3) filter out extrema that have low contrast and lie on edges or close
+           to the image borders
+        """
+        extrema_pos = []
+        extrema_scales = []
+        extrema_sigmas = []
+        threshold = self.c_dog * 0.8
+        for o, (octave, delta) in enumerate(zip(dogspace, self.deltas)):
+            # find extrema
+            keys = _local_max(np.ascontiguousarray(octave), threshold)
+            if keys.size == 0:
+                extrema_pos.append(np.empty((0, 2)))
+                continue
+
+            # localize extrema
+            oshape = octave.shape
+            refinement_iterations = 5
+            offset_max = 0.6
+            for i in range(refinement_iterations):
+                if i > 0:
+                    # exclude any keys that have moved out of bounds
+                    keys = keys[self._inrange(keys, oshape), :]
+
+                # Jacobian and Hessian of all extrema
+                grad = _sparse_gradient(octave, keys)
+                hess = _hessian(octave, keys)
+
+                # solve for offset of the extremum
+                off = _offsets(grad, hess)
+                if i == refinement_iterations - 1:
+                    break
+                # offset is too big and an increase would not bring us out of
+                # bounds
+                wrong_position_pos = np.logical_and(
+                    off > offset_max, keys + 1 < tuple([a - 1 for a in oshape])
+                )
+                wrong_position_neg = np.logical_and(off < -offset_max, keys - 1 > 0)
+                if not np.any(np.logical_or(wrong_position_neg, wrong_position_pos)):
+                    break
+                keys[wrong_position_pos] += 1
+                keys[wrong_position_neg] -= 1
+
+            # mask for all extrema that have been localized successfully
+            finished = np.all(np.abs(off) < offset_max, axis=1)
+            keys = keys[finished]
+            off = off[finished]
+            grad = [g[finished] for g in grad]
+
+            # value of extremum in octave
+            vals = octave[keys[:, 0], keys[:, 1], keys[:, 2]]
+            # values at interpolated point
+            w = vals
+            for i in range(3):
+                w += 0.5 * grad[i] * off[:, i]
+
+            h00, h11, h01 = hess[0][finished], hess[1][finished], hess[3][finished]
+
+            sigmaratio = self.scalespace_sigmas[0, 1] / self.scalespace_sigmas[0, 0]
+
+            # filter for contrast, edgeness and borders
+            contrast_threshold = self.c_dog
+            contrast_filter = np.abs(w) > contrast_threshold
+
+            edge_threshold = np.square(self.c_edge + 1) / self.c_edge
+            edge_response = _edgeness(
+                h00[contrast_filter], h11[contrast_filter], h01[contrast_filter]
+            )
+            edge_filter = np.abs(edge_response) <= edge_threshold
+
+            keys = keys[contrast_filter][edge_filter]
+            off = off[contrast_filter][edge_filter]
+            yx = ((keys[:, :2] + off[:, :2]) * delta).astype(self.float_dtype)
+
+            sigmas = self.scalespace_sigmas[o, keys[:, 2]] * np.power(
+                sigmaratio, off[:, 2]
+            )
+            border_filter = np.all(
+                np.logical_and(
+                    (yx - sigmas[:, np.newaxis]) > 0.0,
+                    (yx + sigmas[:, np.newaxis]) < img_shape,
+                ),
+                axis=1,
+            )
+            extrema_pos.append(yx[border_filter])
+            extrema_scales.append(keys[border_filter, 2])
+            extrema_sigmas.append(sigmas[border_filter])
+
+        octave_indices = np.concatenate(
+            [np.full(len(p), i) for i, p in enumerate(extrema_pos)]
+        )
+
+        if len(octave_indices) == 0:
+            raise RuntimeError(
+                "SIFT found no features. Try passing in an image containing "
+                "greater intensity contrasts between adjacent pixels."
+            )
+
+        extrema_pos = np.concatenate(extrema_pos)
+        extrema_scales = np.concatenate(extrema_scales)
+        extrema_sigmas = np.concatenate(extrema_sigmas)
+        return extrema_pos, extrema_scales, extrema_sigmas, octave_indices
+
+    def _fit(self, h):
+        """Refine the position of the peak by fitting it to a parabola"""
+        return (h[0] - h[2]) / (2 * (h[0] + h[2] - 2 * h[1]))
+
+    def _compute_orientation(
+        self, positions_oct, scales_oct, sigmas_oct, octaves, gaussian_scalespace
+    ):
+        """Source: "Anatomy of the SIFT Method" Alg. 11
+        Calculates the orientation of the gradient around every keypoint
+        """
+        gradient_space = []
+        # list for keypoints that have more than one reference orientation
+        keypoint_indices = []
+        keypoint_angles = []
+        keypoint_octave = []
+        orientations = np.zeros_like(sigmas_oct, dtype=self.float_dtype)
+        key_count = 0
+        for o, (octave, delta) in enumerate(zip(gaussian_scalespace, self.deltas)):
+            gradient_space.append(np.gradient(octave))
+
+            in_oct = octaves == o
+            if not np.any(in_oct):
+                continue
+            positions = positions_oct[in_oct]
+            scales = scales_oct[in_oct]
+            sigmas = sigmas_oct[in_oct]
+
+            oshape = octave.shape[:2]
+            # convert to octave's dimensions
+            yx = positions / delta
+            sigma = sigmas / delta
+
+            # dimensions of the patch
+            radius = 3 * self.lambda_ori * sigma
+            p_min = np.maximum(0, yx - radius[:, np.newaxis] + 0.5).astype(int)
+            p_max = np.minimum(
+                yx + radius[:, np.newaxis] + 0.5, (oshape[0] - 1, oshape[1] - 1)
+            ).astype(int)
+            # orientation histogram
+            hist = np.empty(self.n_bins, dtype=self.float_dtype)
+            avg_kernel = np.full((3,), 1 / 3, dtype=self.float_dtype)
+            for k in range(len(yx)):
+                hist[:] = 0
+
+                # use the patch coordinates to get the gradient and then
+                # normalize them
+                r, c = np.meshgrid(
+                    np.arange(p_min[k, 0], p_max[k, 0] + 1),
+                    np.arange(p_min[k, 1], p_max[k, 1] + 1),
+                    indexing='ij',
+                    sparse=True,
+                )
+                gradient_row = gradient_space[o][0][r, c, scales[k]]
+                gradient_col = gradient_space[o][1][r, c, scales[k]]
+                r = r.astype(self.float_dtype, copy=False)
+                c = c.astype(self.float_dtype, copy=False)
+                r -= yx[k, 0]
+                c -= yx[k, 1]
+
+                # gradient magnitude and angles
+                magnitude = np.sqrt(np.square(gradient_row) + np.square(gradient_col))
+                theta = np.mod(np.arctan2(gradient_col, gradient_row), 2 * np.pi)
+
+                # more weight to center values
+                kernel = np.exp(
+                    np.divide(r * r + c * c, -2 * (self.lambda_ori * sigma[k]) ** 2)
+                )
+
+                # fill the histogram
+                bins = np.floor(
+                    (theta / (2 * np.pi) * self.n_bins + 0.5) % self.n_bins
+                ).astype(int)
+                np.add.at(hist, bins, kernel * magnitude)
+
+                # smooth the histogram and find the maximum
+                hist = np.concatenate((hist[-6:], hist, hist[:6]))
+                for _ in range(6):  # number of smoothings
+                    hist = np.convolve(hist, avg_kernel, mode='same')
+                hist = hist[6:-6]
+                max_filter = ndi.maximum_filter(hist, [3], mode='wrap')
+
+                # if an angle is in 80% percent range of the maximum, a
+                # new keypoint is created for it
+                maxima = np.nonzero(
+                    np.logical_and(
+                        hist >= (self.c_max * np.max(hist)), max_filter == hist
+                    )
+                )
+
+                # save the angles
+                for c, m in enumerate(maxima[0]):
+                    neigh = np.arange(m - 1, m + 2) % len(hist)
+                    # use neighbors to fit a parabola, to get more accurate
+                    # result
+                    ori = (m + self._fit(hist[neigh]) + 0.5) * 2 * np.pi / self.n_bins
+                    if ori > np.pi:
+                        ori -= 2 * np.pi
+                    if c == 0:
+                        orientations[key_count] = ori
+                    else:
+                        keypoint_indices.append(key_count)
+                        keypoint_angles.append(ori)
+                        keypoint_octave.append(o)
+                key_count += 1
+        self.positions = np.concatenate(
+            (positions_oct, positions_oct[keypoint_indices])
+        )
+        self.scales = np.concatenate((scales_oct, scales_oct[keypoint_indices]))
+        self.sigmas = np.concatenate((sigmas_oct, sigmas_oct[keypoint_indices]))
+        self.orientations = np.concatenate((orientations, keypoint_angles))
+        self.octaves = np.concatenate((octaves, keypoint_octave))
+        # return the gradient_space to reuse it to find the descriptor
+        return gradient_space
+
+    def _rotate(self, row, col, angle):
+        c = math.cos(angle)
+        s = math.sin(angle)
+        rot_row = c * row + s * col
+        rot_col = -s * row + c * col
+        return rot_row, rot_col
+
+    def _compute_descriptor(self, gradient_space):
+        """Source: "Anatomy of the SIFT Method" Alg. 12
+        Calculates the descriptor for every keypoint
+        """
+        n_key = len(self.scales)
+        self.descriptors = np.empty(
+            (n_key, self.n_hist**2 * self.n_ori), dtype=np.uint8
+        )
+
+        # indices of the histograms
+        hists = np.arange(1, self.n_hist + 1, dtype=self.float_dtype)
+        # indices of the bins
+        bins = np.arange(1, self.n_ori + 1, dtype=self.float_dtype)
+
+        key_numbers = np.arange(n_key)
+        for o, (gradient, delta) in enumerate(zip(gradient_space, self.deltas)):
+            in_oct = self.octaves == o
+            if not np.any(in_oct):
+                continue
+            positions = self.positions[in_oct]
+            scales = self.scales[in_oct]
+            sigmas = self.sigmas[in_oct]
+            orientations = self.orientations[in_oct]
+            numbers = key_numbers[in_oct]
+
+            dim = gradient[0].shape[:2]
+            center_pos = positions / delta
+            sigma = sigmas / delta
+
+            # dimensions of the patch
+            radius = self.lambda_descr * (1 + 1 / self.n_hist) * sigma
+            radius_patch = math.sqrt(2) * radius
+            p_min = np.asarray(
+                np.maximum(0, center_pos - radius_patch[:, np.newaxis] + 0.5), dtype=int
+            )
+            p_max = np.asarray(
+                np.minimum(
+                    center_pos + radius_patch[:, np.newaxis] + 0.5,
+                    (dim[0] - 1, dim[1] - 1),
+                ),
+                dtype=int,
+            )
+
+            for k in range(len(p_max)):
+                rad_k = float(radius[k])
+                ori = float(orientations[k])
+                histograms = np.zeros(
+                    (self.n_hist, self.n_hist, self.n_ori), dtype=self.float_dtype
+                )
+                # the patch
+                r, c = np.meshgrid(
+                    np.arange(p_min[k, 0], p_max[k, 0]),
+                    np.arange(p_min[k, 1], p_max[k, 1]),
+                    indexing='ij',
+                    sparse=True,
+                )
+                # normalized coordinates
+                r_norm = np.subtract(r, center_pos[k, 0], dtype=self.float_dtype)
+                c_norm = np.subtract(c, center_pos[k, 1], dtype=self.float_dtype)
+                r_norm, c_norm = self._rotate(r_norm, c_norm, ori)
+
+                # select coordinates and gradient values within the patch
+                inside = np.maximum(np.abs(r_norm), np.abs(c_norm)) < rad_k
+                r_norm, c_norm = r_norm[inside], c_norm[inside]
+                r_idx, c_idx = np.nonzero(inside)
+                r = r[r_idx, 0]
+                c = c[0, c_idx]
+                gradient_row = gradient[0][r, c, scales[k]]
+                gradient_col = gradient[1][r, c, scales[k]]
+                # compute the (relative) gradient orientation
+                theta = np.arctan2(gradient_col, gradient_row) - ori
+                lam_sig = self.lambda_descr * float(sigma[k])
+                # Gaussian weighted kernel magnitude
+                kernel = np.exp((r_norm * r_norm + c_norm * c_norm) / (-2 * lam_sig**2))
+                magnitude = (
+                    np.sqrt(gradient_row * gradient_row + gradient_col * gradient_col)
+                    * kernel
+                )
+
+                lam_sig_ratio = 2 * lam_sig / self.n_hist
+                rc_bins = (hists - (1 + self.n_hist) / 2) * lam_sig_ratio
+                rc_bin_spacing = lam_sig_ratio
+                ori_bins = (2 * np.pi * bins) / self.n_ori
+
+                # distances to the histograms and bins
+                dist_r = np.abs(np.subtract.outer(rc_bins, r_norm))
+                dist_c = np.abs(np.subtract.outer(rc_bins, c_norm))
+
+                # the orientation histograms/bins that get the contribution
+                near_t, near_t_val = _ori_distances(ori_bins, theta)
+
+                # create the histogram
+                _update_histogram(
+                    histograms,
+                    near_t,
+                    near_t_val,
+                    magnitude,
+                    dist_r,
+                    dist_c,
+                    rc_bin_spacing,
+                )
+
+                # convert the histograms to a 1d descriptor
+                histograms = histograms.reshape(-1)
+                # saturate the descriptor
+                histograms = np.minimum(histograms, 0.2 * np.linalg.norm(histograms))
+                # normalize the descriptor
+                descriptor = (512 * histograms) / np.linalg.norm(histograms)
+                # quantize the descriptor
+                descriptor = np.minimum(np.floor(descriptor), 255)
+                self.descriptors[numbers[k], :] = descriptor
+
+    def _preprocess(self, image):
+        check_nD(image, 2)
+        image = img_as_float(image)
+        self.float_dtype = _supported_float_type(image.dtype)
+        image = image.astype(self.float_dtype, copy=False)
+
+        self._set_number_of_octaves(image.shape)
+        return image
+
+    def detect(self, image):
+        """Detect the keypoints.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+
+        """
+        image = self._preprocess(image)
+
+        gaussian_scalespace = self._create_scalespace(image)
+
+        dog_scalespace = [np.diff(layer, axis=2) for layer in gaussian_scalespace]
+
+        positions, scales, sigmas, octaves = self._find_localize_evaluate(
+            dog_scalespace, image.shape
+        )
+
+        self._compute_orientation(
+            positions, scales, sigmas, octaves, gaussian_scalespace
+        )
+
+        self.keypoints = self.positions.round().astype(int)
+
+    def extract(self, image):
+        """Extract the descriptors for all keypoints in the image.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+
+        """
+        image = self._preprocess(image)
+
+        gaussian_scalespace = self._create_scalespace(image)
+
+        gradient_space = [np.gradient(octave) for octave in gaussian_scalespace]
+
+        self._compute_descriptor(gradient_space)
+
+    def detect_and_extract(self, image):
+        """Detect the keypoints and extract their descriptors.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+
+        """
+        image = self._preprocess(image)
+
+        gaussian_scalespace = self._create_scalespace(image)
+
+        dog_scalespace = [np.diff(layer, axis=2) for layer in gaussian_scalespace]
+
+        positions, scales, sigmas, octaves = self._find_localize_evaluate(
+            dog_scalespace, image.shape
+        )
+
+        gradient_space = self._compute_orientation(
+            positions, scales, sigmas, octaves, gaussian_scalespace
+        )
+
+        self._compute_descriptor(gradient_space)
+
+        self.keypoints = self.positions.round().astype(int)

envs/kitoverlay/skimage/feature/template.py

@@ -0,0 +1,186 @@
+import math
+
+import numpy as np
+from scipy.signal import fftconvolve
+
+from .._shared.utils import check_nD, _supported_float_type
+
+
+def _window_sum_2d(image, window_shape):
+    window_sum = np.cumsum(image, axis=0)
+    window_sum = window_sum[window_shape[0] : -1] - window_sum[: -window_shape[0] - 1]
+
+    window_sum = np.cumsum(window_sum, axis=1)
+    window_sum = (
+        window_sum[:, window_shape[1] : -1] - window_sum[:, : -window_shape[1] - 1]
+    )
+
+    return window_sum
+
+
+def _window_sum_3d(image, window_shape):
+    window_sum = _window_sum_2d(image, window_shape)
+
+    window_sum = np.cumsum(window_sum, axis=2)
+    window_sum = (
+        window_sum[:, :, window_shape[2] : -1]
+        - window_sum[:, :, : -window_shape[2] - 1]
+    )
+
+    return window_sum
+
+
+def match_template(
+    image, template, pad_input=False, mode='constant', constant_values=0
+):
+    """Match a template to a 2-D or 3-D image using normalized correlation.
+
+    The output is an array with values between -1.0 and 1.0. The value at a
+    given position corresponds to the correlation coefficient between the image
+    and the template.
+
+    For `pad_input=True` matches correspond to the center and otherwise to the
+    top-left corner of the template. To find the best match you must search for
+    peaks in the response (output) image.
+
+    Parameters
+    ----------
+    image : (M, N[, P]) array
+        2-D or 3-D input image.
+    template : (m, n[, p]) array
+        Template to locate. It must be `(m <= M, n <= N[, p <= P])`.
+    pad_input : bool
+        If True, pad `image` so that output is the same size as the image, and
+        output values correspond to the template center. Otherwise, the output
+        is an array with shape `(M - m + 1, N - n + 1)` for an `(M, N)` image
+        and an `(m, n)` template, and matches correspond to origin
+        (top-left corner) of the template.
+    mode : see `numpy.pad`, optional
+        Padding mode.
+    constant_values : see `numpy.pad`, optional
+        Constant values used in conjunction with ``mode='constant'``.
+
+    Returns
+    -------
+    output : array
+        Response image with correlation coefficients.
+
+    Notes
+    -----
+    Details on the cross-correlation are presented in [1]_. This implementation
+    uses FFT convolutions of the image and the template. Reference [2]_
+    presents similar derivations but the approximation presented in this
+    reference is not used in our implementation.
+
+    References
+    ----------
+    .. [1] J. P. Lewis, "Fast Normalized Cross-Correlation", Industrial Light
+           and Magic.
+    .. [2] Briechle and Hanebeck, "Template Matching using Fast Normalized
+           Cross Correlation", Proceedings of the SPIE (2001).
+           :DOI:`10.1117/12.421129`
+
+    Examples
+    --------
+    >>> template = np.zeros((3, 3))
+    >>> template[1, 1] = 1
+    >>> template
+    array([[0., 0., 0.],
+           [0., 1., 0.],
+           [0., 0., 0.]])
+    >>> image = np.zeros((6, 6))
+    >>> image[1, 1] = 1
+    >>> image[4, 4] = -1
+    >>> image
+    array([[ 0.,  0.,  0.,  0.,  0.,  0.],
+           [ 0.,  1.,  0.,  0.,  0.,  0.],
+           [ 0.,  0.,  0.,  0.,  0.,  0.],
+           [ 0.,  0.,  0.,  0.,  0.,  0.],
+           [ 0.,  0.,  0.,  0., -1.,  0.],
+           [ 0.,  0.,  0.,  0.,  0.,  0.]])
+    >>> result = match_template(image, template)
+    >>> np.round(result, 3)
+    array([[ 1.   , -0.125,  0.   ,  0.   ],
+           [-0.125, -0.125,  0.   ,  0.   ],
+           [ 0.   ,  0.   ,  0.125,  0.125],
+           [ 0.   ,  0.   ,  0.125, -1.   ]])
+    >>> result = match_template(image, template, pad_input=True)
+    >>> np.round(result, 3)
+    array([[-0.125, -0.125, -0.125,  0.   ,  0.   ,  0.   ],
+           [-0.125,  1.   , -0.125,  0.   ,  0.   ,  0.   ],
+           [-0.125, -0.125, -0.125,  0.   ,  0.   ,  0.   ],
+           [ 0.   ,  0.   ,  0.   ,  0.125,  0.125,  0.125],
+           [ 0.   ,  0.   ,  0.   ,  0.125, -1.   ,  0.125],
+           [ 0.   ,  0.   ,  0.   ,  0.125,  0.125,  0.125]])
+    """
+    check_nD(image, (2, 3))
+
+    if image.ndim < template.ndim:
+        raise ValueError(
+            "Dimensionality of template must be less than or "
+            "equal to the dimensionality of image."
+        )
+    if np.any(np.less(image.shape, template.shape)):
+        raise ValueError("Image must be larger than template.")
+
+    image_shape = image.shape
+
+    float_dtype = _supported_float_type(image.dtype)
+    image = image.astype(float_dtype, copy=False)
+
+    pad_width = tuple((width, width) for width in template.shape)
+    if mode == 'constant':
+        image = np.pad(
+            image, pad_width=pad_width, mode=mode, constant_values=constant_values
+        )
+    else:
+        image = np.pad(image, pad_width=pad_width, mode=mode)
+
+    # Use special case for 2-D images for much better performance in
+    # computation of integral images
+    if image.ndim == 2:
+        image_window_sum = _window_sum_2d(image, template.shape)
+        image_window_sum2 = _window_sum_2d(image**2, template.shape)
+    elif image.ndim == 3:
+        image_window_sum = _window_sum_3d(image, template.shape)
+        image_window_sum2 = _window_sum_3d(image**2, template.shape)
+
+    template_mean = template.mean()
+    template_volume = math.prod(template.shape)
+    template_ssd = np.sum((template - template_mean) ** 2)
+
+    if image.ndim == 2:
+        xcorr = fftconvolve(image, template[::-1, ::-1], mode="valid")[1:-1, 1:-1]
+    elif image.ndim == 3:
+        xcorr = fftconvolve(image, template[::-1, ::-1, ::-1], mode="valid")[
+            1:-1, 1:-1, 1:-1
+        ]
+
+    numerator = xcorr - image_window_sum * template_mean
+
+    denominator = image_window_sum2
+    np.multiply(image_window_sum, image_window_sum, out=image_window_sum)
+    np.divide(image_window_sum, template_volume, out=image_window_sum)
+    denominator -= image_window_sum
+    denominator *= template_ssd
+    np.maximum(denominator, 0, out=denominator)  # sqrt of negative number not allowed
+    np.sqrt(denominator, out=denominator)
+
+    response = np.zeros_like(xcorr, dtype=float_dtype)
+
+    # avoid zero-division
+    mask = denominator > np.finfo(float_dtype).eps
+
+    response[mask] = numerator[mask] / denominator[mask]
+
+    slices = []
+    for i in range(template.ndim):
+        if pad_input:
+            d0 = (template.shape[i] - 1) // 2
+            d1 = d0 + image_shape[i]
+        else:
+            d0 = template.shape[i] - 1
+            d1 = d0 + image_shape[i] - template.shape[i] + 1
+        slices.append(slice(d0, d1))
+
+    return response[tuple(slices)]

envs/kitoverlay/skimage/feature/texture.py

@@ -0,0 +1,562 @@
+"""
+Methods to characterize image textures.
+"""
+
+import warnings
+
+import numpy as np
+
+from .._shared.utils import check_nD
+from ..color import gray2rgb
+from ..util import img_as_float
+from ._texture import _glcm_loop, _local_binary_pattern, _multiblock_lbp
+
+
+def graycomatrix(image, distances, angles, levels=None, symmetric=False, normed=False):
+    """Calculate the gray-level co-occurrence matrix.
+
+    A gray level co-occurrence matrix is a histogram of co-occurring
+    grayscale values at a given offset over an image.
+
+    .. versionchanged:: 0.19
+               `greymatrix` was renamed to `graymatrix` in 0.19.
+
+    Parameters
+    ----------
+    image : array_like
+        Integer typed input image. Only positive valued images are supported.
+        If type is other than uint8, the argument `levels` needs to be set.
+    distances : array_like
+        List of pixel pair distance offsets.
+    angles : array_like
+        List of pixel pair angles in radians.
+    levels : int, optional
+        The input image should contain integers in [0, `levels`-1],
+        where levels indicate the number of gray-levels counted
+        (typically 256 for an 8-bit image). This argument is required for
+        16-bit images or higher and is typically the maximum of the image.
+        As the output matrix is at least `levels` x `levels`, it might
+        be preferable to use binning of the input image rather than
+        large values for `levels`.
+    symmetric : bool, optional
+        If True, the output matrix `P[:, :, d, theta]` is symmetric. This
+        is accomplished by ignoring the order of value pairs, so both
+        (i, j) and (j, i) are accumulated when (i, j) is encountered
+        for a given offset. The default is False.
+    normed : bool, optional
+        If True, normalize each matrix `P[:, :, d, theta]` by dividing
+        by the total number of accumulated co-occurrences for the given
+        offset. The elements of the resulting matrix sum to 1. The
+        default is False.
+
+    Returns
+    -------
+    P : 4-D ndarray
+        The gray-level co-occurrence histogram. The value
+        `P[i,j,d,theta]` is the number of times that gray-level `j`
+        occurs at a distance `d` and at an angle `theta` from
+        gray-level `i`. If `normed` is `False`, the output is of
+        type uint32, otherwise it is float64. The dimensions are:
+        levels x levels x number of distances x number of angles.
+
+    References
+    ----------
+    .. [1] M. Hall-Beyer, 2007. GLCM Texture: A Tutorial
+           https://prism.ucalgary.ca/handle/1880/51900
+           DOI:`10.11575/PRISM/33280`
+    .. [2] R.M. Haralick, K. Shanmugam, and I. Dinstein, "Textural features for
+           image classification", IEEE Transactions on Systems, Man, and
+           Cybernetics, vol. SMC-3, no. 6, pp. 610-621, Nov. 1973.
+           :DOI:`10.1109/TSMC.1973.4309314`
+    .. [3] M. Nadler and E.P. Smith, Pattern Recognition Engineering,
+           Wiley-Interscience, 1993.
+    .. [4] Wikipedia, https://en.wikipedia.org/wiki/Co-occurrence_matrix
+
+
+    Examples
+    --------
+    Compute 4 GLCMs using 1-pixel distance and 4 different angles. For example,
+    an angle of 0 radians refers to the neighboring pixel to the right;
+    pi/4 radians to the top-right diagonal neighbor; pi/2 radians to the pixel
+    above, and so forth.
+
+    >>> image = np.array([[0, 0, 1, 1],
+    ...                   [0, 0, 1, 1],
+    ...                   [0, 2, 2, 2],
+    ...                   [2, 2, 3, 3]], dtype=np.uint8)
+    >>> result = graycomatrix(image, [1], [0, np.pi/4, np.pi/2, 3*np.pi/4],
+    ...                       levels=4)
+    >>> result[:, :, 0, 0]
+    array([[2, 2, 1, 0],
+           [0, 2, 0, 0],
+           [0, 0, 3, 1],
+           [0, 0, 0, 1]], dtype=uint32)
+    >>> result[:, :, 0, 1]
+    array([[1, 1, 3, 0],
+           [0, 1, 1, 0],
+           [0, 0, 0, 2],
+           [0, 0, 0, 0]], dtype=uint32)
+    >>> result[:, :, 0, 2]
+    array([[3, 0, 2, 0],
+           [0, 2, 2, 0],
+           [0, 0, 1, 2],
+           [0, 0, 0, 0]], dtype=uint32)
+    >>> result[:, :, 0, 3]
+    array([[2, 0, 0, 0],
+           [1, 1, 2, 0],
+           [0, 0, 2, 1],
+           [0, 0, 0, 0]], dtype=uint32)
+
+    """
+    check_nD(image, 2)
+    check_nD(distances, 1, 'distances')
+    check_nD(angles, 1, 'angles')
+
+    image = np.ascontiguousarray(image)
+
+    image_max = image.max()
+
+    if np.issubdtype(image.dtype, np.floating):
+        raise ValueError(
+            "Float images are not supported by graycomatrix. "
+            "Convert the image to an unsigned integer type."
+        )
+
+    # for image type > 8bit, levels must be set.
+    if image.dtype not in (np.uint8, np.int8) and levels is None:
+        raise ValueError(
+            "The levels argument is required for data types "
+            "other than uint8. The resulting matrix will be at "
+            "least levels ** 2 in size."
+        )
+
+    if np.issubdtype(image.dtype, np.signedinteger) and np.any(image < 0):
+        raise ValueError("Negative-valued images are not supported.")
+
+    if levels is None:
+        levels = 256
+
+    if image_max >= levels:
+        raise ValueError(
+            "The maximum grayscale value in the image should be "
+            "smaller than the number of levels."
+        )
+
+    distances = np.ascontiguousarray(distances, dtype=np.float64)
+    angles = np.ascontiguousarray(angles, dtype=np.float64)
+
+    P = np.zeros(
+        (levels, levels, len(distances), len(angles)), dtype=np.uint32, order='C'
+    )
+
+    # count co-occurences
+    _glcm_loop(image, distances, angles, levels, P)
+
+    # make each GLMC symmetric
+    if symmetric:
+        Pt = np.transpose(P, (1, 0, 2, 3))
+        P = P + Pt
+
+    # normalize each GLCM
+    if normed:
+        P = P.astype(np.float64)
+        glcm_sums = np.sum(P, axis=(0, 1), keepdims=True)
+        glcm_sums[glcm_sums == 0] = 1
+        P /= glcm_sums
+
+    return P
+
+
+def graycoprops(P, prop='contrast'):
+    """Calculate texture properties of a GLCM.
+
+    Compute a feature of a gray level co-occurrence matrix to serve as
+    a compact summary of the matrix. The properties are computed as
+    follows:
+
+    - 'contrast': :math:`\\sum_{i,j=0}^{levels-1} P_{i,j}(i-j)^2`
+    - 'dissimilarity': :math:`\\sum_{i,j=0}^{levels-1}P_{i,j}|i-j|`
+    - 'homogeneity': :math:`\\sum_{i,j=0}^{levels-1}\\frac{P_{i,j}}{1+(i-j)^2}`
+    - 'ASM': :math:`\\sum_{i,j=0}^{levels-1} P_{i,j}^2`
+    - 'energy': :math:`\\sqrt{ASM}`
+    - 'correlation':
+        .. math:: \\sum_{i,j=0}^{levels-1} P_{i,j}\\left[\\frac{(i-\\mu_i) \\
+                  (j-\\mu_j)}{\\sqrt{(\\sigma_i^2)(\\sigma_j^2)}}\\right]
+    - 'mean': :math:`\\sum_{i=0}^{levels-1} i*P_{i}`
+    - 'variance': :math:`\\sum_{i=0}^{levels-1} P_{i}*(i-mean)^2`
+    - 'std': :math:`\\sqrt{variance}`
+    - 'entropy': :math:`\\sum_{i,j=0}^{levels-1} -P_{i,j}*log(P_{i,j})`
+
+    Each GLCM is normalized to have a sum of 1 before the computation of
+    texture properties.
+
+    .. versionchanged:: 0.19
+           `greycoprops` was renamed to `graycoprops` in 0.19.
+
+    Parameters
+    ----------
+    P : ndarray
+        Input array. `P` is the gray-level co-occurrence histogram
+        for which to compute the specified property. The value
+        `P[i,j,d,theta]` is the number of times that gray-level j
+        occurs at a distance d and at an angle theta from
+        gray-level i.
+    prop : {'contrast', 'dissimilarity', 'homogeneity', 'energy', \
+            'correlation', 'ASM', 'mean', 'variance', 'std', 'entropy'}, optional
+        The property of the GLCM to compute. The default is 'contrast'.
+
+    Returns
+    -------
+    results : 2-D ndarray
+        2-dimensional array. `results[d, a]` is the property 'prop' for
+        the d'th distance and the a'th angle.
+
+    References
+    ----------
+    .. [1] M. Hall-Beyer, 2007. GLCM Texture: A Tutorial v. 1.0 through 3.0.
+           The GLCM Tutorial Home Page,
+           https://prism.ucalgary.ca/handle/1880/51900
+           DOI:`10.11575/PRISM/33280`
+
+    Examples
+    --------
+    Compute the contrast for GLCMs with distances [1, 2] and angles
+    [0 degrees, 90 degrees]
+
+    >>> image = np.array([[0, 0, 1, 1],
+    ...                   [0, 0, 1, 1],
+    ...                   [0, 2, 2, 2],
+    ...                   [2, 2, 3, 3]], dtype=np.uint8)
+    >>> g = graycomatrix(image, [1, 2], [0, np.pi/2], levels=4,
+    ...                  normed=True, symmetric=True)
+    >>> contrast = graycoprops(g, 'contrast')
+    >>> contrast
+    array([[0.58333333, 1.        ],
+           [1.25      , 2.75      ]])
+
+    """
+
+    def glcm_mean():
+        I = np.arange(num_level).reshape((num_level, 1, 1, 1))
+        mean = np.sum(I * P, axis=(0, 1))
+        return I, mean
+
+    check_nD(P, 4, 'P')
+
+    (num_level, num_level2, num_dist, num_angle) = P.shape
+    if num_level != num_level2:
+        raise ValueError('num_level and num_level2 must be equal.')
+    if num_dist <= 0:
+        raise ValueError('num_dist must be positive.')
+    if num_angle <= 0:
+        raise ValueError('num_angle must be positive.')
+
+    # normalize each GLCM
+    P = P.astype(np.float64)
+    glcm_sums = np.sum(P, axis=(0, 1), keepdims=True)
+    glcm_sums[glcm_sums == 0] = 1
+    P /= glcm_sums
+
+    # create weights for specified property
+    I, J = np.ogrid[0:num_level, 0:num_level]
+    if prop == 'contrast':
+        weights = (I - J) ** 2
+    elif prop == 'dissimilarity':
+        weights = np.abs(I - J)
+    elif prop == 'homogeneity':
+        weights = 1.0 / (1.0 + (I - J) ** 2)
+    elif prop in ['ASM', 'energy', 'correlation', 'entropy', 'variance', 'mean', 'std']:
+        pass
+    else:
+        raise ValueError(f'{prop} is an invalid property')
+
+    # compute property for each GLCM
+    if prop == 'energy':
+        asm = np.sum(P**2, axis=(0, 1))
+        results = np.sqrt(asm)
+    elif prop == 'ASM':
+        results = np.sum(P**2, axis=(0, 1))
+    elif prop == 'mean':
+        _, results = glcm_mean()
+    elif prop == 'variance':
+        I, mean = glcm_mean()
+        results = np.sum(P * ((I - mean) ** 2), axis=(0, 1))
+    elif prop == 'std':
+        I, mean = glcm_mean()
+        var = np.sum(P * ((I - mean) ** 2), axis=(0, 1))
+        results = np.sqrt(var)
+    elif prop == 'entropy':
+        ln = -np.log(P, where=(P != 0), out=np.zeros_like(P))
+        results = np.sum(P * ln, axis=(0, 1))
+
+    elif prop == 'correlation':
+        results = np.zeros((num_dist, num_angle), dtype=np.float64)
+        I = np.array(range(num_level)).reshape((num_level, 1, 1, 1))
+        J = np.array(range(num_level)).reshape((1, num_level, 1, 1))
+        diff_i = I - np.sum(I * P, axis=(0, 1))
+        diff_j = J - np.sum(J * P, axis=(0, 1))
+
+        std_i = np.sqrt(np.sum(P * (diff_i) ** 2, axis=(0, 1)))
+        std_j = np.sqrt(np.sum(P * (diff_j) ** 2, axis=(0, 1)))
+        cov = np.sum(P * (diff_i * diff_j), axis=(0, 1))
+
+        # handle the special case of standard deviations near zero
+        mask_0 = std_i < 1e-15
+        mask_0[std_j < 1e-15] = True
+        results[mask_0] = 1
+
+        # handle the standard case
+        mask_1 = ~mask_0
+        results[mask_1] = cov[mask_1] / (std_i[mask_1] * std_j[mask_1])
+    elif prop in ['contrast', 'dissimilarity', 'homogeneity']:
+        weights = weights.reshape((num_level, num_level, 1, 1))
+        results = np.sum(P * weights, axis=(0, 1))
+
+    return results
+
+
+def local_binary_pattern(image, P, R, method='default'):
+    """Compute the local binary patterns (LBP) of an image.
+
+    LBP is a visual descriptor often used in texture classification.
+
+    Parameters
+    ----------
+    image : (M, N) array
+        2D grayscale image.
+    P : int
+        Number of circularly symmetric neighbor set points (quantization of
+        the angular space).
+    R : float
+        Radius of circle (spatial resolution of the operator).
+    method : str {'default', 'ror', 'uniform', 'nri_uniform', 'var'}, optional
+        Method to determine the pattern:
+
+        ``default``
+            Original local binary pattern which is grayscale invariant but not
+            rotation invariant.
+        ``ror``
+            Extension of default pattern which is grayscale invariant and
+            rotation invariant.
+        ``uniform``
+            Uniform pattern which is grayscale invariant and rotation
+            invariant, offering finer quantization of the angular space.
+            For details, see [1]_.
+        ``nri_uniform``
+            Variant of uniform pattern which is grayscale invariant but not
+            rotation invariant. For details, see [2]_ and [3]_.
+        ``var``
+            Variance of local image texture (related to contrast)
+            which is rotation invariant but not grayscale invariant.
+
+    Returns
+    -------
+    output : (M, N) array
+        LBP image.
+
+    References
+    ----------
+    .. [1] T. Ojala, M. Pietikainen, T. Maenpaa, "Multiresolution gray-scale
+           and rotation invariant texture classification with local binary
+           patterns", IEEE Transactions on Pattern Analysis and Machine
+           Intelligence, vol. 24, no. 7, pp. 971-987, July 2002
+           :DOI:`10.1109/TPAMI.2002.1017623`
+    .. [2] T. Ahonen, A. Hadid and M. Pietikainen. "Face recognition with
+           local binary patterns", in Proc. Eighth European Conf. Computer
+           Vision, Prague, Czech Republic, May 11-14, 2004, pp. 469-481, 2004.
+           http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.214.6851
+           :DOI:`10.1007/978-3-540-24670-1_36`
+    .. [3] T. Ahonen, A. Hadid and M. Pietikainen, "Face Description with
+           Local Binary Patterns: Application to Face Recognition",
+           IEEE Transactions on Pattern Analysis and Machine Intelligence,
+           vol. 28, no. 12, pp. 2037-2041, Dec. 2006
+           :DOI:`10.1109/TPAMI.2006.244`
+    """
+    check_nD(image, 2)
+
+    methods = {
+        'default': ord('D'),
+        'ror': ord('R'),
+        'uniform': ord('U'),
+        'nri_uniform': ord('N'),
+        'var': ord('V'),
+    }
+    if np.issubdtype(image.dtype, np.floating):
+        warnings.warn(
+            "Applying `local_binary_pattern` to floating-point images may "
+            "give unexpected results when small numerical differences between "
+            "adjacent pixels are present. It is recommended to use this "
+            "function with images of integer dtype."
+        )
+    image = np.ascontiguousarray(image, dtype=np.float64)
+    output = _local_binary_pattern(image, P, R, methods[method.lower()])
+    return output
+
+
+def multiblock_lbp(int_image, r, c, width, height):
+    """Multi-block local binary pattern (MB-LBP).
+
+    The features are calculated similarly to local binary patterns (LBPs),
+    (See :py:meth:`local_binary_pattern`) except that summed blocks are
+    used instead of individual pixel values.
+
+    MB-LBP is an extension of LBP that can be computed on multiple scales
+    in constant time using the integral image. Nine equally-sized rectangles
+    are used to compute a feature. For each rectangle, the sum of the pixel
+    intensities is computed. Comparisons of these sums to that of the central
+    rectangle determine the feature, similarly to LBP.
+
+    Parameters
+    ----------
+    int_image : (N, M) array
+        Integral image.
+    r : int
+        Row-coordinate of top left corner of a rectangle containing feature.
+    c : int
+        Column-coordinate of top left corner of a rectangle containing feature.
+    width : int
+        Width of one of the 9 equal rectangles that will be used to compute
+        a feature.
+    height : int
+        Height of one of the 9 equal rectangles that will be used to compute
+        a feature.
+
+    Returns
+    -------
+    output : int
+        8-bit MB-LBP feature descriptor.
+
+    References
+    ----------
+    .. [1] L. Zhang, R. Chu, S. Xiang, S. Liao, S.Z. Li. "Face Detection Based
+           on Multi-Block LBP Representation", In Proceedings: Advances in
+           Biometrics, International Conference, ICB 2007, Seoul, Korea.
+           http://www.cbsr.ia.ac.cn/users/scliao/papers/Zhang-ICB07-MBLBP.pdf
+           :DOI:`10.1007/978-3-540-74549-5_2`
+    """
+
+    int_image = np.ascontiguousarray(int_image, dtype=np.float32)
+    lbp_code = _multiblock_lbp(int_image, r, c, width, height)
+    return lbp_code
+
+
+def draw_multiblock_lbp(
+    image,
+    r,
+    c,
+    width,
+    height,
+    lbp_code=0,
+    color_greater_block=(1, 1, 1),
+    color_less_block=(0, 0.69, 0.96),
+    alpha=0.5,
+):
+    """Multi-block local binary pattern visualization.
+
+    Blocks with higher sums are colored with alpha-blended white rectangles,
+    whereas blocks with lower sums are colored alpha-blended cyan. Colors
+    and the `alpha` parameter can be changed.
+
+    Parameters
+    ----------
+    image : ndarray of float or uint
+        Image on which to visualize the pattern.
+    r : int
+        Row-coordinate of top left corner of a rectangle containing feature.
+    c : int
+        Column-coordinate of top left corner of a rectangle containing feature.
+    width : int
+        Width of one of 9 equal rectangles that will be used to compute
+        a feature.
+    height : int
+        Height of one of 9 equal rectangles that will be used to compute
+        a feature.
+    lbp_code : int
+        The descriptor of feature to visualize. If not provided, the
+        descriptor with 0 value will be used.
+    color_greater_block : tuple of 3 floats
+        Floats specifying the color for the block that has greater
+        intensity value. They should be in the range [0, 1].
+        Corresponding values define (R, G, B) values. Default value
+        is white (1, 1, 1).
+    color_greater_block : tuple of 3 floats
+        Floats specifying the color for the block that has greater intensity
+        value. They should be in the range [0, 1]. Corresponding values define
+        (R, G, B) values. Default value is cyan (0, 0.69, 0.96).
+    alpha : float
+        Value in the range [0, 1] that specifies opacity of visualization.
+        1 - fully transparent, 0 - opaque.
+
+    Returns
+    -------
+    output : ndarray of float
+        Image with MB-LBP visualization.
+
+    References
+    ----------
+    .. [1] L. Zhang, R. Chu, S. Xiang, S. Liao, S.Z. Li. "Face Detection Based
+           on Multi-Block LBP Representation", In Proceedings: Advances in
+           Biometrics, International Conference, ICB 2007, Seoul, Korea.
+           http://www.cbsr.ia.ac.cn/users/scliao/papers/Zhang-ICB07-MBLBP.pdf
+           :DOI:`10.1007/978-3-540-74549-5_2`
+    """
+
+    # Default colors for regions.
+    # White is for the blocks that are brighter.
+    # Cyan is for the blocks that has less intensity.
+    color_greater_block = np.asarray(color_greater_block, dtype=np.float64)
+    color_less_block = np.asarray(color_less_block, dtype=np.float64)
+
+    # Copy array to avoid the changes to the original one.
+    output = np.copy(image)
+
+    # As the visualization uses RGB color we need 3 bands.
+    if len(image.shape) < 3:
+        output = gray2rgb(image)
+
+    # Colors are specified in floats.
+    output = img_as_float(output)
+
+    # Offsets of neighbor rectangles relative to central one.
+    # It has order starting from top left and going clockwise.
+    neighbor_rect_offsets = (
+        (-1, -1),
+        (-1, 0),
+        (-1, 1),
+        (0, 1),
+        (1, 1),
+        (1, 0),
+        (1, -1),
+        (0, -1),
+    )
+
+    # Pre-multiply the offsets with width and height.
+    neighbor_rect_offsets = np.array(neighbor_rect_offsets)
+    neighbor_rect_offsets[:, 0] *= height
+    neighbor_rect_offsets[:, 1] *= width
+
+    # Top-left coordinates of central rectangle.
+    central_rect_r = r + height
+    central_rect_c = c + width
+
+    for element_num, offset in enumerate(neighbor_rect_offsets):
+        offset_r, offset_c = offset
+
+        curr_r = central_rect_r + offset_r
+        curr_c = central_rect_c + offset_c
+
+        has_greater_value = lbp_code & (1 << (7 - element_num))
+
+        # Mix-in the visualization colors.
+        if has_greater_value:
+            new_value = (1 - alpha) * output[
+                curr_r : curr_r + height, curr_c : curr_c + width
+            ] + alpha * color_greater_block
+            output[curr_r : curr_r + height, curr_c : curr_c + width] = new_value
+        else:
+            new_value = (1 - alpha) * output[
+                curr_r : curr_r + height, curr_c : curr_c + width
+            ] + alpha * color_less_block
+            output[curr_r : curr_r + height, curr_c : curr_c + width] = new_value
+
+    return output

envs/kitoverlay/skimage/feature/util.py

@@ -0,0 +1,232 @@
+import numpy as np
+
+from ..util import img_as_float
+from .._shared.utils import (
+    _supported_float_type,
+    check_nD,
+)
+
+
+class FeatureDetector:
+    def __init__(self):
+        self.keypoints_ = np.array([])
+
+    def detect(self, image):
+        """Detect keypoints in image.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+
+        """
+        raise NotImplementedError()
+
+
+class DescriptorExtractor:
+    def __init__(self):
+        self.descriptors_ = np.array([])
+
+    def extract(self, image, keypoints):
+        """Extract feature descriptors in image for given keypoints.
+
+        Parameters
+        ----------
+        image : 2D array
+            Input image.
+        keypoints : (N, 2) array
+            Keypoint locations as ``(row, col)``.
+
+        """
+        raise NotImplementedError()
+
+
+def plot_matched_features(
+    image0,
+    image1,
+    *,
+    keypoints0,
+    keypoints1,
+    matches,
+    ax,
+    keypoints_color='k',
+    matches_color=None,
+    only_matches=False,
+    alignment='horizontal',
+):
+    """Plot matched features between two images.
+
+    .. versionadded:: 0.23
+
+    Parameters
+    ----------
+    image0 : (N, M [, 3]) array
+        First image.
+    image1 : (N, M [, 3]) array
+        Second image.
+    keypoints0 : (K1, 2) array
+        First keypoint coordinates as ``(row, col)``.
+    keypoints1 : (K2, 2) array
+        Second keypoint coordinates as ``(row, col)``.
+    matches : (Q, 2) array
+        Indices of corresponding matches in first and second sets of
+        descriptors, where `matches[:, 0]` (resp. `matches[:, 1]`) contains
+        the indices in the first (resp. second) set of descriptors.
+    ax : matplotlib.axes.Axes
+        The Axes object where the images and their matched features are drawn.
+    keypoints_color : matplotlib color, optional
+        Color for keypoint locations.
+    matches_color : matplotlib color or sequence thereof, optional
+        Single color or sequence of colors for each line defined by `matches`,
+        which connect keypoint matches. See [1]_ for an overview of supported
+        color formats. By default, colors are picked randomly.
+    only_matches : bool, optional
+        Set to True to plot matches only and not the keypoint locations.
+    alignment : {'horizontal', 'vertical'}, optional
+        Whether to show the two images side by side (`'horizontal'`), or one above
+        the other (`'vertical'`).
+
+    References
+    ----------
+    .. [1] https://matplotlib.org/stable/users/explain/colors/colors.html#specifying-colors
+
+    Notes
+    -----
+    To make a sequence of colors passed to `matches_color` work for any number of
+    `matches`, you can wrap that sequence in :func:`itertools.cycle`.
+    """
+    image0 = img_as_float(image0)
+    image1 = img_as_float(image1)
+
+    new_shape0 = list(image0.shape)
+    new_shape1 = list(image1.shape)
+
+    if image0.shape[0] < image1.shape[0]:
+        new_shape0[0] = image1.shape[0]
+    elif image0.shape[0] > image1.shape[0]:
+        new_shape1[0] = image0.shape[0]
+
+    if image0.shape[1] < image1.shape[1]:
+        new_shape0[1] = image1.shape[1]
+    elif image0.shape[1] > image1.shape[1]:
+        new_shape1[1] = image0.shape[1]
+
+    if new_shape0 != image0.shape:
+        new_image0 = np.zeros(new_shape0, dtype=image0.dtype)
+        new_image0[: image0.shape[0], : image0.shape[1]] = image0
+        image0 = new_image0
+
+    if new_shape1 != image1.shape:
+        new_image1 = np.zeros(new_shape1, dtype=image1.dtype)
+        new_image1[: image1.shape[0], : image1.shape[1]] = image1
+        image1 = new_image1
+
+    offset = np.array(image0.shape)
+    if alignment == 'horizontal':
+        image = np.concatenate([image0, image1], axis=1)
+        offset[0] = 0
+    elif alignment == 'vertical':
+        image = np.concatenate([image0, image1], axis=0)
+        offset[1] = 0
+    else:
+        mesg = (
+            f"`plot_matched_features` accepts either 'horizontal' or 'vertical' for "
+            f"alignment, but '{alignment}' was given. See "
+            f"https://scikit-image.org/docs/dev/api/skimage.feature.html#skimage.feature.plot_matched_features "
+            f"for details."
+        )
+        raise ValueError(mesg)
+
+    if not only_matches:
+        ax.scatter(
+            keypoints0[:, 1],
+            keypoints0[:, 0],
+            facecolors='none',
+            edgecolors=keypoints_color,
+        )
+        ax.scatter(
+            keypoints1[:, 1] + offset[1],
+            keypoints1[:, 0] + offset[0],
+            facecolors='none',
+            edgecolors=keypoints_color,
+        )
+
+    ax.imshow(image, cmap='gray')
+    ax.axis((0, image0.shape[1] + offset[1], image0.shape[0] + offset[0], 0))
+
+    number_of_matches = matches.shape[0]
+
+    from matplotlib.colors import is_color_like
+
+    if matches_color is None:
+        rng = np.random.default_rng(seed=0)
+        colors = [rng.random(3) for _ in range(number_of_matches)]
+    elif is_color_like(matches_color):
+        colors = [matches_color for _ in range(number_of_matches)]
+    elif hasattr(matches_color, "__len__") and len(matches_color) == number_of_matches:
+        # No need to check each color, matplotlib does so for us
+        colors = matches_color
+    else:
+        error_message = (
+            '`matches_color` needs to be a single color '
+            'or a sequence of length equal to the number of matches.'
+        )
+        raise ValueError(error_message)
+
+    for i, match in enumerate(matches):
+        idx0, idx1 = match
+        ax.plot(
+            (keypoints0[idx0, 1], keypoints1[idx1, 1] + offset[1]),
+            (keypoints0[idx0, 0], keypoints1[idx1, 0] + offset[0]),
+            '-',
+            color=colors[i],
+        )
+
+
+def _prepare_grayscale_input_2D(image):
+    image = np.squeeze(image)
+    check_nD(image, 2)
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    return image.astype(float_dtype, copy=False)
+
+
+def _prepare_grayscale_input_nD(image):
+    image = np.squeeze(image)
+    check_nD(image, range(2, 6))
+    image = img_as_float(image)
+    float_dtype = _supported_float_type(image.dtype)
+    return image.astype(float_dtype, copy=False)
+
+
+def _mask_border_keypoints(image_shape, keypoints, distance):
+    """Mask coordinates that are within certain distance from the image border.
+
+    Parameters
+    ----------
+    image_shape : (2,) array_like
+        Shape of the image as ``(rows, cols)``.
+    keypoints : (N, 2) array
+        Keypoint coordinates as ``(rows, cols)``.
+    distance : int
+        Image border distance.
+
+    Returns
+    -------
+    mask : (N,) bool array
+        Mask indicating if pixels are within the image (``True``) or in the
+        border region of the image (``False``).
+
+    """
+
+    rows = image_shape[0]
+    cols = image_shape[1]
+
+    mask = (
+        ((distance - 1) < keypoints[:, 0])
+        & (keypoints[:, 0] < (rows - distance + 1))
+        & ((distance - 1) < keypoints[:, 1])
+        & (keypoints[:, 1] < (cols - distance + 1))
+    )
+
+    return mask

envs/kitoverlay/skimage/metrics/__init__.py

@@ -0,0 +1,5 @@
+"""Metrics corresponding to images, e.g., distance metrics, similarity, etc."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/metrics/__init__.pyi

@@ -0,0 +1,28 @@
+# 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__ = [
+    "adapted_rand_error",
+    "variation_of_information",
+    "contingency_table",
+    "mean_squared_error",
+    "normalized_mutual_information",
+    "normalized_root_mse",
+    "peak_signal_noise_ratio",
+    "structural_similarity",
+    "hausdorff_distance",
+    "hausdorff_pair",
+]
+
+from ._adapted_rand_error import adapted_rand_error
+from ._contingency_table import contingency_table
+from ._structural_similarity import structural_similarity
+from ._variation_of_information import variation_of_information
+from .set_metrics import hausdorff_distance, hausdorff_pair
+from .simple_metrics import (
+    mean_squared_error,
+    normalized_mutual_information,
+    normalized_root_mse,
+    peak_signal_noise_ratio,
+)

envs/kitoverlay/skimage/metrics/_adapted_rand_error.py

@@ -0,0 +1,103 @@
+from .._shared.utils import check_shape_equality
+from ._contingency_table import contingency_table
+
+__all__ = ['adapted_rand_error']
+
+
+def adapted_rand_error(
+    image_true=None, image_test=None, *, table=None, ignore_labels=(0,), alpha=0.5
+):
+    r"""Compute Adapted Rand error as defined by the SNEMI3D contest. [1]_
+
+    Parameters
+    ----------
+    image_true : ndarray of int
+        Ground-truth label image, same shape as im_test.
+    image_test : ndarray of int
+        Test image.
+    table : scipy.sparse array in crs format, optional
+        A contingency table built with skimage.evaluate.contingency_table.
+        If None, it will be computed on the fly.
+    ignore_labels : sequence of int, optional
+        Labels to ignore. Any part of the true image labeled with any of these
+        values will not be counted in the score.
+    alpha : float, optional
+        Relative weight given to precision and recall in the adapted Rand error
+        calculation.
+
+    Returns
+    -------
+    are : float
+        The adapted Rand error.
+    prec : float
+        The adapted Rand precision: this is the number of pairs of pixels that
+        have the same label in the test label image *and* in the true image,
+        divided by the number in the test image.
+    rec : float
+        The adapted Rand recall: this is the number of pairs of pixels that
+        have the same label in the test label image *and* in the true image,
+        divided by the number in the true image.
+
+    Notes
+    -----
+    Pixels with label 0 in the true segmentation are ignored in the score.
+
+    The adapted Rand error is calculated as follows:
+
+    :math:`1 - \frac{\sum_{ij} p_{ij}^{2}}{\alpha \sum_{k} s_{k}^{2} +
+    (1-\alpha)\sum_{k} t_{k}^{2}}`,
+    where :math:`p_{ij}` is the probability that a pixel has the same label
+    in the test image *and* in the true image, :math:`t_{k}` is the
+    probability that a pixel has label :math:`k` in the true image,
+    and :math:`s_{k}` is the probability that a pixel has label :math:`k`
+    in the test image.
+
+    Default behavior is to weight precision and recall equally in the
+    adapted Rand error calculation.
+    When alpha = 0, adapted Rand error = recall.
+    When alpha = 1, adapted Rand error = precision.
+
+
+    References
+    ----------
+    .. [1] Arganda-Carreras I, Turaga SC, Berger DR, et al. (2015)
+           Crowdsourcing the creation of image segmentation algorithms
+           for connectomics. Front. Neuroanat. 9:142.
+           :DOI:`10.3389/fnana.2015.00142`
+    """
+    if image_test is not None and image_true is not None:
+        check_shape_equality(image_true, image_test)
+
+    if table is None:
+        p_ij = contingency_table(
+            image_true,
+            image_test,
+            ignore_labels=ignore_labels,
+            normalize=False,
+            sparse_type="array",
+        )
+    else:
+        p_ij = table
+
+    if alpha < 0.0 or alpha > 1.0:
+        raise ValueError('alpha must be between 0 and 1')
+
+    # Sum of the joint distribution squared
+    sum_p_ij2 = p_ij.data @ p_ij.data - p_ij.sum()
+
+    a_i = p_ij.sum(axis=1).ravel()
+    b_i = p_ij.sum(axis=0).ravel()
+
+    # Sum of squares of the test segment sizes (this is 2x the number of pairs
+    # of pixels with the same label in im_test)
+    sum_a2 = a_i @ a_i - a_i.sum()
+    # Same for im_true
+    sum_b2 = b_i @ b_i - b_i.sum()
+
+    precision = sum_p_ij2 / sum_a2
+    recall = sum_p_ij2 / sum_b2
+
+    fscore = sum_p_ij2 / (alpha * sum_a2 + (1 - alpha) * sum_b2)
+    are = 1.0 - fscore
+
+    return are, precision, recall

envs/kitoverlay/skimage/metrics/_contingency_table.py

@@ -0,0 +1,51 @@
+import scipy.sparse as sparse
+import numpy as np
+
+__all__ = ['contingency_table']
+
+
+def contingency_table(
+    im_true, im_test, *, ignore_labels=None, normalize=False, sparse_type="matrix"
+):
+    """
+    Return the contingency table for all regions in matched segmentations.
+
+    Parameters
+    ----------
+    im_true : ndarray of int
+        Ground-truth label image, same shape as im_test.
+    im_test : ndarray of int
+        Test image.
+    ignore_labels : sequence of int, optional
+        Labels to ignore. Any part of the true image labeled with any of these
+        values will not be counted in the score.
+    normalize : bool
+        Determines if the contingency table is normalized by pixel count.
+    sparse_type : {"matrix", "array"}, optional
+        The return type of `cont`, either `scipy.sparse.csr_array` or
+        `scipy.sparse.csr_matrix` (default).
+
+    Returns
+    -------
+    cont : scipy.sparse.csr_matrix or scipy.sparse.csr_array
+        A contingency table. `cont[i, j]` will equal the number of voxels
+        labeled `i` in `im_true` and `j` in `im_test`. Depending on `sparse_type`,
+        this can be returned as a `scipy.sparse.csr_array`.
+    """
+
+    if ignore_labels is None:
+        ignore_labels = []
+    im_test_r = im_test.reshape(-1)
+    im_true_r = im_true.reshape(-1)
+    data = np.isin(im_true_r, ignore_labels, invert=True).astype(float)
+    if normalize:
+        data /= np.count_nonzero(data)
+    cont = sparse.csr_array((data, (im_true_r, im_test_r)))
+
+    if sparse_type == "matrix":
+        cont = sparse.csr_matrix(cont)
+    elif sparse_type != "array":
+        msg = f"`sparse_type` must be 'array' or 'matrix', got {sparse_type}"
+        raise ValueError(msg)
+
+    return cont