Add files using upload-large-folder tool

envs/kitoverlay/bin/lsm2bin

@@ -0,0 +1,8 @@
+#!/isaac-sim/kit/python/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tifffile.lsm2bin import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

envs/kitoverlay/bin/tiff2fsspec

@@ -0,0 +1,8 @@
+#!/isaac-sim/kit/python/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tifffile.tiff2fsspec import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

envs/kitoverlay/bin/tiffcomment

@@ -0,0 +1,8 @@
+#!/isaac-sim/kit/python/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tifffile.tiffcomment import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

envs/kitoverlay/bin/tifffile

@@ -0,0 +1,8 @@
+#!/isaac-sim/kit/python/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tifffile import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

envs/kitoverlay/lazy_loader-0.5.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

envs/kitoverlay/lazy_loader-0.5.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: lazy-loader
+Version: 0.5
+Summary: Makes it easy to load subpackages and functions on demand.
+Author: Scientific Python Developers
+License-Expression: BSD-3-Clause
+Project-URL: Home, https://scientific-python.org/specs/spec-0001/
+Project-URL: Source, https://github.com/scientific-python/lazy-loader
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: packaging
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-cov>=5.0; extra == "test"
+Requires-Dist: coverage[toml]>=7.2; extra == "test"
+Provides-Extra: lint
+Requires-Dist: pre-commit==4.3.0; extra == "lint"
+Provides-Extra: dev
+Requires-Dist: changelist==0.5; extra == "dev"
+Requires-Dist: spin==0.15; extra == "dev"
+Dynamic: license-file
+
+[![PyPI](https://img.shields.io/pypi/v/lazy-loader)](https://pypi.org/project/lazy-loader/)
+[![Test status](https://github.com/scientific-python/lazy-loader/workflows/test/badge.svg?branch=main)](https://github.com/scientific-python/lazy-loader/actions?query=workflow%3A%22test%22)
+[![Test coverage](https://codecov.io/gh/scientific-python/lazy-loader/branch/main/graph/badge.svg)](https://app.codecov.io/gh/scientific-python/lazy-loader/branch/main)
+
+`lazy-loader` makes it easy to load subpackages and functions on demand.
+
+## Motivation
+
+1. Allow subpackages to be made visible to users without incurring import costs.
+2. Allow external libraries to be imported only when used, improving import times.
+
+For a more detailed discussion, see [the SPEC](https://scientific-python.org/specs/spec-0001/).
+
+## Installation
+
+```
+pip install -U lazy-loader
+```
+
+We recommend using `lazy-loader` with Python >= 3.11.
+If using Python 3.11, please upgrade to 3.11.9 or later.
+If using Python 3.12, please upgrade to 3.12.3 or later.
+These versions [avoid](https://github.com/python/cpython/pull/114781) a [known race condition](https://github.com/python/cpython/issues/114763).
+
+## Usage
+
+### Lazily load subpackages
+
+Consider the `__init__.py` from [scikit-image](https://scikit-image.org):
+
+```python
+subpackages = [
+    ...,
+    'filters',
+    ...
+]
+
+import lazy_loader as lazy
+__getattr__, __dir__, _ = lazy.attach(__name__, subpackages)
+```
+
+You can now do:
+
+```python
+import skimage as ski
+ski.filters.gaussian(...)
+```
+
+The `filters` subpackages will only be loaded once accessed.
+
+### Lazily load subpackages and functions
+
+Consider `skimage/filters/__init__.py`:
+
+```python
+from ..util import lazy
+
+__getattr__, __dir__, __all__ = lazy.attach(
+    __name__,
+    submodules=['rank'],
+    submod_attrs={
+        '_gaussian': ['gaussian', 'difference_of_gaussians'],
+        'edges': ['sobel', 'scharr', 'prewitt', 'roberts',
+                  'laplace', 'farid']
+    }
+)
+```
+
+The above is equivalent to:
+
+```python
+from . import rank
+from ._gaussian import gaussian, difference_of_gaussians
+from .edges import (sobel, scharr, prewitt, roberts,
+                    laplace, farid)
+```
+
+Except that all subpackages (such as `rank`) and functions (such as `sobel`) are loaded upon access.
+
+### Type checkers
+
+Static type checkers and IDEs cannot infer type information from
+lazily loaded imports. As a workaround you can load [type
+stubs](https://mypy.readthedocs.io/en/stable/stubs.html) (`.pyi`
+files) with `lazy.attach_stub`:
+
+```python
+import lazy_loader as lazy
+__getattr__, __dir__, _ = lazy.attach_stub(__name__, "subpackages.pyi")
+```
+
+Note that, since imports are now defined in `.pyi` files, those
+are not only necessary for type checking but also at runtime.
+
+The SPEC [describes this workaround in more
+detail](https://scientific-python.org/specs/spec-0001/#type-checkers).
+
+### Early failure
+
+With lazy loading, missing imports no longer fail upon loading the
+library. During development and testing, you can set the `EAGER_IMPORT`
+environment variable to "1" or "true" to disable lazy loading ("0" or "" re-enables lazy loading).
+
+### External libraries
+
+The `lazy.attach` function discussed above is used to set up package
+internal imports.
+
+Use `lazy.load` to lazily import external libraries:
+
+```python
+sp = lazy.load('scipy')  # `sp` will only be loaded when accessed
+sp.linalg.norm(...)
+```
+
+_Note that lazily importing *sub*packages,
+i.e. `load('scipy.linalg')` will cause the package containing the
+subpackage to be imported immediately; thus, this usage is
+discouraged._
+
+You can ask `lazy.load` to raise import errors as soon as it is called:
+
+```python
+linalg = lazy.load('scipy.linalg', error_on_import=True)
+```
+
+#### Optional requirements
+
+One use for lazy loading is for loading optional dependencies, with
+`ImportErrors` only arising when optional functionality is accessed. If optional
+functionality depends on a specific version, a version requirement can
+be set:
+
+```python
+np = lazy.load("numpy", require="numpy >=1.24")
+```
+
+In this case, if `numpy` is installed, but the version is less than 1.24,
+the `np` module returned will raise an error on attribute access. Using
+this feature is not all-or-nothing: One module may rely on one version of
+numpy, while another module may not set any requirement.
+
+_Note that the requirement must use the package [distribution name][] instead
+of the module [import name][]. For example, the `pyyaml` distribution provides
+the `yaml` module for import._
+
+[distribution name]: https://packaging.python.org/en/latest/glossary/#term-Distribution-Package
+[import name]: https://packaging.python.org/en/latest/glossary/#term-Import-Package

envs/kitoverlay/lazy_loader-0.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+lazy_loader-0.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+lazy_loader-0.5.dist-info/METADATA,sha256=q2XIYmSTfYrAgNX8iV25J_8vlkoHy5L5F2jbFV_Aw3w,5919
+lazy_loader-0.5.dist-info/RECORD,,
+lazy_loader-0.5.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lazy_loader-0.5.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+lazy_loader-0.5.dist-info/licenses/LICENSE.md,sha256=eXtpN6T5doNu-7uzrjM9eGbdw-s8sVKXKyvjSNNSk3I,1539
+lazy_loader-0.5.dist-info/top_level.txt,sha256=NYVH9nn-v-w-FAbrgorNRM8g_GoewNbzC_1tptomQTQ,12
+lazy_loader/__init__.py,sha256=kBfn54D_53QrjNJYgsIsk6y5rDU_M3K43Mdqz4Mqzyk,10801
+lazy_loader/__pycache__/__init__.cpython-311.pyc,,

envs/kitoverlay/lazy_loader-0.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

envs/kitoverlay/lazy_loader-0.5.dist-info/licenses/LICENSE.md

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2022--2023, Scientific Python project
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

envs/kitoverlay/lazy_loader-0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+lazy_loader

envs/kitoverlay/skimage/color/__init__.py

@@ -0,0 +1,5 @@
+"""Color space conversion."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/color/__init__.pyi

@@ -0,0 +1,135 @@
+# 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__ = [
+    'convert_colorspace',
+    'xyz_tristimulus_values',
+    'rgba2rgb',
+    'rgb2hsv',
+    'hsv2rgb',
+    'rgb2xyz',
+    'xyz2rgb',
+    'rgb2rgbcie',
+    'rgbcie2rgb',
+    'rgb2gray',
+    'gray2rgb',
+    'gray2rgba',
+    'xyz2lab',
+    'lab2xyz',
+    'lab2rgb',
+    'rgb2lab',
+    'rgb2hed',
+    'hed2rgb',
+    'lab2lch',
+    'lch2lab',
+    'rgb2yuv',
+    'yuv2rgb',
+    'rgb2yiq',
+    'yiq2rgb',
+    'rgb2ypbpr',
+    'ypbpr2rgb',
+    'rgb2ycbcr',
+    'ycbcr2rgb',
+    'rgb2ydbdr',
+    'ydbdr2rgb',
+    'separate_stains',
+    'combine_stains',
+    'rgb_from_hed',
+    'hed_from_rgb',
+    'rgb_from_hdx',
+    'hdx_from_rgb',
+    'rgb_from_fgx',
+    'fgx_from_rgb',
+    'rgb_from_bex',
+    'bex_from_rgb',
+    'rgb_from_rbd',
+    'rbd_from_rgb',
+    'rgb_from_gdx',
+    'gdx_from_rgb',
+    'rgb_from_hax',
+    'hax_from_rgb',
+    'rgb_from_bro',
+    'bro_from_rgb',
+    'rgb_from_bpx',
+    'bpx_from_rgb',
+    'rgb_from_ahx',
+    'ahx_from_rgb',
+    'rgb_from_hpx',
+    'hpx_from_rgb',
+    'color_dict',
+    'label2rgb',
+    'deltaE_cie76',
+    'deltaE_ciede94',
+    'deltaE_ciede2000',
+    'deltaE_cmc',
+]
+
+from .colorconv import (
+    convert_colorspace,
+    xyz_tristimulus_values,
+    rgba2rgb,
+    rgb2hsv,
+    hsv2rgb,
+    rgb2xyz,
+    xyz2rgb,
+    rgb2rgbcie,
+    rgbcie2rgb,
+    rgb2gray,
+    gray2rgb,
+    gray2rgba,
+    xyz2lab,
+    lab2xyz,
+    lab2rgb,
+    rgb2lab,
+    xyz2luv,
+    luv2xyz,
+    luv2rgb,
+    rgb2luv,
+    rgb2hed,
+    hed2rgb,
+    lab2lch,
+    lch2lab,
+    rgb2yuv,
+    yuv2rgb,
+    rgb2yiq,
+    yiq2rgb,
+    rgb2ypbpr,
+    ypbpr2rgb,
+    rgb2ycbcr,
+    ycbcr2rgb,
+    rgb2ydbdr,
+    ydbdr2rgb,
+    separate_stains,
+    combine_stains,
+    rgb_from_hed,
+    hed_from_rgb,
+    rgb_from_hdx,
+    hdx_from_rgb,
+    rgb_from_fgx,
+    fgx_from_rgb,
+    rgb_from_bex,
+    bex_from_rgb,
+    rgb_from_rbd,
+    rbd_from_rgb,
+    rgb_from_gdx,
+    gdx_from_rgb,
+    rgb_from_hax,
+    hax_from_rgb,
+    rgb_from_bro,
+    bro_from_rgb,
+    rgb_from_bpx,
+    bpx_from_rgb,
+    rgb_from_ahx,
+    ahx_from_rgb,
+    rgb_from_hpx,
+    hpx_from_rgb,
+)
+
+from .colorlabel import color_dict, label2rgb
+from .delta_e import (
+    deltaE_cie76,
+    deltaE_ciede94,
+    deltaE_ciede2000,
+    deltaE_cmc,
+)

envs/kitoverlay/skimage/color/adapt_rgb.py

@@ -0,0 +1,81 @@
+import functools
+
+import numpy as np
+
+from .. import color
+from ..util.dtype import _convert
+
+
+__all__ = ['adapt_rgb', 'hsv_value', 'each_channel']
+
+
+def is_rgb_like(image, channel_axis=-1):
+    """Return True if the image *looks* like it's RGB.
+
+    This function should not be public because it is only intended to be used
+    for functions that don't accept volumes as input, since checking an image's
+    shape is fragile.
+    """
+    return (image.ndim == 3) and (image.shape[channel_axis] in (3, 4))
+
+
+def adapt_rgb(apply_to_rgb):
+    """Return decorator that adapts to RGB images to a gray-scale filter.
+
+    This function is only intended to be used for functions that don't accept
+    volumes as input, since checking an image's shape is fragile.
+
+    Parameters
+    ----------
+    apply_to_rgb : function
+        Function that returns a filtered image from an image-filter and RGB
+        image. This will only be called if the image is RGB-like.
+    """
+
+    def decorator(image_filter):
+        @functools.wraps(image_filter)
+        def image_filter_adapted(image, *args, **kwargs):
+            if is_rgb_like(image):
+                return apply_to_rgb(image_filter, image, *args, **kwargs)
+            else:
+                return image_filter(image, *args, **kwargs)
+
+        return image_filter_adapted
+
+    return decorator
+
+
+def hsv_value(image_filter, image, *args, **kwargs):
+    """Return color image by applying `image_filter` on HSV-value of `image`.
+
+    Note that this function is intended for use with `adapt_rgb`.
+
+    Parameters
+    ----------
+    image_filter : function
+        Function that filters a gray-scale image.
+    image : array
+        Input image. Note that RGBA images are treated as RGB.
+    """
+    # Slice the first three channels so that we remove any alpha channels.
+    hsv = color.rgb2hsv(image[:, :, :3])
+    value = hsv[:, :, 2].copy()
+    value = image_filter(value, *args, **kwargs)
+    hsv[:, :, 2] = _convert(value, hsv.dtype)
+    return color.hsv2rgb(hsv)
+
+
+def each_channel(image_filter, image, *args, **kwargs):
+    """Return color image by applying `image_filter` on channels of `image`.
+
+    Note that this function is intended for use with `adapt_rgb`.
+
+    Parameters
+    ----------
+    image_filter : function
+        Function that filters a gray-scale image.
+    image : array
+        Input image.
+    """
+    c_new = [image_filter(c, *args, **kwargs) for c in np.moveaxis(image, -1, 0)]
+    return np.stack(c_new, axis=-1)

envs/kitoverlay/skimage/color/colorconv.py

@@ -0,0 +1,2314 @@
+"""Functions for converting between color spaces.
+
+The "central" color space in this module is RGB, more specifically the linear
+sRGB color space using D65 as a white-point [1]_.  This represents a
+standard monitor (w/o gamma correction). For a good FAQ on color spaces see
+[2]_.
+
+The API consists of functions to convert to and from RGB as defined above, as
+well as a generic function to convert to and from any supported color space
+(which is done through RGB in most cases).
+
+
+Supported color spaces
+----------------------
+* RGB : Red Green Blue.
+        Here the sRGB standard [1]_.
+* HSV : Hue, Saturation, Value.
+        Uniquely defined when related to sRGB [3]_.
+* RGB CIE : Red Green Blue.
+        The original RGB CIE standard from 1931 [4]_. Primary colors are 700 nm
+        (red), 546.1 nm (blue) and 435.8 nm (green).
+* XYZ CIE : XYZ
+        Derived from the RGB CIE color space. Chosen such that
+        ``x == y == z == 1/3`` at the whitepoint, and all color matching
+        functions are greater than zero everywhere.
+* LAB CIE : Lightness, a, b
+        Colorspace derived from XYZ CIE that is intended to be more
+        perceptually uniform
+* LUV CIE : Lightness, u, v
+        Colorspace derived from XYZ CIE that is intended to be more
+        perceptually uniform
+* LCH CIE : Lightness, Chroma, Hue
+        Defined in terms of LAB CIE.  C and H are the polar representation of
+        a and b.  The polar angle C is defined to be on ``(0, 2*pi)``
+
+:author: Nicolas Pinto (rgb2hsv)
+:author: Ralf Gommers (hsv2rgb)
+:author: Travis Oliphant (XYZ and RGB CIE functions)
+:author: Matt Terry (lab2lch)
+:author: Alex Izvorski (yuv2rgb, rgb2yuv and related)
+
+:license: modified BSD
+
+References
+----------
+.. [1] Official specification of sRGB, IEC 61966-2-1:1999.
+.. [2] http://www.poynton.com/ColorFAQ.html
+.. [3] https://en.wikipedia.org/wiki/HSL_and_HSV
+.. [4] https://en.wikipedia.org/wiki/CIE_1931_color_space
+"""
+
+from warnings import warn
+
+import numpy as np
+from scipy import linalg
+
+
+from .._shared.utils import (
+    _supported_float_type,
+    channel_as_last_axis,
+    identity,
+    reshape_nd,
+    slice_at_axis,
+)
+from ..util import dtype, dtype_limits
+
+# TODO: when minimum numpy dependency is 1.25 use:
+# np..exceptions.AxisError instead of AxisError
+# and remove this try-except
+try:
+    from numpy import AxisError
+except ImportError:
+    from numpy.exceptions import AxisError
+
+
+def convert_colorspace(arr, fromspace, tospace, *, channel_axis=-1):
+    """Convert an image array to a new color space.
+
+    Valid color spaces are:
+        'RGB', 'HSV', 'RGB CIE', 'XYZ', 'YUV', 'YIQ', 'YPbPr', 'YCbCr', 'YDbDr'
+
+    Parameters
+    ----------
+    arr : (..., C=3, ...) array_like
+        The image to convert. By default, the final dimension denotes
+        channels.
+    fromspace : str
+        The color space to convert from. Can be specified in lower case.
+    tospace : str
+        The color space to convert to. Can be specified in lower case.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The converted image. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If fromspace is not a valid color space
+    ValueError
+        If tospace is not a valid color space
+
+    Notes
+    -----
+    Conversion is performed through the "central" RGB color space,
+    i.e. conversion from XYZ to HSV is implemented as ``XYZ -> RGB -> HSV``
+    instead of directly.
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> img = data.astronaut()
+    >>> img_hsv = convert_colorspace(img, 'RGB', 'HSV')
+    """
+    fromdict = {
+        'rgb': identity,
+        'hsv': hsv2rgb,
+        'rgb cie': rgbcie2rgb,
+        'xyz': xyz2rgb,
+        'yuv': yuv2rgb,
+        'yiq': yiq2rgb,
+        'ypbpr': ypbpr2rgb,
+        'ycbcr': ycbcr2rgb,
+        'ydbdr': ydbdr2rgb,
+    }
+    todict = {
+        'rgb': identity,
+        'hsv': rgb2hsv,
+        'rgb cie': rgb2rgbcie,
+        'xyz': rgb2xyz,
+        'yuv': rgb2yuv,
+        'yiq': rgb2yiq,
+        'ypbpr': rgb2ypbpr,
+        'ycbcr': rgb2ycbcr,
+        'ydbdr': rgb2ydbdr,
+    }
+
+    fromspace = fromspace.lower()
+    tospace = tospace.lower()
+    if fromspace not in fromdict:
+        msg = f'`fromspace` has to be one of {fromdict.keys()}'
+        raise ValueError(msg)
+    if tospace not in todict:
+        msg = f'`tospace` has to be one of {todict.keys()}'
+        raise ValueError(msg)
+
+    return todict[tospace](
+        fromdict[fromspace](arr, channel_axis=channel_axis), channel_axis=channel_axis
+    )
+
+
+def _prepare_colorarray(arr, force_copy=False, *, channel_axis=-1):
+    """Check the shape of the array and convert it to
+    floating point representation.
+    """
+    arr = np.asanyarray(arr)
+
+    if arr.shape[channel_axis] != 3:
+        msg = (
+            f'the input array must have size 3 along `channel_axis`, '
+            f'got {arr.shape}'
+        )
+        raise ValueError(msg)
+
+    float_dtype = _supported_float_type(arr.dtype)
+    if float_dtype == np.float32:
+        _func = dtype.img_as_float32
+    else:
+        _func = dtype.img_as_float64
+    return _func(arr, force_copy=force_copy)
+
+
+def _validate_channel_axis(channel_axis, ndim):
+    if not isinstance(channel_axis, int):
+        raise TypeError("channel_axis must be an integer")
+    if channel_axis < -ndim or channel_axis >= ndim:
+        raise AxisError("channel_axis exceeds array dimensions")
+
+
+def rgba2rgb(rgba, background=(1, 1, 1), *, channel_axis=-1):
+    """RGBA to RGB conversion using alpha blending [1]_.
+
+    Parameters
+    ----------
+    rgba : (..., C=4, ...) array_like
+        The image in RGBA format. By default, the final dimension denotes
+        channels.
+    background : array_like
+        The color of the background to blend the image with (3 floats
+        between 0 to 1 - the RGB value of the background).
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgba` is not at least 2D with shape (..., 4, ...).
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending
+
+    Examples
+    --------
+    >>> from skimage import color
+    >>> from skimage import data
+    >>> img_rgba = data.logo()
+    >>> img_rgb = color.rgba2rgb(img_rgba)
+    """
+    arr = np.asanyarray(rgba)
+    _validate_channel_axis(channel_axis, arr.ndim)
+    channel_axis = channel_axis % arr.ndim
+
+    if arr.shape[channel_axis] != 4:
+        msg = (
+            f'the input array must have size 4 along `channel_axis`, '
+            f'got {arr.shape}'
+        )
+        raise ValueError(msg)
+
+    float_dtype = _supported_float_type(arr.dtype)
+    if float_dtype == np.float32:
+        arr = dtype.img_as_float32(arr)
+    else:
+        arr = dtype.img_as_float64(arr)
+
+    background = np.ravel(background).astype(arr.dtype)
+    if len(background) != 3:
+        raise ValueError(
+            'background must be an array-like containing 3 RGB '
+            f'values. Got {len(background)} items'
+        )
+    if np.any(background < 0) or np.any(background > 1):
+        raise ValueError('background RGB values must be floats between ' '0 and 1.')
+    # reshape background for broadcasting along non-channel axes
+    background = reshape_nd(background, arr.ndim, channel_axis)
+
+    alpha = arr[slice_at_axis(slice(3, 4), axis=channel_axis)]
+    channels = arr[slice_at_axis(slice(3), axis=channel_axis)]
+    out = np.clip((1 - alpha) * background + alpha * channels, a_min=0, a_max=1)
+    return out
+
+
+@channel_as_last_axis()
+def rgb2hsv(rgb, *, channel_axis=-1):
+    """RGB to HSV color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in HSV format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    Conversion between RGB and HSV color spaces results in some loss of
+    precision, due to integer arithmetic and rounding [1]_.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/HSL_and_HSV
+
+    Examples
+    --------
+    >>> from skimage import color
+    >>> from skimage import data
+    >>> img = data.astronaut()
+    >>> img_hsv = color.rgb2hsv(img)
+    """
+    input_is_one_pixel = rgb.ndim == 1
+    if input_is_one_pixel:
+        rgb = rgb[np.newaxis, ...]
+
+    arr = _prepare_colorarray(rgb, channel_axis=-1)
+    out = np.empty_like(arr)
+
+    # -- V channel
+    out_v = arr.max(-1)
+
+    # -- S channel
+    delta = np.ptp(arr, axis=-1)
+    # Ignore warning for zero divided by zero
+    old_settings = np.seterr(invalid='ignore')
+    out_s = delta / out_v
+    out_s[delta == 0.0] = 0.0
+
+    # -- H channel
+    # red is max
+    idx = arr[..., 0] == out_v
+    out[idx, 0] = (arr[idx, 1] - arr[idx, 2]) / delta[idx]
+
+    # green is max
+    idx = arr[..., 1] == out_v
+    out[idx, 0] = 2.0 + (arr[idx, 2] - arr[idx, 0]) / delta[idx]
+
+    # blue is max
+    idx = arr[..., 2] == out_v
+    out[idx, 0] = 4.0 + (arr[idx, 0] - arr[idx, 1]) / delta[idx]
+    out_h = (out[..., 0] / 6.0) % 1.0
+    out_h[delta == 0.0] = 0.0
+
+    np.seterr(**old_settings)
+
+    # -- output
+    out[..., 0] = out_h
+    out[..., 1] = out_s
+    out[..., 2] = out_v
+
+    # # remove NaN
+    out[np.isnan(out)] = 0
+
+    if input_is_one_pixel:
+        out = np.squeeze(out, axis=0)
+
+    return out
+
+
+@channel_as_last_axis()
+def hsv2rgb(hsv, *, channel_axis=-1):
+    """HSV to RGB color space conversion.
+
+    Parameters
+    ----------
+    hsv : (..., C=3, ...) array_like
+        The image in HSV format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `hsv` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    Conversion between RGB and HSV color spaces results in some loss of
+    precision, due to integer arithmetic and rounding [1]_.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/HSL_and_HSV
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> img = data.astronaut()
+    >>> img_hsv = rgb2hsv(img)
+    >>> img_rgb = hsv2rgb(img_hsv)
+    """
+    arr = _prepare_colorarray(hsv, channel_axis=-1)
+
+    hi = np.floor(arr[..., 0] * 6)
+    f = arr[..., 0] * 6 - hi
+    p = arr[..., 2] * (1 - arr[..., 1])
+    q = arr[..., 2] * (1 - f * arr[..., 1])
+    t = arr[..., 2] * (1 - (1 - f) * arr[..., 1])
+    v = arr[..., 2]
+
+    hi = np.stack([hi, hi, hi], axis=-1).astype(np.uint8) % 6
+    out = np.choose(
+        hi,
+        np.stack(
+            [
+                np.stack((v, t, p), axis=-1),
+                np.stack((q, v, p), axis=-1),
+                np.stack((p, v, t), axis=-1),
+                np.stack((p, q, v), axis=-1),
+                np.stack((t, p, v), axis=-1),
+                np.stack((v, p, q), axis=-1),
+            ]
+        ),
+    )
+
+    return out
+
+
+# ---------------------------------------------------------------
+# Primaries for the coordinate systems
+# ---------------------------------------------------------------
+cie_primaries = np.array([700, 546.1, 435.8])
+sb_primaries = np.array([1.0 / 155, 1.0 / 190, 1.0 / 225]) * 1e5
+
+# ---------------------------------------------------------------
+# Matrices that define conversion between different color spaces
+# ---------------------------------------------------------------
+
+# From sRGB specification
+xyz_from_rgb = np.array(
+    [
+        [0.412453, 0.357580, 0.180423],
+        [0.212671, 0.715160, 0.072169],
+        [0.019334, 0.119193, 0.950227],
+    ]
+)
+
+rgb_from_xyz = linalg.inv(xyz_from_rgb)
+
+# From https://en.wikipedia.org/wiki/CIE_1931_color_space
+# Note: Travis's code did not have the divide by 0.17697
+xyz_from_rgbcie = (
+    np.array([[0.49, 0.31, 0.20], [0.17697, 0.81240, 0.01063], [0.00, 0.01, 0.99]])
+    / 0.17697
+)
+
+rgbcie_from_xyz = linalg.inv(xyz_from_rgbcie)
+
+# construct matrices to and from rgb:
+rgbcie_from_rgb = rgbcie_from_xyz @ xyz_from_rgb
+rgb_from_rgbcie = rgb_from_xyz @ xyz_from_rgbcie
+
+
+gray_from_rgb = np.array([[0.2125, 0.7154, 0.0721], [0, 0, 0], [0, 0, 0]])
+
+yuv_from_rgb = np.array(
+    [
+        [0.299, 0.587, 0.114],
+        [-0.14714119, -0.28886916, 0.43601035],
+        [0.61497538, -0.51496512, -0.10001026],
+    ]
+)
+
+rgb_from_yuv = linalg.inv(yuv_from_rgb)
+
+yiq_from_rgb = np.array(
+    [
+        [0.299, 0.587, 0.114],
+        [0.59590059, -0.27455667, -0.32134392],
+        [0.21153661, -0.52273617, 0.31119955],
+    ]
+)
+
+rgb_from_yiq = linalg.inv(yiq_from_rgb)
+
+ypbpr_from_rgb = np.array(
+    [[0.299, 0.587, 0.114], [-0.168736, -0.331264, 0.5], [0.5, -0.418688, -0.081312]]
+)
+
+rgb_from_ypbpr = linalg.inv(ypbpr_from_rgb)
+
+ycbcr_from_rgb = np.array(
+    [[65.481, 128.553, 24.966], [-37.797, -74.203, 112.0], [112.0, -93.786, -18.214]]
+)
+
+rgb_from_ycbcr = linalg.inv(ycbcr_from_rgb)
+
+ydbdr_from_rgb = np.array(
+    [[0.299, 0.587, 0.114], [-0.45, -0.883, 1.333], [-1.333, 1.116, 0.217]]
+)
+
+rgb_from_ydbdr = linalg.inv(ydbdr_from_rgb)
+
+
+# CIE LAB constants for Observer=2A, Illuminant=D65
+# NOTE: this is actually the XYZ values for the illuminant above.
+lab_ref_white = np.array([0.95047, 1.0, 1.08883])
+
+# CIE XYZ tristimulus values of the illuminants, scaled to [0, 1]. For each illuminant I
+# we have:
+#
+#   illuminant[I]['2'] corresponds to the CIE XYZ tristimulus values for the 2 degree
+#   field of view.
+#
+#   illuminant[I]['10'] corresponds to the CIE XYZ tristimulus values for the 10 degree
+#   field of view.
+#
+#   illuminant[I]['R'] corresponds to the CIE XYZ tristimulus values for R illuminants
+#   in grDevices::convertColor
+#
+# The CIE XYZ tristimulus values are calculated from [1], using the formula:
+#
+#   X = x * ( Y / y )
+#   Y = Y
+#   Z = ( 1 - x - y ) * ( Y / y )
+#
+# where Y = 1. The only exception is the illuminant "D65" with aperture angle
+# 2, whose coordinates are copied from 'lab_ref_white' for
+# backward-compatibility reasons.
+#
+#     References
+#    ----------
+#    .. [1] https://en.wikipedia.org/wiki/Standard_illuminant
+
+_illuminants = {
+    "A": {
+        '2': (1.098466069456375, 1, 0.3558228003436005),
+        '10': (1.111420406956693, 1, 0.3519978321919493),
+        'R': (1.098466069456375, 1, 0.3558228003436005),
+    },
+    "B": {
+        '2': (0.9909274480248003, 1, 0.8531327322886154),
+        '10': (0.9917777147717607, 1, 0.8434930535866175),
+        'R': (0.9909274480248003, 1, 0.8531327322886154),
+    },
+    "C": {
+        '2': (0.980705971659919, 1, 1.1822494939271255),
+        '10': (0.9728569189782166, 1, 1.1614480488951577),
+        'R': (0.980705971659919, 1, 1.1822494939271255),
+    },
+    "D50": {
+        '2': (0.9642119944211994, 1, 0.8251882845188288),
+        '10': (0.9672062750333777, 1, 0.8142801513128616),
+        'R': (0.9639501491621826, 1, 0.8241280285499208),
+    },
+    "D55": {
+        '2': (0.956797052643698, 1, 0.9214805860173273),
+        '10': (0.9579665682254781, 1, 0.9092525159847462),
+        'R': (0.9565317453467969, 1, 0.9202554587037198),
+    },
+    "D65": {
+        '2': (0.95047, 1.0, 1.08883),  # This was: `lab_ref_white`
+        '10': (0.94809667673716, 1, 1.0730513595166162),
+        'R': (0.9532057125493769, 1, 1.0853843816469158),
+    },
+    "D75": {
+        '2': (0.9497220898840717, 1, 1.226393520724154),
+        '10': (0.9441713925645873, 1, 1.2064272211720228),
+        'R': (0.9497220898840717, 1, 1.226393520724154),
+    },
+    "E": {'2': (1.0, 1.0, 1.0), '10': (1.0, 1.0, 1.0), 'R': (1.0, 1.0, 1.0)},
+}
+
+
+def xyz_tristimulus_values(*, illuminant, observer, dtype=float):
+    """Get the CIE XYZ tristimulus values.
+
+    Given an illuminant and observer, this function returns the CIE XYZ tristimulus
+    values [2]_ scaled such that :math:`Y = 1`.
+
+    Parameters
+    ----------
+    illuminant : {"A", "B", "C", "D50", "D55", "D65", "D75", "E"}
+        The name of the illuminant (the function is NOT case sensitive).
+    observer : {"2", "10", "R"}
+        One of: 2-degree observer, 10-degree observer, or 'R' observer as in
+        R function ``grDevices::convertColor`` [3]_.
+    dtype : dtype, optional
+        Output data type.
+
+    Returns
+    -------
+    values : array
+        Array with 3 elements :math:`X, Y, Z` containing the CIE XYZ tristimulus values
+        of the given illuminant.
+
+    Raises
+    ------
+    ValueError
+        If either the illuminant or the observer angle are not supported or
+        unknown.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Standard_illuminant#White_points_of_standard_illuminants
+    .. [2] https://en.wikipedia.org/wiki/CIE_1931_color_space#Meaning_of_X,_Y_and_Z
+    .. [3] https://www.rdocumentation.org/packages/grDevices/versions/3.6.2/topics/convertColor
+
+    Notes
+    -----
+    The CIE XYZ tristimulus values are calculated from :math:`x, y` [1]_, using the
+    formula
+
+    .. math:: X = x / y
+
+    .. math:: Y = 1
+
+    .. math:: Z = (1 - x - y) / y
+
+    The only exception is the illuminant "D65" with aperture angle 2° for
+    backward-compatibility reasons.
+
+    Examples
+    --------
+    Get the CIE XYZ tristimulus values for a "D65" illuminant for a 10 degree field of
+    view
+
+    >>> xyz_tristimulus_values(illuminant="D65", observer="10")
+    array([0.94809668, 1.        , 1.07305136])
+    """
+    illuminant = illuminant.upper()
+    observer = observer.upper()
+    try:
+        return np.asarray(_illuminants[illuminant][observer], dtype=dtype)
+    except KeyError:
+        raise ValueError(
+            f'Unknown illuminant/observer combination '
+            f'(`{illuminant}`, `{observer}`)'
+        )
+
+
+# Haematoxylin-Eosin-DAB colorspace
+# From original Ruifrok's paper: A. C. Ruifrok and D. A. Johnston,
+# "Quantification of histochemical staining by color deconvolution,"
+# Analytical and quantitative cytology and histology / the International
+# Academy of Cytology [and] American Society of Cytology, vol. 23, no. 4,
+# pp. 291-9, Aug. 2001.
+rgb_from_hed = np.array([[0.65, 0.70, 0.29], [0.07, 0.99, 0.11], [0.27, 0.57, 0.78]])
+hed_from_rgb = linalg.inv(rgb_from_hed)
+
+# Following matrices are adapted form the Java code written by G.Landini.
+# The original code is available at:
+# https://web.archive.org/web/20160624145052/http://www.mecourse.com/landinig/software/cdeconv/cdeconv.html
+
+# Hematoxylin + DAB
+rgb_from_hdx = np.array([[0.650, 0.704, 0.286], [0.268, 0.570, 0.776], [0.0, 0.0, 0.0]])
+rgb_from_hdx[2, :] = np.cross(rgb_from_hdx[0, :], rgb_from_hdx[1, :])
+hdx_from_rgb = linalg.inv(rgb_from_hdx)
+
+# Feulgen + Light Green
+rgb_from_fgx = np.array(
+    [
+        [0.46420921, 0.83008335, 0.30827187],
+        [0.94705542, 0.25373821, 0.19650764],
+        [0.0, 0.0, 0.0],
+    ]
+)
+rgb_from_fgx[2, :] = np.cross(rgb_from_fgx[0, :], rgb_from_fgx[1, :])
+fgx_from_rgb = linalg.inv(rgb_from_fgx)
+
+# Giemsa: Methyl Blue + Eosin
+rgb_from_bex = np.array(
+    [
+        [0.834750233, 0.513556283, 0.196330403],
+        [0.092789, 0.954111, 0.283111],
+        [0.0, 0.0, 0.0],
+    ]
+)
+rgb_from_bex[2, :] = np.cross(rgb_from_bex[0, :], rgb_from_bex[1, :])
+bex_from_rgb = linalg.inv(rgb_from_bex)
+
+# FastRed + FastBlue +  DAB
+rgb_from_rbd = np.array(
+    [
+        [0.21393921, 0.85112669, 0.47794022],
+        [0.74890292, 0.60624161, 0.26731082],
+        [0.268, 0.570, 0.776],
+    ]
+)
+rbd_from_rgb = linalg.inv(rgb_from_rbd)
+
+# Methyl Green + DAB
+rgb_from_gdx = np.array(
+    [[0.98003, 0.144316, 0.133146], [0.268, 0.570, 0.776], [0.0, 0.0, 0.0]]
+)
+rgb_from_gdx[2, :] = np.cross(rgb_from_gdx[0, :], rgb_from_gdx[1, :])
+gdx_from_rgb = linalg.inv(rgb_from_gdx)
+
+# Hematoxylin + AEC
+rgb_from_hax = np.array(
+    [[0.650, 0.704, 0.286], [0.2743, 0.6796, 0.6803], [0.0, 0.0, 0.0]]
+)
+rgb_from_hax[2, :] = np.cross(rgb_from_hax[0, :], rgb_from_hax[1, :])
+hax_from_rgb = linalg.inv(rgb_from_hax)
+
+# Blue matrix Anilline Blue + Red matrix Azocarmine + Orange matrix Orange-G
+rgb_from_bro = np.array(
+    [
+        [0.853033, 0.508733, 0.112656],
+        [0.09289875, 0.8662008, 0.49098468],
+        [0.10732849, 0.36765403, 0.9237484],
+    ]
+)
+bro_from_rgb = linalg.inv(rgb_from_bro)
+
+# Methyl Blue + Ponceau Fuchsin
+rgb_from_bpx = np.array(
+    [
+        [0.7995107, 0.5913521, 0.10528667],
+        [0.09997159, 0.73738605, 0.6680326],
+        [0.0, 0.0, 0.0],
+    ]
+)
+rgb_from_bpx[2, :] = np.cross(rgb_from_bpx[0, :], rgb_from_bpx[1, :])
+bpx_from_rgb = linalg.inv(rgb_from_bpx)
+
+# Alcian Blue + Hematoxylin
+rgb_from_ahx = np.array(
+    [[0.874622, 0.457711, 0.158256], [0.552556, 0.7544, 0.353744], [0.0, 0.0, 0.0]]
+)
+rgb_from_ahx[2, :] = np.cross(rgb_from_ahx[0, :], rgb_from_ahx[1, :])
+ahx_from_rgb = linalg.inv(rgb_from_ahx)
+
+# Hematoxylin + PAS
+rgb_from_hpx = np.array(
+    [[0.644211, 0.716556, 0.266844], [0.175411, 0.972178, 0.154589], [0.0, 0.0, 0.0]]
+)
+rgb_from_hpx[2, :] = np.cross(rgb_from_hpx[0, :], rgb_from_hpx[1, :])
+hpx_from_rgb = linalg.inv(rgb_from_hpx)
+
+# -------------------------------------------------------------
+# The conversion functions that make use of the matrices above
+# -------------------------------------------------------------
+
+
+def _convert(matrix, arr):
+    """Do the color space conversion.
+
+    Parameters
+    ----------
+    matrix : array_like
+        The 3x3 matrix to use.
+    arr : (..., C=3, ...) array_like
+        The input array. By default, the final dimension denotes
+        channels.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The converted array. Same dimensions as input.
+    """
+    arr = _prepare_colorarray(arr)
+
+    return arr @ matrix.T.astype(arr.dtype)
+
+
+@channel_as_last_axis()
+def xyz2rgb(xyz, *, channel_axis=-1):
+    """XYZ to RGB color space conversion.
+
+    Parameters
+    ----------
+    xyz : (..., C=3, ...) array_like
+        The image in XYZ format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `xyz` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    The CIE XYZ color space is derived from the CIE RGB color space. Note
+    however that this function converts to sRGB.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/CIE_1931_color_space
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2xyz, xyz2rgb
+    >>> img = data.astronaut()
+    >>> img_xyz = rgb2xyz(img)
+    >>> img_rgb = xyz2rgb(img_xyz)
+    """
+    # Follow the algorithm from http://www.easyrgb.com/index.php
+    # except we don't multiply/divide by 100 in the conversion
+    arr = _convert(rgb_from_xyz, xyz)
+    mask = arr > 0.0031308
+    arr[mask] = 1.055 * np.power(arr[mask], 1 / 2.4) - 0.055
+    arr[~mask] *= 12.92
+    np.clip(arr, 0, 1, out=arr)
+    return arr
+
+
+@channel_as_last_axis()
+def rgb2xyz(rgb, *, channel_axis=-1):
+    """RGB to XYZ color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in XYZ format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    The CIE XYZ color space is derived from the CIE RGB color space. Note
+    however that this function converts from sRGB.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/CIE_1931_color_space
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> img = data.astronaut()
+    >>> img_xyz = rgb2xyz(img)
+    """
+    # Follow the algorithm from http://www.easyrgb.com/index.php
+    # except we don't multiply/divide by 100 in the conversion
+    arr = _prepare_colorarray(rgb, channel_axis=-1).copy()
+    mask = arr > 0.04045
+    arr[mask] = np.power((arr[mask] + 0.055) / 1.055, 2.4)
+    arr[~mask] /= 12.92
+    return arr @ xyz_from_rgb.T.astype(arr.dtype)
+
+
+@channel_as_last_axis()
+def rgb2rgbcie(rgb, *, channel_axis=-1):
+    """RGB to RGB CIE color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB CIE format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/CIE_1931_color_space
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2rgbcie
+    >>> img = data.astronaut()
+    >>> img_rgbcie = rgb2rgbcie(img)
+    """
+    return _convert(rgbcie_from_rgb, rgb)
+
+
+@channel_as_last_axis()
+def rgbcie2rgb(rgbcie, *, channel_axis=-1):
+    """RGB CIE to RGB color space conversion.
+
+    Parameters
+    ----------
+    rgbcie : (..., C=3, ...) array_like
+        The image in RGB CIE format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgbcie` is not at least 2-D with shape (..., C=3, ...).
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/CIE_1931_color_space
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2rgbcie, rgbcie2rgb
+    >>> img = data.astronaut()
+    >>> img_rgbcie = rgb2rgbcie(img)
+    >>> img_rgb = rgbcie2rgb(img_rgbcie)
+    """
+    return _convert(rgb_from_rgbcie, rgbcie)
+
+
+@channel_as_last_axis(multichannel_output=False)
+def rgb2gray(rgb, *, channel_axis=-1):
+    """Compute luminance of an RGB image.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+
+    Returns
+    -------
+    out : ndarray
+        The luminance image - an array which is the same size as the input
+        array, but with the channel dimension removed.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    The weights used in this conversion are calibrated for contemporary
+    CRT phosphors::
+
+        Y = 0.2125 R + 0.7154 G + 0.0721 B
+
+    If there is an alpha channel present, it is ignored.
+
+    References
+    ----------
+    .. [1] http://poynton.ca/PDFs/ColorFAQ.pdf
+
+    Examples
+    --------
+    >>> from skimage.color import rgb2gray
+    >>> from skimage import data
+    >>> img = data.astronaut()
+    >>> img_gray = rgb2gray(img)
+    """
+    rgb = _prepare_colorarray(rgb)
+    coeffs = np.array([0.2125, 0.7154, 0.0721], dtype=rgb.dtype)
+    return rgb @ coeffs
+
+
+def gray2rgba(image, alpha=None, *, channel_axis=-1):
+    """Create a RGBA representation of a gray-level image.
+
+    Parameters
+    ----------
+    image : array_like
+        Input image.
+    alpha : array_like, optional
+        Alpha channel of the output image. It may be a scalar or an
+        array that can be broadcast to ``image``. If not specified it is
+        set to the maximum limit corresponding to the ``image`` dtype.
+    channel_axis : int, optional
+        This parameter indicates which axis of the output array will correspond
+        to channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    rgba : ndarray
+        RGBA image. A new dimension of length 4 is added to input
+        image shape.
+    """
+    arr = np.asarray(image)
+    if alpha is None:
+        _, alpha = dtype_limits(arr, clip_negative=False)
+    with np.errstate(over="ignore", under="ignore"):
+        alpha_arr = np.asarray(alpha).astype(arr.dtype)
+    if not np.array_equal(alpha_arr, alpha):
+        warn(
+            f'alpha cannot be safely cast to image dtype {arr.dtype.name}', stacklevel=2
+        )
+    try:
+        alpha_arr = np.broadcast_to(alpha_arr, arr.shape)
+    except ValueError as e:
+        raise ValueError("alpha.shape must match image.shape") from e
+    rgba = np.stack((arr,) * 3 + (alpha_arr,), axis=channel_axis)
+    return rgba
+
+
+def gray2rgb(image, *, channel_axis=-1):
+    """Create an RGB representation of a gray-level image.
+
+    Parameters
+    ----------
+    image : array_like
+        Input image.
+    channel_axis : int, optional
+        This parameter indicates which axis of the output array will correspond
+        to channels.
+
+    Returns
+    -------
+    rgb : (..., C=3, ...) ndarray
+        RGB image. A new dimension of length 3 is added to input image.
+
+    Notes
+    -----
+    If the input is a 1-dimensional image of shape ``(M,)``, the output
+    will be shape ``(M, C=3)``.
+    """
+    return np.stack(3 * (image,), axis=channel_axis)
+
+
+@channel_as_last_axis()
+def xyz2lab(xyz, illuminant="D65", observer="2", *, channel_axis=-1):
+    """XYZ to CIE-LAB color space conversion.
+
+    Parameters
+    ----------
+    xyz : (..., C=3, ...) array_like
+        The image in XYZ format. By default, the final dimension denotes
+        channels.
+    illuminant : {"A", "B", "C", "D50", "D55", "D65", "D75", "E"}, optional
+        The name of the illuminant (the function is NOT case sensitive).
+    observer : {"2", "10", "R"}, optional
+        One of: 2-degree observer, 10-degree observer, or 'R' observer as in
+        R function grDevices::convertColor.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in CIE-LAB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `xyz` is not at least 2-D with shape (..., C=3, ...).
+    ValueError
+        If either the illuminant or the observer angle is unsupported or
+        unknown.
+
+    Notes
+    -----
+    By default Observer="2", Illuminant="D65". CIE XYZ tristimulus values
+    x_ref=95.047, y_ref=100., z_ref=108.883. See function
+    :func:`~.xyz_tristimulus_values` for a list of supported illuminants.
+
+    References
+    ----------
+    .. [1] http://www.easyrgb.com/en/math.php
+    .. [2] https://en.wikipedia.org/wiki/CIELAB_color_space
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2xyz, xyz2lab
+    >>> img = data.astronaut()
+    >>> img_xyz = rgb2xyz(img)
+    >>> img_lab = xyz2lab(img_xyz)
+    """
+    arr = _prepare_colorarray(xyz, channel_axis=-1)
+
+    xyz_ref_white = xyz_tristimulus_values(
+        illuminant=illuminant, observer=observer, dtype=arr.dtype
+    )
+
+    # scale by CIE XYZ tristimulus values of the reference white point
+    arr = arr / xyz_ref_white
+
+    # Nonlinear distortion and linear transformation
+    mask = arr > 0.008856
+    arr[mask] = np.cbrt(arr[mask])
+    arr[~mask] = 7.787 * arr[~mask] + 16.0 / 116.0
+
+    x, y, z = arr[..., 0], arr[..., 1], arr[..., 2]
+
+    # Vector scaling
+    L = (116.0 * y) - 16.0
+    a = 500.0 * (x - y)
+    b = 200.0 * (y - z)
+
+    return np.concatenate([x[..., np.newaxis] for x in [L, a, b]], axis=-1)
+
+
+@channel_as_last_axis()
+def lab2xyz(lab, illuminant="D65", observer="2", *, channel_axis=-1):
+    """Convert image in CIE-LAB to XYZ color space.
+
+    Parameters
+    ----------
+    lab : (..., C=3, ...) array_like
+        The input image in CIE-LAB color space.
+        Unless `channel_axis` is set, the final dimension denotes the CIE-LAB
+        channels.
+        The L* values range from 0 to 100;
+        the a* and b* values range from -128 to 127.
+    illuminant : {"A", "B", "C", "D50", "D55", "D65", "D75", "E"}, optional
+        The name of the illuminant (the function is NOT case sensitive).
+    observer : {"2", "10", "R"}, optional
+        The aperture angle of the observer.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in XYZ color space, of same shape as input.
+
+    Raises
+    ------
+    ValueError
+        If `lab` is not at least 2-D with shape (..., C=3, ...).
+    ValueError
+        If either the illuminant or the observer angle are not supported or
+        unknown.
+    UserWarning
+        If any of the pixels are invalid (Z < 0).
+
+    Notes
+    -----
+    The CIE XYZ tristimulus values are x_ref = 95.047, y_ref = 100., and
+    z_ref = 108.883. See function :func:`~.xyz_tristimulus_values` for a list of
+    supported illuminants.
+
+    See Also
+    --------
+    xyz2lab
+
+    References
+    ----------
+    .. [1] http://www.easyrgb.com/en/math.php
+    .. [2] https://en.wikipedia.org/wiki/CIELAB_color_space
+    """
+    xyz, n_invalid = _lab2xyz(lab, illuminant, observer)
+    if n_invalid != 0:
+        warn(
+            "Conversion from CIE-LAB to XYZ color space resulted in "
+            f"{n_invalid} negative Z values that have been clipped to zero",
+            stacklevel=3,
+        )
+    return xyz
+
+
+def _lab2xyz(lab, illuminant, observer):
+    """Convert CIE-LAB to XYZ color space.
+
+    Internal function for :func:`~.lab2xyz` and others. In addition to the
+    converted image, return the number of invalid pixels in the Z channel for
+    correct warning propagation.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in XYZ format. Same dimensions as input.
+    n_invalid : int
+        Number of invalid pixels in the Z channel after conversion.
+    """
+    arr = _prepare_colorarray(lab, channel_axis=-1).copy()
+
+    L, a, b = arr[..., 0], arr[..., 1], arr[..., 2]
+    y = (L + 16.0) / 116.0
+    x = (a / 500.0) + y
+    z = y - (b / 200.0)
+
+    invalid = np.atleast_1d(z < 0).nonzero()
+    n_invalid = invalid[0].size
+    if n_invalid != 0:
+        # Warning should be emitted by caller
+        if z.ndim > 0:
+            z[invalid] = 0
+        else:
+            z = 0
+
+    out = np.stack([x, y, z], axis=-1)
+
+    mask = out > 0.2068966
+    out[mask] = np.power(out[mask], 3.0)
+    out[~mask] = (out[~mask] - 16.0 / 116.0) / 7.787
+
+    # rescale to the reference white (illuminant)
+    xyz_ref_white = xyz_tristimulus_values(illuminant=illuminant, observer=observer)
+    out *= xyz_ref_white
+    return out, n_invalid
+
+
+@channel_as_last_axis()
+def rgb2lab(rgb, illuminant="D65", observer="2", *, channel_axis=-1):
+    """Conversion from the sRGB color space (IEC 61966-2-1:1999)
+    to the CIE Lab colorspace under the given illuminant and observer.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    illuminant : {"A", "B", "C", "D50", "D55", "D65", "D75", "E"}, optional
+        The name of the illuminant (the function is NOT case sensitive).
+    observer : {"2", "10", "R"}, optional
+        The aperture angle of the observer.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in Lab format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    RGB is a device-dependent color space so, if you use this function, be
+    sure that the image you are analyzing has been mapped to the sRGB color
+    space.
+
+    This function uses rgb2xyz and xyz2lab.
+    By default Observer="2", Illuminant="D65". CIE XYZ tristimulus values
+    x_ref=95.047, y_ref=100., z_ref=108.883. See function
+    :func:`~.xyz_tristimulus_values` for a list of supported illuminants.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Standard_illuminant
+    """
+    return xyz2lab(rgb2xyz(rgb), illuminant, observer)
+
+
+@channel_as_last_axis()
+def lab2rgb(lab, illuminant="D65", observer="2", *, channel_axis=-1):
+    """Convert image in CIE-LAB to sRGB color space.
+
+    Parameters
+    ----------
+    lab : (..., C=3, ...) array_like
+        The input image in CIE-LAB color space.
+        Unless `channel_axis` is set, the final dimension denotes the CIE-LAB
+        channels.
+        The L* values range from 0 to 100;
+        the a* and b* values range from -128 to 127.
+    illuminant : {"A", "B", "C", "D50", "D55", "D65", "D75", "E"}, optional
+        The name of the illuminant (the function is NOT case sensitive).
+    observer : {"2", "10", "R"}, optional
+        The aperture angle of the observer.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in sRGB color space, of same shape as input.
+
+    Raises
+    ------
+    ValueError
+        If `lab` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    This function uses :func:`~.lab2xyz` and :func:`~.xyz2rgb`.
+    The CIE XYZ tristimulus values are x_ref = 95.047, y_ref = 100., and
+    z_ref = 108.883. See function :func:`~.xyz_tristimulus_values` for a list of
+    supported illuminants.
+
+    See Also
+    --------
+    rgb2lab
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Standard_illuminant
+    .. [2] https://en.wikipedia.org/wiki/CIELAB_color_space
+    """
+    xyz, n_invalid = _lab2xyz(lab, illuminant, observer)
+    if n_invalid != 0:
+        warn(
+            "Conversion from CIE-LAB, via XYZ to sRGB color space resulted in "
+            f"{n_invalid} negative Z values that have been clipped to zero",
+            stacklevel=3,
+        )
+    return xyz2rgb(xyz)
+
+
+@channel_as_last_axis()
+def xyz2luv(xyz, illuminant="D65", observer="2", *, channel_axis=-1):
+    """XYZ to CIE-Luv color space conversion.
+
+    Parameters
+    ----------
+    xyz : (..., C=3, ...) array_like
+        The image in XYZ format. By default, the final dimension denotes
+        channels.
+    illuminant : {"A", "B", "C", "D50", "D55", "D65", "D75", "E"}, optional
+        The name of the illuminant (the function is NOT case sensitive).
+    observer : {"2", "10", "R"}, optional
+        The aperture angle of the observer.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in CIE-Luv format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `xyz` is not at least 2-D with shape (..., C=3, ...).
+    ValueError
+        If either the illuminant or the observer angle are not supported or
+        unknown.
+
+    Notes
+    -----
+    By default XYZ conversion weights use observer=2A. Reference whitepoint
+    for D65 Illuminant, with XYZ tristimulus values of ``(95.047, 100.,
+    108.883)``. See function :func:`~.xyz_tristimulus_values` for a list of supported
+    illuminants.
+
+    References
+    ----------
+    .. [1] http://www.easyrgb.com/en/math.php
+    .. [2] https://en.wikipedia.org/wiki/CIELUV
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2xyz, xyz2luv
+    >>> img = data.astronaut()
+    >>> img_xyz = rgb2xyz(img)
+    >>> img_luv = xyz2luv(img_xyz)
+    """
+    input_is_one_pixel = xyz.ndim == 1
+    if input_is_one_pixel:
+        xyz = xyz[np.newaxis, ...]
+
+    arr = _prepare_colorarray(xyz, channel_axis=-1)
+
+    # extract channels
+    x, y, z = arr[..., 0], arr[..., 1], arr[..., 2]
+
+    eps = np.finfo(arr.dtype).eps
+
+    # compute y_r and L
+    xyz_ref_white = xyz_tristimulus_values(
+        illuminant=illuminant, observer=observer, dtype=arr.dtype
+    )
+    L = y / xyz_ref_white[1]
+    mask = L > 0.008856
+    L[mask] = 116.0 * np.cbrt(L[mask]) - 16.0
+    L[~mask] = 903.3 * L[~mask]
+
+    uv_weights = np.array([1, 15, 3], dtype=arr.dtype)
+    u0 = 4 * xyz_ref_white[0] / (uv_weights @ xyz_ref_white)
+    v0 = 9 * xyz_ref_white[1] / (uv_weights @ xyz_ref_white)
+
+    # u' and v' helper functions
+    def fu(X, Y, Z):
+        return (4.0 * X) / (X + 15.0 * Y + 3.0 * Z + eps)
+
+    def fv(X, Y, Z):
+        return (9.0 * Y) / (X + 15.0 * Y + 3.0 * Z + eps)
+
+    # compute u and v using helper functions
+    u = 13.0 * L * (fu(x, y, z) - u0)
+    v = 13.0 * L * (fv(x, y, z) - v0)
+
+    out = np.stack([L, u, v], axis=-1)
+
+    if input_is_one_pixel:
+        out = np.squeeze(out, axis=0)
+
+    return out
+
+
+@channel_as_last_axis()
+def luv2xyz(luv, illuminant="D65", observer="2", *, channel_axis=-1):
+    """CIE-Luv to XYZ color space conversion.
+
+    Parameters
+    ----------
+    luv : (..., C=3, ...) array_like
+        The image in CIE-Luv format. By default, the final dimension denotes
+        channels.
+    illuminant : {"A", "B", "C", "D50", "D55", "D65", "D75", "E"}, optional
+        The name of the illuminant (the function is NOT case sensitive).
+    observer : {"2", "10", "R"}, optional
+        The aperture angle of the observer.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in XYZ format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `luv` is not at least 2-D with shape (..., C=3, ...).
+    ValueError
+        If either the illuminant or the observer angle are not supported or
+        unknown.
+
+    Notes
+    -----
+    XYZ conversion weights use observer=2A. Reference whitepoint for D65
+    Illuminant, with XYZ tristimulus values of ``(95.047, 100., 108.883)``. See
+    function :func:`~.xyz_tristimulus_values` for a list of supported illuminants.
+
+    References
+    ----------
+    .. [1] http://www.easyrgb.com/en/math.php
+    .. [2] https://en.wikipedia.org/wiki/CIELUV
+    """
+    arr = _prepare_colorarray(luv, channel_axis=-1).copy()
+
+    L, u, v = arr[..., 0], arr[..., 1], arr[..., 2]
+
+    eps = np.finfo(arr.dtype).eps
+
+    # compute y
+    y = L.copy()
+    mask = y > 7.999625
+    y[mask] = np.power((y[mask] + 16.0) / 116.0, 3.0)
+    y[~mask] = y[~mask] / 903.3
+    xyz_ref_white = xyz_tristimulus_values(
+        illuminant=illuminant, observer=observer, dtype=arr.dtype
+    )
+    y *= xyz_ref_white[1]
+
+    # reference white x,z
+    uv_weights = np.array([1, 15, 3], dtype=arr.dtype)
+    u0 = 4 * xyz_ref_white[0] / (uv_weights @ xyz_ref_white)
+    v0 = 9 * xyz_ref_white[1] / (uv_weights @ xyz_ref_white)
+
+    # compute intermediate values
+    a = u0 + u / (13.0 * L + eps)
+    b = v0 + v / (13.0 * L + eps)
+    c = 3 * y * (5 * b - 3)
+
+    # compute x and z
+    z = ((a - 4) * c - 15 * a * b * y) / (12 * b)
+    x = -(c / b + 3.0 * z)
+
+    return np.concatenate([q[..., np.newaxis] for q in [x, y, z]], axis=-1)
+
+
+@channel_as_last_axis()
+def rgb2luv(rgb, *, channel_axis=-1):
+    """RGB to CIE-Luv color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in CIE Luv format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    This function uses rgb2xyz and xyz2luv.
+
+    References
+    ----------
+    .. [1] http://www.easyrgb.com/en/math.php
+    .. [2] https://en.wikipedia.org/wiki/CIELUV
+    """
+    return xyz2luv(rgb2xyz(rgb))
+
+
+@channel_as_last_axis()
+def luv2rgb(luv, *, channel_axis=-1):
+    """Luv to RGB color space conversion.
+
+    Parameters
+    ----------
+    luv : (..., C=3, ...) array_like
+        The image in CIE Luv format. By default, the final dimension denotes
+        channels.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `luv` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    This function uses luv2xyz and xyz2rgb.
+    """
+    return xyz2rgb(luv2xyz(luv))
+
+
+@channel_as_last_axis()
+def rgb2hed(rgb, *, channel_axis=-1):
+    """RGB to Haematoxylin-Eosin-DAB (HED) color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in HED format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    References
+    ----------
+    .. [1] A. C. Ruifrok and D. A. Johnston, "Quantification of histochemical
+           staining by color deconvolution.," Analytical and quantitative
+           cytology and histology / the International Academy of Cytology [and]
+           American Society of Cytology, vol. 23, no. 4, pp. 291-9, Aug. 2001.
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2hed
+    >>> ihc = data.immunohistochemistry()
+    >>> ihc_hed = rgb2hed(ihc)
+    """
+    return separate_stains(rgb, hed_from_rgb)
+
+
+@channel_as_last_axis()
+def hed2rgb(hed, *, channel_axis=-1):
+    """Haematoxylin-Eosin-DAB (HED) to RGB color space conversion.
+
+    Parameters
+    ----------
+    hed : (..., C=3, ...) array_like
+        The image in the HED color space. By default, the final dimension
+        denotes channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `hed` is not at least 2-D with shape (..., C=3, ...).
+
+    References
+    ----------
+    .. [1] A. C. Ruifrok and D. A. Johnston, "Quantification of histochemical
+           staining by color deconvolution.," Analytical and quantitative
+           cytology and histology / the International Academy of Cytology [and]
+           American Society of Cytology, vol. 23, no. 4, pp. 291-9, Aug. 2001.
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2hed, hed2rgb
+    >>> ihc = data.immunohistochemistry()
+    >>> ihc_hed = rgb2hed(ihc)
+    >>> ihc_rgb = hed2rgb(ihc_hed)
+    """
+    return combine_stains(hed, rgb_from_hed)
+
+
+@channel_as_last_axis()
+def separate_stains(rgb, conv_matrix, *, channel_axis=-1):
+    """RGB to stain color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    conv_matrix : ndarray
+        The stain separation matrix as described by G. Landini [1]_.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in stain color space. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    Stain separation matrices available in the ``color`` module and their
+    respective colorspace:
+
+    * ``hed_from_rgb``: Hematoxylin + Eosin + DAB
+    * ``hdx_from_rgb``: Hematoxylin + DAB
+    * ``fgx_from_rgb``: Feulgen + Light Green
+    * ``bex_from_rgb``: Giemsa stain : Methyl Blue + Eosin
+    * ``rbd_from_rgb``: FastRed + FastBlue +  DAB
+    * ``gdx_from_rgb``: Methyl Green + DAB
+    * ``hax_from_rgb``: Hematoxylin + AEC
+    * ``bro_from_rgb``: Blue matrix Anilline Blue + Red matrix Azocarmine\
+                        + Orange matrix Orange-G
+    * ``bpx_from_rgb``: Methyl Blue + Ponceau Fuchsin
+    * ``ahx_from_rgb``: Alcian Blue + Hematoxylin
+    * ``hpx_from_rgb``: Hematoxylin + PAS
+
+    This implementation borrows some ideas from DIPlib [2]_, e.g. the
+    compensation using a small value to avoid log artifacts when
+    calculating the Beer-Lambert law.
+
+    References
+    ----------
+    .. [1] https://web.archive.org/web/20160624145052/http://www.mecourse.com/landinig/software/cdeconv/cdeconv.html
+    .. [2] https://github.com/DIPlib/diplib/
+    .. [3] A. C. Ruifrok and D. A. Johnston, “Quantification of histochemical
+           staining by color deconvolution,” Anal. Quant. Cytol. Histol., vol.
+           23, no. 4, pp. 291–299, Aug. 2001.
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import separate_stains, hdx_from_rgb
+    >>> ihc = data.immunohistochemistry()
+    >>> ihc_hdx = separate_stains(ihc, hdx_from_rgb)
+    """
+    rgb = _prepare_colorarray(rgb, force_copy=True, channel_axis=-1)
+    np.maximum(rgb, 1e-6, out=rgb)  # avoiding log artifacts
+    log_adjust = np.log(1e-6)  # used to compensate the sum above
+
+    stains = (np.log(rgb) / log_adjust) @ conv_matrix
+
+    np.maximum(stains, 0, out=stains)
+
+    return stains
+
+
+@channel_as_last_axis()
+def combine_stains(stains, conv_matrix, *, channel_axis=-1):
+    """Stain to RGB color space conversion.
+
+    Parameters
+    ----------
+    stains : (..., C=3, ...) array_like
+        The image in stain color space. By default, the final dimension denotes
+        channels.
+    conv_matrix : ndarray
+        The stain separation matrix as described by G. Landini [1]_.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `stains` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    Stain combination matrices available in the ``color`` module and their
+    respective colorspace:
+
+    * ``rgb_from_hed``: Hematoxylin + Eosin + DAB
+    * ``rgb_from_hdx``: Hematoxylin + DAB
+    * ``rgb_from_fgx``: Feulgen + Light Green
+    * ``rgb_from_bex``: Giemsa stain : Methyl Blue + Eosin
+    * ``rgb_from_rbd``: FastRed + FastBlue +  DAB
+    * ``rgb_from_gdx``: Methyl Green + DAB
+    * ``rgb_from_hax``: Hematoxylin + AEC
+    * ``rgb_from_bro``: Blue matrix Anilline Blue + Red matrix Azocarmine\
+                        + Orange matrix Orange-G
+    * ``rgb_from_bpx``: Methyl Blue + Ponceau Fuchsin
+    * ``rgb_from_ahx``: Alcian Blue + Hematoxylin
+    * ``rgb_from_hpx``: Hematoxylin + PAS
+
+    References
+    ----------
+    .. [1] https://web.archive.org/web/20160624145052/http://www.mecourse.com/landinig/software/cdeconv/cdeconv.html
+    .. [2] A. C. Ruifrok and D. A. Johnston, “Quantification of histochemical
+           staining by color deconvolution,” Anal. Quant. Cytol. Histol., vol.
+           23, no. 4, pp. 291–299, Aug. 2001.
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import (separate_stains, combine_stains,
+    ...                            hdx_from_rgb, rgb_from_hdx)
+    >>> ihc = data.immunohistochemistry()
+    >>> ihc_hdx = separate_stains(ihc, hdx_from_rgb)
+    >>> ihc_rgb = combine_stains(ihc_hdx, rgb_from_hdx)
+    """
+    stains = _prepare_colorarray(stains, channel_axis=-1)
+
+    # log_adjust here is used to compensate the sum within separate_stains().
+    log_adjust = -np.log(1e-6)
+    log_rgb = -(stains * log_adjust) @ conv_matrix
+    rgb = np.exp(log_rgb)
+
+    return np.clip(rgb, a_min=0, a_max=1)
+
+
+@channel_as_last_axis()
+def lab2lch(lab, *, channel_axis=-1):
+    """Convert image in CIE-LAB to CIE-LCh color space.
+
+    CIE-LCh is the cylindrical representation of the CIE-LAB (Cartesian) color
+    space.
+
+    Parameters
+    ----------
+    lab : (..., C=3, ...) array_like
+        The input image in CIE-LAB color space.
+        Unless `channel_axis` is set, the final dimension denotes the CIE-LAB
+        channels.
+        The L* values range from 0 to 100;
+        the a* and b* values range from -128 to 127.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in CIE-LCh color space, of same shape as input.
+
+    Raises
+    ------
+    ValueError
+        If `lab` does not have at least 3 channels (i.e., L*, a*, and b*).
+
+    Notes
+    -----
+    The h channel (i.e., hue) is expressed as an angle in range ``(0, 2*pi)``.
+
+    See Also
+    --------
+    lch2lab
+
+    References
+    ----------
+    .. [1] http://www.easyrgb.com/en/math.php
+    .. [2] https://en.wikipedia.org/wiki/CIELAB_color_space
+    .. [3] https://en.wikipedia.org/wiki/HCL_color_space
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2lab, lab2lch
+    >>> img = data.astronaut()
+    >>> img_lab = rgb2lab(img)
+    >>> img_lch = lab2lch(img_lab)
+    """
+    lch = _prepare_lab_array(lab)
+
+    a, b = lch[..., 1], lch[..., 2]
+    lch[..., 1], lch[..., 2] = _cart2polar_2pi(a, b)
+    return lch
+
+
+def _cart2polar_2pi(x, y):
+    """convert cartesian coordinates to polar (uses non-standard theta range!)
+
+    NON-STANDARD RANGE! Maps to ``(0, 2*pi)`` rather than usual ``(-pi, +pi)``
+    """
+    r, t = np.hypot(x, y), np.arctan2(y, x)
+    t += np.where(t < 0.0, 2 * np.pi, 0)
+    return r, t
+
+
+@channel_as_last_axis()
+def lch2lab(lch, *, channel_axis=-1):
+    """Convert image in CIE-LCh to CIE-LAB color space.
+
+    CIE-LCh is the cylindrical representation of the CIE-LAB (Cartesian) color
+    space.
+
+    Parameters
+    ----------
+    lch : (..., C=3, ...) array_like
+        The input image in CIE-LCh color space.
+        Unless `channel_axis` is set, the final dimension denotes the CIE-LAB
+        channels.
+        The L* values range from 0 to 100;
+        the C values range from 0 to 100;
+        the h values range from 0 to ``2*pi``.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in CIE-LAB format, of same shape as input.
+
+    Raises
+    ------
+    ValueError
+        If `lch` does not have at least 3 channels (i.e., L*, C, and h).
+
+    Notes
+    -----
+    The h channel (i.e., hue) is expressed as an angle in range ``(0, 2*pi)``.
+
+    See Also
+    --------
+    lab2lch
+
+    References
+    ----------
+    .. [1] http://www.easyrgb.com/en/math.php
+    .. [2] https://en.wikipedia.org/wiki/HCL_color_space
+    .. [3] https://en.wikipedia.org/wiki/CIELAB_color_space
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> from skimage.color import rgb2lab, lch2lab, lab2lch
+    >>> img = data.astronaut()
+    >>> img_lab = rgb2lab(img)
+    >>> img_lch = lab2lch(img_lab)
+    >>> img_lab2 = lch2lab(img_lch)
+    """
+    lch = _prepare_lab_array(lch)
+
+    c, h = lch[..., 1], lch[..., 2]
+    lch[..., 1], lch[..., 2] = c * np.cos(h), c * np.sin(h)
+    return lch
+
+
+def _prepare_lab_array(arr, force_copy=True):
+    """Ensure input for lab2lch and lch2lab is well-formed.
+
+    Input array must be in floating point and have at least 3 elements in the
+    last dimension. Returns a new array by default.
+    """
+    arr = np.asarray(arr)
+    shape = arr.shape
+    if shape[-1] < 3:
+        raise ValueError('Input image has less than 3 channels.')
+    float_dtype = _supported_float_type(arr.dtype)
+    if float_dtype == np.float32:
+        _func = dtype.img_as_float32
+    else:
+        _func = dtype.img_as_float64
+    return _func(arr, force_copy=force_copy)
+
+
+@channel_as_last_axis()
+def rgb2yuv(rgb, *, channel_axis=-1):
+    """RGB to YUV color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in YUV format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    Y is between 0 and 1.  Use YCbCr instead of YUV for the color space
+    commonly used by video codecs, where Y ranges from 16 to 235.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YUV
+    """
+    return _convert(yuv_from_rgb, rgb)
+
+
+@channel_as_last_axis()
+def rgb2yiq(rgb, *, channel_axis=-1):
+    """RGB to YIQ color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in YIQ format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+    """
+    return _convert(yiq_from_rgb, rgb)
+
+
+@channel_as_last_axis()
+def rgb2ypbpr(rgb, *, channel_axis=-1):
+    """RGB to YPbPr color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in YPbPr format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YPbPr
+    """
+    return _convert(ypbpr_from_rgb, rgb)
+
+
+@channel_as_last_axis()
+def rgb2ycbcr(rgb, *, channel_axis=-1):
+    """RGB to YCbCr color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in YCbCr format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    Y is between 16 and 235. This is the color space commonly used by video
+    codecs; it is sometimes incorrectly called "YUV".
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YCbCr
+    """
+    arr = _convert(ycbcr_from_rgb, rgb)
+    arr[..., 0] += 16
+    arr[..., 1] += 128
+    arr[..., 2] += 128
+    return arr
+
+
+@channel_as_last_axis()
+def rgb2ydbdr(rgb, *, channel_axis=-1):
+    """RGB to YDbDr color space conversion.
+
+    Parameters
+    ----------
+    rgb : (..., C=3, ...) array_like
+        The image in RGB format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in YDbDr format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `rgb` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    This is the color space commonly used by video codecs. It is also the
+    reversible color transform in JPEG2000.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YDbDr
+    """
+    arr = _convert(ydbdr_from_rgb, rgb)
+    return arr
+
+
+@channel_as_last_axis()
+def yuv2rgb(yuv, *, channel_axis=-1):
+    """YUV to RGB color space conversion.
+
+    Parameters
+    ----------
+    yuv : (..., C=3, ...) array_like
+        The image in YUV format. By default, the final dimension denotes
+        channels.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `yuv` is not at least 2-D with shape (..., C=3, ...).
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YUV
+    """
+    return _convert(rgb_from_yuv, yuv)
+
+
+@channel_as_last_axis()
+def yiq2rgb(yiq, *, channel_axis=-1):
+    """YIQ to RGB color space conversion.
+
+    Parameters
+    ----------
+    yiq : (..., C=3, ...) array_like
+        The image in YIQ format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `yiq` is not at least 2-D with shape (..., C=3, ...).
+    """
+    return _convert(rgb_from_yiq, yiq)
+
+
+@channel_as_last_axis()
+def ypbpr2rgb(ypbpr, *, channel_axis=-1):
+    """YPbPr to RGB color space conversion.
+
+    Parameters
+    ----------
+    ypbpr : (..., C=3, ...) array_like
+        The image in YPbPr format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `ypbpr` is not at least 2-D with shape (..., C=3, ...).
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YPbPr
+    """
+    return _convert(rgb_from_ypbpr, ypbpr)
+
+
+@channel_as_last_axis()
+def ycbcr2rgb(ycbcr, *, channel_axis=-1):
+    """YCbCr to RGB color space conversion.
+
+    Parameters
+    ----------
+    ycbcr : (..., C=3, ...) array_like
+        The image in YCbCr format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `ycbcr` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    Y is between 16 and 235. This is the color space commonly used by video
+    codecs; it is sometimes incorrectly called "YUV".
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YCbCr
+    """
+    arr = ycbcr.copy()
+    arr[..., 0] -= 16
+    arr[..., 1] -= 128
+    arr[..., 2] -= 128
+    return _convert(rgb_from_ycbcr, arr)
+
+
+@channel_as_last_axis()
+def ydbdr2rgb(ydbdr, *, channel_axis=-1):
+    """YDbDr to RGB color space conversion.
+
+    Parameters
+    ----------
+    ydbdr : (..., C=3, ...) array_like
+        The image in YDbDr format. By default, the final dimension denotes
+        channels.
+    channel_axis : int, optional
+        This parameter indicates which axis of the array corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    Raises
+    ------
+    ValueError
+        If `ydbdr` is not at least 2-D with shape (..., C=3, ...).
+
+    Notes
+    -----
+    This is the color space commonly used by video codecs, also called the
+    reversible color transform in JPEG2000.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/YDbDr
+    """
+    return _convert(rgb_from_ydbdr, ydbdr)

envs/kitoverlay/skimage/color/colorlabel.py

@@ -0,0 +1,299 @@
+import itertools
+
+import numpy as np
+
+from .._shared.utils import _supported_float_type, warn
+from ..util import img_as_float
+from . import rgb_colors
+from .colorconv import gray2rgb, rgb2hsv, hsv2rgb
+
+
+__all__ = ['color_dict', 'label2rgb', 'DEFAULT_COLORS']
+
+
+DEFAULT_COLORS = (
+    'red',
+    'blue',
+    'yellow',
+    'magenta',
+    'green',
+    'indigo',
+    'darkorange',
+    'cyan',
+    'pink',
+    'yellowgreen',
+)
+
+
+color_dict = {k: v for k, v in rgb_colors.__dict__.items() if isinstance(v, tuple)}
+
+
+def _rgb_vector(color):
+    """Return RGB color as (1, 3) array.
+
+    This RGB array gets multiplied by masked regions of an RGB image, which are
+    partially flattened by masking (i.e. dimensions 2D + RGB -> 1D + RGB).
+
+    Parameters
+    ----------
+    color : str or array
+        Color name in ``skimage.color.color_dict`` or RGB float values between [0, 1].
+    """
+    if isinstance(color, str):
+        color = color_dict[color]
+    # Slice to handle RGBA colors.
+    return np.array(color[:3])
+
+
+def _match_label_with_color(label, colors, bg_label, bg_color):
+    """Return `unique_labels` and `color_cycle` for label array and color list.
+
+    Colors are cycled for normal labels, but the background color should only
+    be used for the background.
+    """
+    # Temporarily set background color; it will be removed later.
+    if bg_color is None:
+        bg_color = (0, 0, 0)
+    bg_color = _rgb_vector(bg_color)
+
+    # map labels to their ranks among all labels from small to large
+    unique_labels, mapped_labels = np.unique(label, return_inverse=True)
+    # unique_inverse is no longer flat in NumPy 2.0
+    mapped_labels = mapped_labels.reshape(-1)
+
+    # get rank of bg_label
+    bg_label_rank_list = mapped_labels[label.flat == bg_label]
+
+    # The rank of each label is the index of the color it is matched to in
+    # color cycle. bg_label should always be mapped to the first color, so
+    # its rank must be 0. Other labels should be ranked from small to large
+    # from 1.
+    if len(bg_label_rank_list) > 0:
+        bg_label_rank = bg_label_rank_list[0]
+        mapped_labels[mapped_labels < bg_label_rank] += 1
+        mapped_labels[label.flat == bg_label] = 0
+    else:
+        mapped_labels += 1
+
+    # Modify labels and color cycle so background color is used only once.
+    color_cycle = itertools.cycle(colors)
+    color_cycle = itertools.chain([bg_color], color_cycle)
+
+    return mapped_labels, color_cycle
+
+
+def label2rgb(
+    label,
+    image=None,
+    colors=None,
+    alpha=0.3,
+    bg_label=0,
+    bg_color=(0, 0, 0),
+    image_alpha=1,
+    kind='overlay',
+    *,
+    saturation=0,
+    channel_axis=-1,
+):
+    """Return an RGB image where color-coded labels are painted over the image.
+
+    Parameters
+    ----------
+    label : ndarray
+        Integer array of labels with the same shape as `image`.
+    image : ndarray, optional
+        Image used as underlay for labels. It should have the same shape as
+        `labels`, optionally with an additional RGB (channels) axis. If `image`
+        is an RGB image, it is converted to grayscale before coloring.
+    colors : list, optional
+        List of colors. If the number of labels exceeds the number of colors,
+        then the colors are cycled.
+    alpha : float [0, 1], optional
+        Opacity of colorized labels. Ignored if image is `None`.
+    bg_label : int, optional
+        Label that's treated as the background. If `bg_label` is specified,
+        `bg_color` is `None`, and `kind` is `overlay`,
+        background is not painted by any colors.
+    bg_color : str or array, optional
+        Background color. Must be a name in ``skimage.color.color_dict`` or RGB float
+        values between [0, 1].
+    image_alpha : float [0, 1], optional
+        Opacity of the image.
+    kind : string, one of {'overlay', 'avg'}
+        The kind of color image desired. 'overlay' cycles over defined colors
+        and overlays the colored labels over the original image. 'avg' replaces
+        each labeled segment with its average color, for a stained-class or
+        pastel painting appearance.
+    saturation : float [0, 1], optional
+        Parameter to control the saturation applied to the original image
+        between fully saturated (original RGB, `saturation=1`) and fully
+        unsaturated (grayscale, `saturation=0`). Only applies when
+        `kind='overlay'`.
+    channel_axis : int, optional
+        This parameter indicates which axis of the output array will correspond
+        to channels. If `image` is provided, this must also match the axis of
+        `image` that corresponds to channels.
+
+        .. versionadded:: 0.19
+            ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    result : ndarray of float, same shape as `image`
+        The result of blending a cycling colormap (`colors`) for each distinct
+        value in `label` with the image, at a certain alpha value.
+    """
+    if image is not None:
+        image = np.moveaxis(image, source=channel_axis, destination=-1)
+    if kind == 'overlay':
+        rgb = _label2rgb_overlay(
+            label, image, colors, alpha, bg_label, bg_color, image_alpha, saturation
+        )
+    elif kind == 'avg':
+        rgb = _label2rgb_avg(label, image, bg_label, bg_color)
+    else:
+        raise ValueError("`kind` must be either 'overlay' or 'avg'.")
+    return np.moveaxis(rgb, source=-1, destination=channel_axis)
+
+
+def _label2rgb_overlay(
+    label,
+    image=None,
+    colors=None,
+    alpha=0.3,
+    bg_label=-1,
+    bg_color=None,
+    image_alpha=1,
+    saturation=0,
+):
+    """Return an RGB image where color-coded labels are painted over the image.
+
+    Parameters
+    ----------
+    label : ndarray
+        Integer array of labels with the same shape as `image`.
+    image : ndarray, optional
+        Image used as underlay for labels. It should have the same shape as
+        `labels`, optionally with an additional RGB (channels) axis. If `image`
+        is an RGB image, it is converted to grayscale before coloring.
+    colors : list, optional
+        List of colors. If the number of labels exceeds the number of colors,
+        then the colors are cycled.
+    alpha : float [0, 1], optional
+        Opacity of colorized labels. Ignored if image is `None`.
+    bg_label : int, optional
+        Label that's treated as the background. If `bg_label` is specified and
+        `bg_color` is `None`, background is not painted by any colors.
+    bg_color : str or array, optional
+        Background color. Must be a name in ``skimage.color.color_dict`` or RGB float
+        values between [0, 1].
+    image_alpha : float [0, 1], optional
+        Opacity of the image.
+    saturation : float [0, 1], optional
+        Parameter to control the saturation applied to the original image
+        between fully saturated (original RGB, `saturation=1`) and fully
+        unsaturated (grayscale, `saturation=0`).
+
+    Returns
+    -------
+    result : ndarray of float, same shape as `image`
+        The result of blending a cycling colormap (`colors`) for each distinct
+        value in `label` with the image, at a certain alpha value.
+    """
+    if not 0 <= saturation <= 1:
+        warn(f'saturation must be in range [0, 1], got {saturation}')
+
+    if colors is None:
+        colors = DEFAULT_COLORS
+    colors = [_rgb_vector(c) for c in colors]
+
+    if image is None:
+        image = np.zeros(label.shape + (3,), dtype=np.float64)
+        # Opacity doesn't make sense if no image exists.
+        alpha = 1
+    else:
+        if image.shape[: label.ndim] != label.shape or image.ndim > label.ndim + 1:
+            raise ValueError("`image` and `label` must be the same shape")
+
+        if image.ndim == label.ndim + 1 and image.shape[-1] != 3:
+            raise ValueError("`image` must be RGB (image.shape[-1] must be 3).")
+
+        if image.min() < 0:
+            warn("Negative intensities in `image` are not supported")
+
+        float_dtype = _supported_float_type(image.dtype)
+        image = img_as_float(image).astype(float_dtype, copy=False)
+        if image.ndim > label.ndim:
+            hsv = rgb2hsv(image)
+            hsv[..., 1] *= saturation
+            image = hsv2rgb(hsv)
+        elif image.ndim == label.ndim:
+            image = gray2rgb(image)
+        image = image * image_alpha + (1 - image_alpha)
+
+    # Ensure that all labels are non-negative so we can index into
+    # `label_to_color` correctly.
+    offset = min(label.min(), bg_label)
+    if offset != 0:
+        label = label - offset  # Make sure you don't modify the input array.
+        bg_label -= offset
+
+    new_type = np.min_scalar_type(int(label.max()))
+    if new_type == bool:
+        new_type = np.uint8
+    label = label.astype(new_type)
+
+    mapped_labels_flat, color_cycle = _match_label_with_color(
+        label, colors, bg_label, bg_color
+    )
+
+    if len(mapped_labels_flat) == 0:
+        return image
+
+    dense_labels = range(np.max(mapped_labels_flat) + 1)
+
+    label_to_color = np.stack([c for i, c in zip(dense_labels, color_cycle)])
+
+    mapped_labels = label
+    mapped_labels.flat = mapped_labels_flat
+    result = label_to_color[mapped_labels] * alpha + image * (1 - alpha)
+
+    # Remove background label if its color was not specified.
+    remove_background = 0 in mapped_labels_flat and bg_color is None
+    if remove_background:
+        result[label == bg_label] = image[label == bg_label]
+
+    return result
+
+
+def _label2rgb_avg(label_field, image, bg_label=0, bg_color=(0, 0, 0)):
+    """Visualise each segment in `label_field` with its mean color in `image`.
+
+    Parameters
+    ----------
+    label_field : ndarray of int
+        A segmentation of an image.
+    image : array, shape ``label_field.shape + (3,)``
+        A color image of the same spatial shape as `label_field`.
+    bg_label : int, optional
+        A value in `label_field` to be treated as background.
+    bg_color : 3-tuple of int, optional
+        The color for the background label
+
+    Returns
+    -------
+    out : ndarray, same shape and type as `image`
+        The output visualization.
+    """
+    out = np.zeros(label_field.shape + (3,), dtype=image.dtype)
+    labels = np.unique(label_field)
+    bg = labels == bg_label
+    if bg.any():
+        labels = labels[labels != bg_label]
+        mask = (label_field == bg_label).nonzero()
+        out[mask] = bg_color
+    for label in labels:
+        mask = (label_field == label).nonzero()
+        color = image[mask].mean(axis=0)
+        out[mask] = color
+    return out

envs/kitoverlay/skimage/color/delta_e.py

@@ -0,0 +1,393 @@
+"""
+Functions for calculating the "distance" between colors.
+
+Implicit in these definitions of "distance" is the notion of "Just Noticeable
+Distance" (JND).  This represents the distance between colors where a human can
+perceive different colors.  Humans are more sensitive to certain colors than
+others, which different deltaE metrics correct for with varying degrees of
+sophistication.
+
+The literature often mentions 1 as the minimum distance for visual
+differentiation, but more recent studies (Mahy 1994) peg JND at 2.3
+
+The delta-E notation comes from the German word for "Sensation" (Empfindung).
+
+References
+----------
+.. [1] https://en.wikipedia.org/wiki/Color_difference
+
+"""
+
+import numpy as np
+
+from .._shared.utils import _supported_float_type
+from .colorconv import lab2lch, _cart2polar_2pi
+
+
+def _float_inputs(lab1, lab2, allow_float32=True):
+    lab1 = np.asarray(lab1)
+    lab2 = np.asarray(lab2)
+    if allow_float32:
+        float_dtype = _supported_float_type((lab1.dtype, lab2.dtype))
+    else:
+        float_dtype = np.float64
+    lab1 = lab1.astype(float_dtype, copy=False)
+    lab2 = lab2.astype(float_dtype, copy=False)
+    return lab1, lab2
+
+
+def deltaE_cie76(lab1, lab2, channel_axis=-1):
+    """Euclidean distance between two points in Lab color space
+
+    Parameters
+    ----------
+    lab1 : array_like
+        reference color (Lab colorspace)
+    lab2 : array_like
+        comparison color (Lab colorspace)
+    channel_axis : int, optional
+        This parameter indicates which axis of the arrays corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    dE : array_like
+        distance between colors `lab1` and `lab2`
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Color_difference
+    .. [2] A. R. Robertson, "The CIE 1976 color-difference formulae,"
+           Color Res. Appl. 2, 7-11 (1977).
+    """
+    lab1, lab2 = _float_inputs(lab1, lab2, allow_float32=True)
+    L1, a1, b1 = np.moveaxis(lab1, source=channel_axis, destination=0)[:3]
+    L2, a2, b2 = np.moveaxis(lab2, source=channel_axis, destination=0)[:3]
+    return np.sqrt((L2 - L1) ** 2 + (a2 - a1) ** 2 + (b2 - b1) ** 2)
+
+
+def deltaE_ciede94(
+    lab1, lab2, kH=1, kC=1, kL=1, k1=0.045, k2=0.015, *, channel_axis=-1
+):
+    """Color difference according to CIEDE 94 standard
+
+    Accommodates perceptual non-uniformities through the use of application
+    specific scale factors (`kH`, `kC`, `kL`, `k1`, and `k2`).
+
+    Parameters
+    ----------
+    lab1 : array_like
+        reference color (Lab colorspace)
+    lab2 : array_like
+        comparison color (Lab colorspace)
+    kH : float, optional
+        Hue scale
+    kC : float, optional
+        Chroma scale
+    kL : float, optional
+        Lightness scale
+    k1 : float, optional
+        first scale parameter
+    k2 : float, optional
+        second scale parameter
+    channel_axis : int, optional
+        This parameter indicates which axis of the arrays corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    dE : array_like
+        color difference between `lab1` and `lab2`
+
+    Notes
+    -----
+    deltaE_ciede94 is not symmetric with respect to lab1 and lab2.  CIEDE94
+    defines the scales for the lightness, hue, and chroma in terms of the first
+    color.  Consequently, the first color should be regarded as the "reference"
+    color.
+
+    `kL`, `k1`, `k2` depend on the application and default to the values
+    suggested for graphic arts
+
+    ==========  ==============  ==========
+    Parameter    Graphic Arts    Textiles
+    ==========  ==============  ==========
+    `kL`         1.000           2.000
+    `k1`         0.045           0.048
+    `k2`         0.015           0.014
+    ==========  ==============  ==========
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Color_difference
+    .. [2] http://www.brucelindbloom.com/index.html?Eqn_DeltaE_CIE94.html
+    """
+    lab1, lab2 = _float_inputs(lab1, lab2, allow_float32=True)
+    lab1 = np.moveaxis(lab1, source=channel_axis, destination=0)
+    lab2 = np.moveaxis(lab2, source=channel_axis, destination=0)
+
+    L1, C1 = lab2lch(lab1, channel_axis=0)[:2]
+    L2, C2 = lab2lch(lab2, channel_axis=0)[:2]
+
+    dL = L1 - L2
+    dC = C1 - C2
+    dH2 = get_dH2(lab1, lab2, channel_axis=0)
+
+    SL = 1
+    SC = 1 + k1 * C1
+    SH = 1 + k2 * C1
+
+    dE2 = (dL / (kL * SL)) ** 2
+    dE2 += (dC / (kC * SC)) ** 2
+    dE2 += dH2 / (kH * SH) ** 2
+    return np.sqrt(np.maximum(dE2, 0))
+
+
+def deltaE_ciede2000(lab1, lab2, kL=1, kC=1, kH=1, *, channel_axis=-1):
+    """Color difference as given by the CIEDE 2000 standard.
+
+    CIEDE 2000 is a major revision of CIDE94.  The perceptual calibration is
+    largely based on experience with automotive paint on smooth surfaces.
+
+    Parameters
+    ----------
+    lab1 : array_like
+        reference color (Lab colorspace)
+    lab2 : array_like
+        comparison color (Lab colorspace)
+    kL : float (range), optional
+        lightness scale factor, 1 for "acceptably close"; 2 for "imperceptible"
+        see deltaE_cmc
+    kC : float (range), optional
+        chroma scale factor, usually 1
+    kH : float (range), optional
+        hue scale factor, usually 1
+    channel_axis : int, optional
+        This parameter indicates which axis of the arrays corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    deltaE : array_like
+        The distance between `lab1` and `lab2`
+
+    Notes
+    -----
+    CIEDE 2000 assumes parametric weighting factors for the lightness, chroma,
+    and hue (`kL`, `kC`, `kH` respectively).  These default to 1.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Color_difference
+    .. [2] http://www.ece.rochester.edu/~gsharma/ciede2000/ciede2000noteCRNA.pdf
+           :DOI:`10.1364/AO.33.008069`
+    .. [3] M. Melgosa, J. Quesada, and E. Hita, "Uniformity of some recent
+           color metrics tested with an accurate color-difference tolerance
+           dataset," Appl. Opt. 33, 8069-8077 (1994).
+    """
+    lab1, lab2 = _float_inputs(lab1, lab2, allow_float32=True)
+
+    channel_axis = channel_axis % lab1.ndim
+    unroll = False
+    if lab1.ndim == 1 and lab2.ndim == 1:
+        unroll = True
+        if lab1.ndim == 1:
+            lab1 = lab1[None, :]
+        if lab2.ndim == 1:
+            lab2 = lab2[None, :]
+        channel_axis += 1
+    L1, a1, b1 = np.moveaxis(lab1, source=channel_axis, destination=0)[:3]
+    L2, a2, b2 = np.moveaxis(lab2, source=channel_axis, destination=0)[:3]
+
+    # distort `a` based on average chroma
+    # then convert to lch coordinates from distorted `a`
+    # all subsequence calculations are in the new coordinates
+    # (often denoted "prime" in the literature)
+    Cbar = 0.5 * (np.hypot(a1, b1) + np.hypot(a2, b2))
+    c7 = Cbar**7
+    G = 0.5 * (1 - np.sqrt(c7 / (c7 + 25**7)))
+    scale = 1 + G
+    C1, h1 = _cart2polar_2pi(a1 * scale, b1)
+    C2, h2 = _cart2polar_2pi(a2 * scale, b2)
+    # recall that c, h are polar coordinates.  c==r, h==theta
+
+    # cide2000 has four terms to delta_e:
+    # 1) Luminance term
+    # 2) Hue term
+    # 3) Chroma term
+    # 4) hue Rotation term
+
+    # lightness term
+    Lbar = 0.5 * (L1 + L2)
+    tmp = (Lbar - 50) ** 2
+    SL = 1 + 0.015 * tmp / np.sqrt(20 + tmp)
+    L_term = (L2 - L1) / (kL * SL)
+
+    # chroma term
+    Cbar = 0.5 * (C1 + C2)  # new coordinates
+    SC = 1 + 0.045 * Cbar
+    C_term = (C2 - C1) / (kC * SC)
+
+    # hue term
+    h_diff = h2 - h1
+    h_sum = h1 + h2
+    CC = C1 * C2
+
+    dH = h_diff.copy()
+    dH[h_diff > np.pi] -= 2 * np.pi
+    dH[h_diff < -np.pi] += 2 * np.pi
+    dH[CC == 0.0] = 0.0  # if r == 0, dtheta == 0
+    dH_term = 2 * np.sqrt(CC) * np.sin(dH / 2)
+
+    Hbar = h_sum.copy()
+    mask = np.logical_and(CC != 0.0, np.abs(h_diff) > np.pi)
+    Hbar[mask * (h_sum < 2 * np.pi)] += 2 * np.pi
+    Hbar[mask * (h_sum >= 2 * np.pi)] -= 2 * np.pi
+    Hbar[CC == 0.0] *= 2
+    Hbar *= 0.5
+
+    T = (
+        1
+        - 0.17 * np.cos(Hbar - np.deg2rad(30))
+        + 0.24 * np.cos(2 * Hbar)
+        + 0.32 * np.cos(3 * Hbar + np.deg2rad(6))
+        - 0.20 * np.cos(4 * Hbar - np.deg2rad(63))
+    )
+    SH = 1 + 0.015 * Cbar * T
+
+    H_term = dH_term / (kH * SH)
+
+    # hue rotation
+    c7 = Cbar**7
+    Rc = 2 * np.sqrt(c7 / (c7 + 25**7))
+    dtheta = np.deg2rad(30) * np.exp(-(((np.rad2deg(Hbar) - 275) / 25) ** 2))
+    R_term = -np.sin(2 * dtheta) * Rc * C_term * H_term
+
+    # put it all together
+    dE2 = L_term**2
+    dE2 += C_term**2
+    dE2 += H_term**2
+    dE2 += R_term
+    ans = np.sqrt(np.maximum(dE2, 0))
+    if unroll:
+        ans = ans[0]
+    return ans
+
+
+def deltaE_cmc(lab1, lab2, kL=1, kC=1, *, channel_axis=-1):
+    """Color difference from the  CMC l:c standard.
+
+    This color difference was developed by the Colour Measurement Committee
+    (CMC) of the Society of Dyers and Colourists (United Kingdom). It is
+    intended for use in the textile industry.
+
+    The scale factors `kL`, `kC` set the weight given to differences in
+    lightness and chroma relative to differences in hue.  The usual values are
+    ``kL=2``, ``kC=1`` for "acceptability" and ``kL=1``, ``kC=1`` for
+    "imperceptibility".  Colors with ``dE > 1`` are "different" for the given
+    scale factors.
+
+    Parameters
+    ----------
+    lab1 : array_like
+        reference color (Lab colorspace)
+    lab2 : array_like
+        comparison color (Lab colorspace)
+    channel_axis : int, optional
+        This parameter indicates which axis of the arrays corresponds to
+        channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    dE : array_like
+        distance between colors `lab1` and `lab2`
+
+    Notes
+    -----
+    deltaE_cmc the defines the scales for the lightness, hue, and chroma
+    in terms of the first color.  Consequently
+    ``deltaE_cmc(lab1, lab2) != deltaE_cmc(lab2, lab1)``
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Color_difference
+    .. [2] http://www.brucelindbloom.com/index.html?Eqn_DeltaE_CIE94.html
+    .. [3] F. J. J. Clarke, R. McDonald, and B. Rigg, "Modification to the
+           JPC79 colour-difference formula," J. Soc. Dyers Colour. 100, 128-132
+           (1984).
+    """
+    lab1, lab2 = _float_inputs(lab1, lab2, allow_float32=True)
+    lab1 = np.moveaxis(lab1, source=channel_axis, destination=0)
+    lab2 = np.moveaxis(lab2, source=channel_axis, destination=0)
+    L1, C1, h1 = lab2lch(lab1, channel_axis=0)[:3]
+    L2, C2, h2 = lab2lch(lab2, channel_axis=0)[:3]
+
+    dC = C1 - C2
+    dL = L1 - L2
+    dH2 = get_dH2(lab1, lab2, channel_axis=0)
+
+    T = np.where(
+        np.logical_and(np.rad2deg(h1) >= 164, np.rad2deg(h1) <= 345),
+        0.56 + 0.2 * np.abs(np.cos(h1 + np.deg2rad(168))),
+        0.36 + 0.4 * np.abs(np.cos(h1 + np.deg2rad(35))),
+    )
+    c1_4 = C1**4
+    F = np.sqrt(c1_4 / (c1_4 + 1900))
+
+    SL = np.where(L1 < 16, 0.511, 0.040975 * L1 / (1.0 + 0.01765 * L1))
+    SC = 0.638 + 0.0638 * C1 / (1.0 + 0.0131 * C1)
+    SH = SC * (F * T + 1 - F)
+
+    dE2 = (dL / (kL * SL)) ** 2
+    dE2 += (dC / (kC * SC)) ** 2
+    dE2 += dH2 / (SH**2)
+
+    return np.sqrt(np.maximum(dE2, 0))
+
+
+def get_dH2(lab1, lab2, *, channel_axis=-1):
+    """squared hue difference term occurring in deltaE_cmc and deltaE_ciede94
+
+    Despite its name, "dH" is not a simple difference of hue values.  We avoid
+    working directly with the hue value, since differencing angles is
+    troublesome.  The hue term is usually written as:
+        c1 = sqrt(a1**2 + b1**2)
+        c2 = sqrt(a2**2 + b2**2)
+        term = (a1-a2)**2 + (b1-b2)**2 - (c1-c2)**2
+        dH = sqrt(term)
+
+    However, this has poor roundoff properties when a or b is dominant.
+    Instead, ab is a vector with elements a and b.  The same dH term can be
+    re-written as:
+        |ab1-ab2|**2 - (|ab1| - |ab2|)**2
+    and then simplified to:
+        2*|ab1|*|ab2| - 2*dot(ab1, ab2)
+    """
+    # This function needs double precision internally for accuracy
+    input_is_float_32 = _supported_float_type((lab1.dtype, lab2.dtype)) == np.float32
+    lab1, lab2 = _float_inputs(lab1, lab2, allow_float32=False)
+
+    a1, b1 = np.moveaxis(lab1, source=channel_axis, destination=0)[1:3]
+    a2, b2 = np.moveaxis(lab2, source=channel_axis, destination=0)[1:3]
+
+    # magnitude of (a, b) is the chroma
+    C1 = np.hypot(a1, b1)
+    C2 = np.hypot(a2, b2)
+
+    term = (C1 * C2) - (a1 * a2 + b1 * b2)
+    out = 2 * term
+    if input_is_float_32:
+        out = out.astype(np.float32)
+    return out

envs/kitoverlay/skimage/color/rgb_colors.py

@@ -0,0 +1,146 @@
+aliceblue = (0.941, 0.973, 1)
+antiquewhite = (0.98, 0.922, 0.843)
+aqua = (0, 1, 1)
+aquamarine = (0.498, 1, 0.831)
+azure = (0.941, 1, 1)
+beige = (0.961, 0.961, 0.863)
+bisque = (1, 0.894, 0.769)
+black = (0, 0, 0)
+blanchedalmond = (1, 0.922, 0.804)
+blue = (0, 0, 1)
+blueviolet = (0.541, 0.169, 0.886)
+brown = (0.647, 0.165, 0.165)
+burlywood = (0.871, 0.722, 0.529)
+cadetblue = (0.373, 0.62, 0.627)
+chartreuse = (0.498, 1, 0)
+chocolate = (0.824, 0.412, 0.118)
+coral = (1, 0.498, 0.314)
+cornflowerblue = (0.392, 0.584, 0.929)
+cornsilk = (1, 0.973, 0.863)
+crimson = (0.863, 0.0784, 0.235)
+cyan = (0, 1, 1)
+darkblue = (0, 0, 0.545)
+darkcyan = (0, 0.545, 0.545)
+darkgoldenrod = (0.722, 0.525, 0.0431)
+darkgray = (0.663, 0.663, 0.663)
+darkgreen = (0, 0.392, 0)
+darkgrey = (0.663, 0.663, 0.663)
+darkkhaki = (0.741, 0.718, 0.42)
+darkmagenta = (0.545, 0, 0.545)
+darkolivegreen = (0.333, 0.42, 0.184)
+darkorange = (1, 0.549, 0)
+darkorchid = (0.6, 0.196, 0.8)
+darkred = (0.545, 0, 0)
+darksalmon = (0.914, 0.588, 0.478)
+darkseagreen = (0.561, 0.737, 0.561)
+darkslateblue = (0.282, 0.239, 0.545)
+darkslategray = (0.184, 0.31, 0.31)
+darkslategrey = (0.184, 0.31, 0.31)
+darkturquoise = (0, 0.808, 0.82)
+darkviolet = (0.58, 0, 0.827)
+deeppink = (1, 0.0784, 0.576)
+deepskyblue = (0, 0.749, 1)
+dimgray = (0.412, 0.412, 0.412)
+dimgrey = (0.412, 0.412, 0.412)
+dodgerblue = (0.118, 0.565, 1)
+firebrick = (0.698, 0.133, 0.133)
+floralwhite = (1, 0.98, 0.941)
+forestgreen = (0.133, 0.545, 0.133)
+fuchsia = (1, 0, 1)
+gainsboro = (0.863, 0.863, 0.863)
+ghostwhite = (0.973, 0.973, 1)
+gold = (1, 0.843, 0)
+goldenrod = (0.855, 0.647, 0.125)
+gray = (0.502, 0.502, 0.502)
+green = (0, 0.502, 0)
+greenyellow = (0.678, 1, 0.184)
+grey = (0.502, 0.502, 0.502)
+honeydew = (0.941, 1, 0.941)
+hotpink = (1, 0.412, 0.706)
+indianred = (0.804, 0.361, 0.361)
+indigo = (0.294, 0, 0.51)
+ivory = (1, 1, 0.941)
+khaki = (0.941, 0.902, 0.549)
+lavender = (0.902, 0.902, 0.98)
+lavenderblush = (1, 0.941, 0.961)
+lawngreen = (0.486, 0.988, 0)
+lemonchiffon = (1, 0.98, 0.804)
+lightblue = (0.678, 0.847, 0.902)
+lightcoral = (0.941, 0.502, 0.502)
+lightcyan = (0.878, 1, 1)
+lightgoldenrodyellow = (0.98, 0.98, 0.824)
+lightgray = (0.827, 0.827, 0.827)
+lightgreen = (0.565, 0.933, 0.565)
+lightgrey = (0.827, 0.827, 0.827)
+lightpink = (1, 0.714, 0.757)
+lightsalmon = (1, 0.627, 0.478)
+lightseagreen = (0.125, 0.698, 0.667)
+lightskyblue = (0.529, 0.808, 0.98)
+lightslategray = (0.467, 0.533, 0.6)
+lightslategrey = (0.467, 0.533, 0.6)
+lightsteelblue = (0.69, 0.769, 0.871)
+lightyellow = (1, 1, 0.878)
+lime = (0, 1, 0)
+limegreen = (0.196, 0.804, 0.196)
+linen = (0.98, 0.941, 0.902)
+magenta = (1, 0, 1)
+maroon = (0.502, 0, 0)
+mediumaquamarine = (0.4, 0.804, 0.667)
+mediumblue = (0, 0, 0.804)
+mediumorchid = (0.729, 0.333, 0.827)
+mediumpurple = (0.576, 0.439, 0.859)
+mediumseagreen = (0.235, 0.702, 0.443)
+mediumslateblue = (0.482, 0.408, 0.933)
+mediumspringgreen = (0, 0.98, 0.604)
+mediumturquoise = (0.282, 0.82, 0.8)
+mediumvioletred = (0.78, 0.0824, 0.522)
+midnightblue = (0.098, 0.098, 0.439)
+mintcream = (0.961, 1, 0.98)
+mistyrose = (1, 0.894, 0.882)
+moccasin = (1, 0.894, 0.71)
+navajowhite = (1, 0.871, 0.678)
+navy = (0, 0, 0.502)
+oldlace = (0.992, 0.961, 0.902)
+olive = (0.502, 0.502, 0)
+olivedrab = (0.42, 0.557, 0.137)
+orange = (1, 0.647, 0)
+orangered = (1, 0.271, 0)
+orchid = (0.855, 0.439, 0.839)
+palegoldenrod = (0.933, 0.91, 0.667)
+palegreen = (0.596, 0.984, 0.596)
+palevioletred = (0.686, 0.933, 0.933)
+papayawhip = (1, 0.937, 0.835)
+peachpuff = (1, 0.855, 0.725)
+peru = (0.804, 0.522, 0.247)
+pink = (1, 0.753, 0.796)
+plum = (0.867, 0.627, 0.867)
+powderblue = (0.69, 0.878, 0.902)
+purple = (0.502, 0, 0.502)
+red = (1, 0, 0)
+rosybrown = (0.737, 0.561, 0.561)
+royalblue = (0.255, 0.412, 0.882)
+saddlebrown = (0.545, 0.271, 0.0745)
+salmon = (0.98, 0.502, 0.447)
+sandybrown = (0.98, 0.643, 0.376)
+seagreen = (0.18, 0.545, 0.341)
+seashell = (1, 0.961, 0.933)
+sienna = (0.627, 0.322, 0.176)
+silver = (0.753, 0.753, 0.753)
+skyblue = (0.529, 0.808, 0.922)
+slateblue = (0.416, 0.353, 0.804)
+slategray = (0.439, 0.502, 0.565)
+slategrey = (0.439, 0.502, 0.565)
+snow = (1, 0.98, 0.98)
+springgreen = (0, 1, 0.498)
+steelblue = (0.275, 0.51, 0.706)
+tan = (0.824, 0.706, 0.549)
+teal = (0, 0.502, 0.502)
+thistle = (0.847, 0.749, 0.847)
+tomato = (1, 0.388, 0.278)
+turquoise = (0.251, 0.878, 0.816)
+violet = (0.933, 0.51, 0.933)
+wheat = (0.961, 0.871, 0.702)
+white = (1, 1, 1)
+whitesmoke = (0.961, 0.961, 0.961)
+yellow = (1, 1, 0)
+yellowgreen = (0.604, 0.804, 0.196)

envs/kitoverlay/skimage/exposure/__init__.py

@@ -0,0 +1,5 @@
+"""Image intensity adjustment, e.g., histogram equalization, etc."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/exposure/__init__.pyi

@@ -0,0 +1,29 @@
+# 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__ = [
+    'histogram',
+    'equalize_hist',
+    'equalize_adapthist',
+    'rescale_intensity',
+    'cumulative_distribution',
+    'adjust_gamma',
+    'adjust_sigmoid',
+    'adjust_log',
+    'is_low_contrast',
+    'match_histograms',
+]
+
+from ._adapthist import equalize_adapthist
+from .histogram_matching import match_histograms
+from .exposure import (
+    histogram,
+    equalize_hist,
+    rescale_intensity,
+    cumulative_distribution,
+    adjust_gamma,
+    adjust_sigmoid,
+    adjust_log,
+    is_low_contrast,
+)

envs/kitoverlay/skimage/exposure/_adapthist.py

@@ -0,0 +1,317 @@
+"""
+Adapted from "Contrast Limited Adaptive Histogram Equalization" by Karel
+Zuiderveld, Graphics Gems IV, Academic Press, 1994.
+
+http://tog.acm.org/resources/GraphicsGems/
+
+Relicensed with permission of the author under the Modified BSD license.
+"""
+
+import math
+import numbers
+
+import numpy as np
+
+from .._shared.utils import _supported_float_type
+from ..color.adapt_rgb import adapt_rgb, hsv_value
+from .exposure import rescale_intensity
+from ..util import img_as_uint
+
+NR_OF_GRAY = 2**14  # number of grayscale levels to use in CLAHE algorithm
+
+
+@adapt_rgb(hsv_value)
+def equalize_adapthist(image, kernel_size=None, clip_limit=0.01, nbins=256):
+    """Contrast Limited Adaptive Histogram Equalization (CLAHE).
+
+    An algorithm for local contrast enhancement, that uses histograms computed
+    over different tile regions of the image. Local details can therefore be
+    enhanced even in regions that are darker or lighter than most of the image.
+
+    Parameters
+    ----------
+    image : (M[, ...][, C]) ndarray
+        Input image.
+    kernel_size : int or array_like, optional
+        Defines the shape of contextual regions used in the algorithm. If
+        iterable is passed, it must have the same number of elements as
+        ``image.ndim`` (without color channel). If integer, it is broadcasted
+        to each `image` dimension. By default, ``kernel_size`` is 1/8 of
+        ``image`` height by 1/8 of its width.
+    clip_limit : float, optional
+        Clipping limit, normalized between 0 and 1 (higher values give more
+        contrast).
+    nbins : int, optional
+        Number of gray bins for histogram ("data range").
+
+    Returns
+    -------
+    out : (M[, ...][, C]) ndarray
+        Equalized image with float64 dtype.
+
+    See Also
+    --------
+    equalize_hist, rescale_intensity
+
+    Notes
+    -----
+    * For color images, the following steps are performed:
+       - The image is converted to HSV color space
+       - The CLAHE algorithm is run on the V (Value) channel
+       - The image is converted back to RGB space and returned
+    * For RGBA images, the original alpha channel is removed.
+
+    .. versionchanged:: 0.17
+        The values returned by this function are slightly shifted upwards
+        because of an internal change in rounding behavior.
+
+    References
+    ----------
+    .. [1] http://tog.acm.org/resources/GraphicsGems/
+    .. [2] https://en.wikipedia.org/wiki/CLAHE#CLAHE
+    """
+
+    float_dtype = _supported_float_type(image.dtype)
+    image = img_as_uint(image)
+    image = np.round(rescale_intensity(image, out_range=(0, NR_OF_GRAY - 1))).astype(
+        np.min_scalar_type(NR_OF_GRAY)
+    )
+
+    if kernel_size is None:
+        kernel_size = tuple([max(s // 8, 1) for s in image.shape])
+    elif isinstance(kernel_size, numbers.Number):
+        kernel_size = (kernel_size,) * image.ndim
+    elif len(kernel_size) != image.ndim:
+        raise ValueError(f'Incorrect value of `kernel_size`: {kernel_size}')
+
+    kernel_size = [int(k) for k in kernel_size]
+
+    image = _clahe(image, kernel_size, clip_limit, nbins)
+    image = image.astype(float_dtype, copy=False)
+    return rescale_intensity(image)
+
+
+def _clahe(image, kernel_size, clip_limit, nbins):
+    """Contrast Limited Adaptive Histogram Equalization.
+
+    Parameters
+    ----------
+    image : (M[, ...]) ndarray
+        Input image.
+    kernel_size : int or N-tuple of int
+        Defines the shape of contextual regions used in the algorithm.
+    clip_limit : float
+        Normalized clipping limit between 0 and 1 (higher values give more
+        contrast).
+    nbins : int
+        Number of gray bins for histogram ("data range").
+
+    Returns
+    -------
+    out : (M[, ...]) ndarray
+        Equalized image.
+
+    The number of "effective" graylevels in the output image is set by `nbins`;
+    selecting a small value (e.g. 128) speeds up processing and still produces
+    an output image of good quality. A clip limit of 0 or larger than or equal
+    to 1 results in standard (non-contrast limited) AHE.
+    """
+    ndim = image.ndim
+    dtype = image.dtype
+
+    # pad the image such that the shape in each dimension
+    # - is a multiple of the kernel_size and
+    # - is preceded by half a kernel size
+    pad_start_per_dim = [k // 2 for k in kernel_size]
+
+    pad_end_per_dim = [
+        (k - s % k) % k + int(np.ceil(k / 2.0))
+        for k, s in zip(kernel_size, image.shape)
+    ]
+
+    image = np.pad(
+        image,
+        [[p_i, p_f] for p_i, p_f in zip(pad_start_per_dim, pad_end_per_dim)],
+        mode='reflect',
+    )
+
+    # determine gray value bins
+    bin_size = 1 + NR_OF_GRAY // nbins
+    lut = np.arange(NR_OF_GRAY, dtype=np.min_scalar_type(NR_OF_GRAY))
+    lut //= bin_size
+
+    image = lut[image]
+
+    # calculate graylevel mappings for each contextual region
+    # rearrange image into flattened contextual regions
+    ns_hist = [int(s / k) - 1 for s, k in zip(image.shape, kernel_size)]
+    hist_blocks_shape = np.array([ns_hist, kernel_size]).T.flatten()
+    hist_blocks_axis_order = np.array(
+        [np.arange(0, ndim * 2, 2), np.arange(1, ndim * 2, 2)]
+    ).flatten()
+    hist_slices = [slice(k // 2, k // 2 + n * k) for k, n in zip(kernel_size, ns_hist)]
+    hist_blocks = image[tuple(hist_slices)].reshape(hist_blocks_shape)
+    hist_blocks = np.transpose(hist_blocks, axes=hist_blocks_axis_order)
+    hist_block_assembled_shape = hist_blocks.shape
+    hist_blocks = hist_blocks.reshape((math.prod(ns_hist), -1))
+
+    # Calculate actual clip limit
+    kernel_elements = math.prod(kernel_size)
+    if clip_limit > 0.0:
+        clim = int(np.clip(clip_limit * kernel_elements, 1, None))
+    else:
+        # largest possible value, i.e., do not clip (AHE)
+        clim = kernel_elements
+
+    hist = np.apply_along_axis(np.bincount, -1, hist_blocks, minlength=nbins)
+    hist = np.apply_along_axis(clip_histogram, -1, hist, clip_limit=clim)
+    hist = map_histogram(hist, 0, NR_OF_GRAY - 1, kernel_elements)
+    hist = hist.reshape(hist_block_assembled_shape[:ndim] + (-1,))
+
+    # duplicate leading mappings in each dim
+    map_array = np.pad(hist, [[1, 1] for _ in range(ndim)] + [[0, 0]], mode='edge')
+
+    # Perform multilinear interpolation of graylevel mappings
+    # using the convention described here:
+    # https://en.wikipedia.org/w/index.php?title=Adaptive_histogram_
+    # equalization&oldid=936814673#Efficient_computation_by_interpolation
+
+    # rearrange image into blocks for vectorized processing
+    ns_proc = [int(s / k) for s, k in zip(image.shape, kernel_size)]
+    blocks_shape = np.array([ns_proc, kernel_size]).T.flatten()
+    blocks_axis_order = np.array(
+        [np.arange(0, ndim * 2, 2), np.arange(1, ndim * 2, 2)]
+    ).flatten()
+    blocks = image.reshape(blocks_shape)
+    blocks = np.transpose(blocks, axes=blocks_axis_order)
+    blocks_flattened_shape = blocks.shape
+    blocks = np.reshape(blocks, (math.prod(ns_proc), math.prod(blocks.shape[ndim:])))
+
+    # calculate interpolation coefficients
+    coeffs = np.meshgrid(
+        *tuple([np.arange(k) / k for k in kernel_size[::-1]]), indexing='ij'
+    )
+    coeffs = [np.transpose(c).flatten() for c in coeffs]
+    inv_coeffs = [1 - c for dim, c in enumerate(coeffs)]
+
+    # sum over contributions of neighboring contextual
+    # regions in each direction
+    result = np.zeros(blocks.shape, dtype=np.float32)
+    for iedge, edge in enumerate(np.ndindex(*([2] * ndim))):
+        edge_maps = map_array[tuple([slice(e, e + n) for e, n in zip(edge, ns_proc)])]
+        edge_maps = edge_maps.reshape((math.prod(ns_proc), -1))
+
+        # apply map
+        edge_mapped = np.take_along_axis(edge_maps, blocks, axis=-1)
+
+        # interpolate
+        edge_coeffs = np.prod(
+            [[inv_coeffs, coeffs][e][d] for d, e in enumerate(edge[::-1])], 0
+        )
+
+        result += (edge_mapped * edge_coeffs).astype(result.dtype)
+
+    result = result.astype(dtype)
+
+    # rebuild result image from blocks
+    result = result.reshape(blocks_flattened_shape)
+    blocks_axis_rebuild_order = np.array(
+        [np.arange(0, ndim), np.arange(ndim, ndim * 2)]
+    ).T.flatten()
+    result = np.transpose(result, axes=blocks_axis_rebuild_order)
+    result = result.reshape(image.shape)
+
+    # undo padding
+    unpad_slices = tuple(
+        [
+            slice(p_i, s - p_f)
+            for p_i, p_f, s in zip(pad_start_per_dim, pad_end_per_dim, image.shape)
+        ]
+    )
+    result = result[unpad_slices]
+
+    return result
+
+
+def clip_histogram(hist, clip_limit):
+    """Perform clipping of the histogram and redistribution of bins.
+
+    The histogram is clipped and the number of excess pixels is counted.
+    Afterwards the excess pixels are equally redistributed across the
+    whole histogram (providing the bin count is smaller than the cliplimit).
+
+    Parameters
+    ----------
+    hist : ndarray
+        Histogram array.
+    clip_limit : int
+        Maximum allowed bin count.
+
+    Returns
+    -------
+    hist : ndarray
+        Clipped histogram.
+    """
+    # calculate total number of excess pixels
+    excess_mask = hist > clip_limit
+    excess = hist[excess_mask]
+    n_excess = excess.sum() - excess.size * clip_limit
+    hist[excess_mask] = clip_limit
+
+    # Second part: clip histogram and redistribute excess pixels in each bin
+    bin_incr = n_excess // hist.size  # average binincrement
+    upper = clip_limit - bin_incr  # Bins larger than upper set to cliplimit
+
+    low_mask = hist < upper
+    n_excess -= hist[low_mask].size * bin_incr
+    hist[low_mask] += bin_incr
+
+    mid_mask = np.logical_and(hist >= upper, hist < clip_limit)
+    mid = hist[mid_mask]
+    n_excess += mid.sum() - mid.size * clip_limit
+    hist[mid_mask] = clip_limit
+
+    while n_excess > 0:  # Redistribute remaining excess
+        prev_n_excess = n_excess
+        for index in range(hist.size):
+            under_mask = hist < clip_limit
+            step_size = max(1, np.count_nonzero(under_mask) // n_excess)
+            under_mask = under_mask[index::step_size]
+            hist[index::step_size][under_mask] += 1
+            n_excess -= np.count_nonzero(under_mask)
+            if n_excess <= 0:
+                break
+        if prev_n_excess == n_excess:
+            break
+
+    return hist
+
+
+def map_histogram(hist, min_val, max_val, n_pixels):
+    """Calculate the equalized lookup table (mapping).
+
+    It does so by cumulating the input histogram.
+    Histogram bins are assumed to be represented by the last array dimension.
+
+    Parameters
+    ----------
+    hist : ndarray
+        Clipped histogram.
+    min_val : int
+        Minimum value for mapping.
+    max_val : int
+        Maximum value for mapping.
+    n_pixels : int
+        Number of pixels in the region.
+
+    Returns
+    -------
+    out : ndarray
+       Mapped intensity LUT.
+    """
+    out = np.cumsum(hist, axis=-1).astype(float)
+    out *= (max_val - min_val) / n_pixels
+    out += min_val
+    np.clip(out, a_min=None, a_max=max_val, out=out)
+
+    return out.astype(int)

envs/kitoverlay/skimage/exposure/exposure.py

@@ -0,0 +1,851 @@
+import numpy as np
+
+from ..util.dtype import dtype_range, dtype_limits
+from .._shared import utils
+
+
+__all__ = [
+    'histogram',
+    'cumulative_distribution',
+    'equalize_hist',
+    'rescale_intensity',
+    'adjust_gamma',
+    'adjust_log',
+    'adjust_sigmoid',
+]
+
+
+DTYPE_RANGE = dtype_range.copy()
+DTYPE_RANGE.update((d.__name__, limits) for d, limits in dtype_range.items())
+DTYPE_RANGE.update(
+    {
+        'uint10': (0, 2**10 - 1),
+        'uint12': (0, 2**12 - 1),
+        'uint14': (0, 2**14 - 1),
+        'bool': dtype_range[bool],
+        'float': dtype_range[np.float64],
+    }
+)
+
+
+def _offset_array(arr, low_boundary, high_boundary):
+    """Offset the array to get the lowest value at 0 if negative."""
+    if low_boundary < 0:
+        offset = low_boundary
+        dyn_range = high_boundary - low_boundary
+        # get smallest dtype that can hold both minimum and offset maximum
+        offset_dtype = np.promote_types(
+            np.min_scalar_type(dyn_range), np.min_scalar_type(low_boundary)
+        )
+        if arr.dtype != offset_dtype:
+            # prevent overflow errors when offsetting
+            arr = arr.astype(offset_dtype)
+        arr = arr - offset
+    return arr
+
+
+def _bincount_histogram_centers(image, source_range):
+    """Compute bin centers for bincount-based histogram."""
+    if source_range not in ['image', 'dtype']:
+        raise ValueError(f'Incorrect value for `source_range` argument: {source_range}')
+    if source_range == 'image':
+        image_min = int(image.min().astype(np.int64))
+        image_max = int(image.max().astype(np.int64))
+    elif source_range == 'dtype':
+        image_min, image_max = dtype_limits(image, clip_negative=False)
+    bin_centers = np.arange(image_min, image_max + 1)
+    return bin_centers
+
+
+def _bincount_histogram(image, source_range, bin_centers=None):
+    """
+    Efficient histogram calculation for an image of integers.
+
+    This function is significantly more efficient than np.histogram but
+    works only on images of integers. It is based on np.bincount.
+
+    Parameters
+    ----------
+    image : array
+        Input image.
+    source_range : {'image', 'dtype'}
+        'image' determines the range from the input image.
+        'dtype' determines the range from the expected range of the images
+        of that data type.
+
+    Returns
+    -------
+    hist : array
+        The values of the histogram.
+    bin_centers : array
+        The values at the center of the bins.
+    """
+    if bin_centers is None:
+        bin_centers = _bincount_histogram_centers(image, source_range)
+    image_min, image_max = bin_centers[0], bin_centers[-1]
+    image = _offset_array(image, image_min, image_max)
+    hist = np.bincount(image.ravel(), minlength=image_max - min(image_min, 0) + 1)
+    if source_range == 'image':
+        idx = max(image_min, 0)
+        hist = hist[idx:]
+    return hist, bin_centers
+
+
+def _get_outer_edges(image, hist_range):
+    """Determine the outer bin edges to use for `numpy.histogram`.
+
+    These are obtained from either the image or hist_range.
+
+    Parameters
+    ----------
+    image : ndarray
+        Image for which the histogram is to be computed.
+    hist_range : 2-tuple of int or None
+        Range of values covered by the histogram bins. If None, the minimum
+        and maximum values of `image` are used.
+
+    Returns
+    -------
+    first_edge, last_edge : int
+        The range spanned by the histogram bins.
+
+    Notes
+    -----
+    This function is adapted from ``np.lib.histograms._get_outer_edges``.
+    """
+    if hist_range is not None:
+        first_edge, last_edge = hist_range
+        if first_edge > last_edge:
+            raise ValueError("max must be larger than min in hist_range parameter.")
+        if not (np.isfinite(first_edge) and np.isfinite(last_edge)):
+            raise ValueError(
+                f'supplied hist_range of [{first_edge}, {last_edge}] is ' f'not finite'
+            )
+    elif image.size == 0:
+        # handle empty arrays. Can't determine hist_range, so use 0-1.
+        first_edge, last_edge = 0, 1
+    else:
+        first_edge, last_edge = image.min(), image.max()
+        if not (np.isfinite(first_edge) and np.isfinite(last_edge)):
+            raise ValueError(
+                f'autodetected hist_range of [{first_edge}, {last_edge}] is '
+                f'not finite'
+            )
+
+    # expand empty hist_range to avoid divide by zero
+    if first_edge == last_edge:
+        first_edge = first_edge - 0.5
+        last_edge = last_edge + 0.5
+
+    return first_edge, last_edge
+
+
+def _get_bin_edges(image, nbins, hist_range):
+    """Computes histogram bins for use with `numpy.histogram`.
+
+    Parameters
+    ----------
+    image : ndarray
+        Image for which the histogram is to be computed.
+    nbins : int
+        The number of bins.
+    hist_range : 2-tuple of int
+        Range of values covered by the histogram bins.
+
+    Returns
+    -------
+    bin_edges : ndarray
+        The histogram bin edges.
+
+    Notes
+    -----
+    This function is a simplified version of
+    ``np.lib.histograms._get_bin_edges`` that only supports uniform bins.
+    """
+    first_edge, last_edge = _get_outer_edges(image, hist_range)
+    # numpy/gh-10322 means that type resolution rules are dependent on array
+    # shapes. To avoid this causing problems, we pick a type now and stick
+    # with it throughout.
+    bin_type = np.result_type(first_edge, last_edge, image)
+    if np.issubdtype(bin_type, np.integer):
+        bin_type = np.result_type(bin_type, float)
+
+    # compute bin edges
+    bin_edges = np.linspace(
+        first_edge, last_edge, nbins + 1, endpoint=True, dtype=bin_type
+    )
+    return bin_edges
+
+
+def _get_numpy_hist_range(image, source_range):
+    if source_range == 'image':
+        hist_range = None
+    elif source_range == 'dtype':
+        hist_range = dtype_limits(image, clip_negative=False)
+    else:
+        raise ValueError(f'Incorrect value for `source_range` argument: {source_range}')
+    return hist_range
+
+
+@utils.channel_as_last_axis(multichannel_output=False)
+def histogram(
+    image, nbins=256, source_range='image', normalize=False, *, channel_axis=None
+):
+    """Return histogram of image.
+
+    Unlike `numpy.histogram`, this function returns the centers of bins and
+    does not rebin integer arrays. For integer arrays, each integer value has
+    its own bin, which improves speed and intensity-resolution.
+
+    If `channel_axis` is not set, the histogram is computed on the flattened
+    image. For color or multichannel images, set ``channel_axis`` to use a
+    common binning for all channels. Alternatively, one may apply the function
+    separately on each channel to obtain a histogram for each color channel
+    with separate binning.
+
+    Parameters
+    ----------
+    image : array
+        Input image.
+    nbins : int, optional
+        Number of bins used to calculate histogram. This value is ignored for
+        integer arrays.
+    source_range : {'image', 'dtype'}, optional
+        'image' (default) determines the range from the input image.
+        'dtype' determines the range from the expected range of the images
+        of that data type.
+    normalize : bool, optional
+        If True, normalize the histogram by the sum of its values.
+    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.
+
+    Returns
+    -------
+    hist : array
+        The values of the histogram. When ``channel_axis`` is not None, hist
+        will be a 2D array where the first axis corresponds to channels.
+    bin_centers : array
+        The values at the center of the bins.
+
+    See Also
+    --------
+    cumulative_distribution
+
+    Examples
+    --------
+    >>> from skimage import data, exposure, img_as_float
+    >>> image = img_as_float(data.camera())
+    >>> np.histogram(image, bins=2)
+    (array([ 93585, 168559]), array([0. , 0.5, 1. ]))
+    >>> exposure.histogram(image, nbins=2)
+    (array([ 93585, 168559]), array([0.25, 0.75]))
+    """
+    sh = image.shape
+    if len(sh) == 3 and sh[-1] < 4 and channel_axis is None:
+        utils.warn(
+            'This might be a color image. The histogram will be '
+            'computed on the flattened image. You can instead '
+            'apply this function to each color channel, or set '
+            'channel_axis.'
+        )
+
+    if channel_axis is not None:
+        channels = sh[-1]
+        hist = []
+
+        # compute bins based on the raveled array
+        if np.issubdtype(image.dtype, np.integer):
+            # here bins corresponds to the bin centers
+            bins = _bincount_histogram_centers(image, source_range)
+        else:
+            # determine the bin edges for np.histogram
+            hist_range = _get_numpy_hist_range(image, source_range)
+            bins = _get_bin_edges(image, nbins, hist_range)
+
+        for chan in range(channels):
+            h, bc = _histogram(image[..., chan], bins, source_range, normalize)
+            hist.append(h)
+        # Convert to numpy arrays
+        bin_centers = np.asarray(bc)
+        hist = np.stack(hist, axis=0)
+    else:
+        hist, bin_centers = _histogram(image, nbins, source_range, normalize)
+
+    return hist, bin_centers
+
+
+def _histogram(image, bins, source_range, normalize):
+    """
+
+    Parameters
+    ----------
+    image : ndarray
+        Image for which the histogram is to be computed.
+    bins : int or ndarray
+        The number of histogram bins. For images with integer dtype, an array
+        containing the bin centers can also be provided. For images with
+        floating point dtype, this can be an array of bin_edges for use by
+        ``np.histogram``.
+    source_range : {'image', 'dtype'}, optional
+        'image' (default) determines the range from the input image.
+        'dtype' determines the range from the expected range of the images
+        of that data type.
+    normalize : bool, optional
+        If True, normalize the histogram by the sum of its values.
+    """
+
+    image = image.flatten()
+    # For integer types, histogramming with bincount is more efficient.
+    if np.issubdtype(image.dtype, np.integer):
+        bin_centers = bins if isinstance(bins, np.ndarray) else None
+        hist, bin_centers = _bincount_histogram(image, source_range, bin_centers)
+    else:
+        hist_range = _get_numpy_hist_range(image, source_range)
+        hist, bin_edges = np.histogram(image, bins=bins, range=hist_range)
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2.0
+
+    if normalize:
+        hist = hist / np.sum(hist)
+    return hist, bin_centers
+
+
+def cumulative_distribution(image, nbins=256):
+    """Return cumulative distribution function (cdf) for the given image.
+
+    Parameters
+    ----------
+    image : array
+        Image array.
+    nbins : int, optional
+        Number of bins for image histogram.
+
+    Returns
+    -------
+    img_cdf : array
+        Values of cumulative distribution function.
+    bin_centers : array
+        Centers of bins.
+
+    See Also
+    --------
+    histogram
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Cumulative_distribution_function
+
+    Examples
+    --------
+    >>> from skimage import data, exposure, img_as_float
+    >>> image = img_as_float(data.camera())
+    >>> hi = exposure.histogram(image)
+    >>> cdf = exposure.cumulative_distribution(image)
+    >>> all(cdf[0] == np.cumsum(hi[0])/float(image.size))
+    True
+    """
+    hist, bin_centers = histogram(image, nbins)
+    img_cdf = hist.cumsum()
+    img_cdf = img_cdf / float(img_cdf[-1])
+
+    # cast img_cdf to single precision for float32 or float16 inputs
+    cdf_dtype = utils._supported_float_type(image.dtype)
+    img_cdf = img_cdf.astype(cdf_dtype, copy=False)
+
+    return img_cdf, bin_centers
+
+
+def equalize_hist(image, nbins=256, mask=None):
+    """Return image after histogram equalization.
+
+    Parameters
+    ----------
+    image : array
+        Image array.
+    nbins : int, optional
+        Number of bins for image histogram. Note: this argument is
+        ignored for integer images, for which each integer is its own
+        bin.
+    mask : ndarray of bools or 0s and 1s, optional
+        Array of same shape as `image`. Only points at which mask == True
+        are used for the equalization, which is applied to the whole image.
+
+    Returns
+    -------
+    out : float array
+        Image array after histogram equalization.
+
+    Notes
+    -----
+    This function is adapted from [1]_ with the author's permission.
+
+    References
+    ----------
+    .. [1] http://www.janeriksolem.net/histogram-equalization-with-python-and.html
+    .. [2] https://en.wikipedia.org/wiki/Histogram_equalization
+
+    """
+    if mask is not None:
+        mask = np.array(mask, dtype=bool)
+        cdf, bin_centers = cumulative_distribution(image[mask], nbins)
+    else:
+        cdf, bin_centers = cumulative_distribution(image, nbins)
+    out = np.interp(image.flat, bin_centers, cdf)
+    out = out.reshape(image.shape)
+    # Unfortunately, np.interp currently always promotes to float64, so we
+    # have to cast back to single precision when float32 output is desired
+    return out.astype(utils._supported_float_type(image.dtype), copy=False)
+
+
+def intensity_range(image, range_values='image', clip_negative=False):
+    """Return image intensity range (min, max) based on desired value type.
+
+    Parameters
+    ----------
+    image : array
+        Input image.
+    range_values : str or 2-tuple, optional
+        The image intensity range is configured by this parameter.
+        The possible values for this parameter are enumerated below.
+
+        'image'
+            Return image min/max as the range.
+        'dtype'
+            Return min/max of the image's dtype as the range.
+        dtype-name
+            Return intensity range based on desired `dtype`. Must be valid key
+            in `DTYPE_RANGE`. Note: `image` is ignored for this range type.
+        2-tuple
+            Return `range_values` as min/max intensities. Note that there's no
+            reason to use this function if you just want to specify the
+            intensity range explicitly. This option is included for functions
+            that use `intensity_range` to support all desired range types.
+
+    clip_negative : bool, optional
+        If True, clip the negative range (i.e. return 0 for min intensity)
+        even if the image dtype allows negative values.
+    """
+    if range_values == 'dtype':
+        range_values = image.dtype.type
+
+    if range_values == 'image':
+        i_min = np.min(image)
+        i_max = np.max(image)
+    elif range_values in DTYPE_RANGE:
+        i_min, i_max = DTYPE_RANGE[range_values]
+        if clip_negative:
+            i_min = 0
+    else:
+        i_min, i_max = range_values
+    return i_min, i_max
+
+
+def _output_dtype(dtype_or_range, image_dtype):
+    """Determine the output dtype for rescale_intensity.
+
+    The dtype is determined according to the following rules:
+    - if ``dtype_or_range`` is a dtype, that is the output dtype.
+    - if ``dtype_or_range`` is a dtype string, that is the dtype used, unless
+      it is not a NumPy data type (e.g. 'uint12' for 12-bit unsigned integers),
+      in which case the data type that can contain it will be used
+      (e.g. uint16 in this case).
+    - if ``dtype_or_range`` is a pair of values, the output data type will be
+      ``_supported_float_type(image_dtype)``. This preserves float32 output for
+      float32 inputs.
+
+    Parameters
+    ----------
+    dtype_or_range : type, string, or 2-tuple of int/float
+        The desired range for the output, expressed as either a NumPy dtype or
+        as a (min, max) pair of numbers.
+    image_dtype : np.dtype
+        The input image dtype.
+
+    Returns
+    -------
+    out_dtype : type
+        The data type appropriate for the desired output.
+    """
+    if type(dtype_or_range) in [list, tuple, np.ndarray]:
+        # pair of values: always return float.
+        return utils._supported_float_type(image_dtype)
+    if type(dtype_or_range) == type:
+        # already a type: return it
+        return dtype_or_range
+    if dtype_or_range in DTYPE_RANGE:
+        # string key in DTYPE_RANGE dictionary
+        try:
+            # if it's a canonical numpy dtype, convert
+            return np.dtype(dtype_or_range).type
+        except TypeError:  # uint10, uint12, uint14
+            # otherwise, return uint16
+            return np.uint16
+    else:
+        raise ValueError(
+            'Incorrect value for out_range, should be a valid image data '
+            f'type or a pair of values, got {dtype_or_range}.'
+        )
+
+
+def rescale_intensity(image, in_range='image', out_range='dtype'):
+    """Return image after stretching or shrinking its intensity levels.
+
+    The desired intensity range of the input and output, `in_range` and
+    `out_range` respectively, are used to stretch or shrink the intensity range
+    of the input image. See examples below.
+
+    Parameters
+    ----------
+    image : array
+        Image array.
+    in_range, out_range : str or 2-tuple, optional
+        Min and max intensity values of input and output image.
+        The possible values for this parameter are enumerated below.
+
+        'image'
+            Use image min/max as the intensity range.
+        'dtype'
+            Use min/max of the image's dtype as the intensity range.
+        dtype-name
+            Use intensity range based on desired `dtype`. Must be valid key
+            in `DTYPE_RANGE`.
+        2-tuple
+            Use `range_values` as explicit min/max intensities.
+
+    Returns
+    -------
+    out : array
+        Image array after rescaling its intensity. This image is the same dtype
+        as the input image.
+
+    Notes
+    -----
+    .. versionchanged:: 0.17
+        The dtype of the output array has changed to match the input dtype, or
+        float if the output range is specified by a pair of values.
+
+    See Also
+    --------
+    equalize_hist
+
+    Examples
+    --------
+    By default, the min/max intensities of the input image are stretched to
+    the limits allowed by the image's dtype, since `in_range` defaults to
+    'image' and `out_range` defaults to 'dtype':
+
+    >>> image = np.array([51, 102, 153], dtype=np.uint8)
+    >>> rescale_intensity(image)
+    array([  0, 127, 255], dtype=uint8)
+
+    It's easy to accidentally convert an image dtype from uint8 to float:
+
+    >>> 1.0 * image
+    array([ 51., 102., 153.])
+
+    Use `rescale_intensity` to rescale to the proper range for float dtypes:
+
+    >>> image_float = 1.0 * image
+    >>> rescale_intensity(image_float)
+    array([0. , 0.5, 1. ])
+
+    To maintain the low contrast of the original, use the `in_range` parameter:
+
+    >>> rescale_intensity(image_float, in_range=(0, 255))
+    array([0.2, 0.4, 0.6])
+
+    If the min/max value of `in_range` is more/less than the min/max image
+    intensity, then the intensity levels are clipped:
+
+    >>> rescale_intensity(image_float, in_range=(0, 102))
+    array([0.5, 1. , 1. ])
+
+    If you have an image with signed integers but want to rescale the image to
+    just the positive range, use the `out_range` parameter. In that case, the
+    output dtype will be float:
+
+    >>> image = np.array([-10, 0, 10], dtype=np.int8)
+    >>> rescale_intensity(image, out_range=(0, 127))
+    array([  0. ,  63.5, 127. ])
+
+    To get the desired range with a specific dtype, use ``.astype()``:
+
+    >>> rescale_intensity(image, out_range=(0, 127)).astype(np.int8)
+    array([  0,  63, 127], dtype=int8)
+
+    If the input image is constant, the output will be clipped directly to the
+    output range:
+    >>> image = np.array([130, 130, 130], dtype=np.int32)
+    >>> rescale_intensity(image, out_range=(0, 127)).astype(np.int32)
+    array([127, 127, 127], dtype=int32)
+    """
+    if out_range in ['dtype', 'image']:
+        out_dtype = _output_dtype(image.dtype.type, image.dtype)
+    else:
+        out_dtype = _output_dtype(out_range, image.dtype)
+
+    imin, imax = map(float, intensity_range(image, in_range))
+    omin, omax = map(
+        float, intensity_range(image, out_range, clip_negative=(imin >= 0))
+    )
+
+    if np.any(np.isnan([imin, imax, omin, omax])):
+        utils.warn(
+            "One or more intensity levels are NaN. Rescaling will broadcast "
+            "NaN to the full image. Provide intensity levels yourself to "
+            "avoid this. E.g. with np.nanmin(image), np.nanmax(image).",
+            stacklevel=2,
+        )
+
+    image = np.clip(image, imin, imax)
+
+    if imin != imax:
+        image = (image - imin) / (imax - imin)
+        return (image * (omax - omin) + omin).astype(out_dtype)
+    else:
+        return np.clip(image, omin, omax).astype(out_dtype)
+
+
+def _assert_non_negative(image):
+    if np.any(image < 0):
+        raise ValueError(
+            'Image Correction methods work correctly only on '
+            'images with non-negative values. Use '
+            'skimage.exposure.rescale_intensity.'
+        )
+
+
+def _adjust_gamma_u8(image, gamma, gain):
+    """LUT based implementation of gamma adjustment."""
+    lut = 255 * gain * (np.linspace(0, 1, 256) ** gamma)
+    lut = np.minimum(np.rint(lut), 255).astype('uint8')
+    return lut[image]
+
+
+def adjust_gamma(image, gamma=1, gain=1):
+    """Perform gamma correction on the input image.
+
+    Gamma correction is a power-law transform [1]_. This function
+    transforms the input `image` pixel-wise according to the power law
+    ``image**gamma`` after scaling each pixel to the range 0 to 1. Then
+    it is rescaled to its original range and muliplied by `gain`.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    gamma : float, optional
+        Non negative real number. Default value is 1.
+    gain : float, optional
+        The constant multiplier. Default value is 1.
+
+    Returns
+    -------
+    out : ndarray
+        Gamma corrected output image.
+
+    See Also
+    --------
+    adjust_log
+
+    Notes
+    -----
+    For gamma greater than 1, the histogram will shift towards left and
+    the output image will be darker than the input image.
+
+    For gamma less than 1, the histogram will shift towards right and
+    the output image will be brighter than the input image.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Gamma_correction
+
+    Examples
+    --------
+    >>> import skimage as ski
+    >>> image = ski.util.img_as_float(ski.data.moon())
+    >>> gamma_corrected = ski.exposure.adjust_gamma(image, 2)
+    >>> # Output is darker for gamma > 1
+    >>> image.mean() > gamma_corrected.mean()
+    True
+    """
+    if gamma < 0:
+        raise ValueError("Gamma should be a non-negative real number.")
+
+    dtype = image.dtype.type
+
+    if dtype is np.uint8:
+        out = _adjust_gamma_u8(image, gamma, gain)
+    else:
+        _assert_non_negative(image)
+
+        limits = dtype_limits(image, clip_negative=True)
+        scale = float(limits[1] - limits[0])
+
+        out = (((image / scale) ** gamma) * scale * gain).astype(dtype)
+
+    return out
+
+
+def adjust_log(image, gain=1, inv=False):
+    """Performs Logarithmic correction on the input image.
+
+    This function transforms the input image pixelwise according to the
+    equation ``O = gain*log(1 + I)`` after scaling each pixel to the range
+    0 to 1. For inverse logarithmic correction, the equation is
+    ``O = gain*(2**I - 1)``.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    gain : float, optional
+        The constant multiplier. Default value is 1.
+    inv : float, optional
+        If True, it performs inverse logarithmic correction,
+        else correction will be logarithmic. Defaults to False.
+
+    Returns
+    -------
+    out : ndarray
+        Logarithm corrected output image.
+
+    See Also
+    --------
+    adjust_gamma
+
+    References
+    ----------
+    .. [1] http://www.ece.ucsb.edu/Faculty/Manjunath/courses/ece178W03/EnhancePart1.pdf
+
+    """
+    _assert_non_negative(image)
+    dtype = image.dtype.type
+    scale = float(dtype_limits(image, True)[1] - dtype_limits(image, True)[0])
+
+    if inv:
+        out = (2 ** (image / scale) - 1) * scale * gain
+        return dtype(out)
+
+    out = np.log2(1 + image / scale) * scale * gain
+    return out.astype(dtype)
+
+
+def adjust_sigmoid(image, cutoff=0.5, gain=10, inv=False):
+    """Performs Sigmoid Correction on the input image.
+
+    Also known as Contrast Adjustment.
+    This function transforms the input image pixelwise according to the
+    equation ``O = 1/(1 + exp*(gain*(cutoff - I)))`` after scaling each pixel
+    to the range 0 to 1.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    cutoff : float, optional
+        Cutoff of the sigmoid function that shifts the characteristic curve
+        in horizontal direction. Default value is 0.5.
+    gain : float, optional
+        The constant multiplier in exponential's power of sigmoid function.
+        Default value is 10.
+    inv : bool, optional
+        If True, returns the negative sigmoid correction. Defaults to False.
+
+    Returns
+    -------
+    out : ndarray
+        Sigmoid corrected output image.
+
+    See Also
+    --------
+    adjust_gamma
+
+    References
+    ----------
+    .. [1] Gustav J. Braun, "Image Lightness Rescaling Using Sigmoidal Contrast
+           Enhancement Functions",
+           http://markfairchild.org/PDFs/PAP07.pdf
+
+    """
+    _assert_non_negative(image)
+    dtype = image.dtype.type
+    scale = float(dtype_limits(image, True)[1] - dtype_limits(image, True)[0])
+
+    if inv:
+        out = (1 - 1 / (1 + np.exp(gain * (cutoff - image / scale)))) * scale
+        return dtype(out)
+
+    out = (1 / (1 + np.exp(gain * (cutoff - image / scale)))) * scale
+    return out.astype(dtype)
+
+
+def is_low_contrast(
+    image,
+    fraction_threshold=0.05,
+    lower_percentile=1,
+    upper_percentile=99,
+    method='linear',
+):
+    """Determine if an image is low contrast.
+
+    Parameters
+    ----------
+    image : array-like
+        The image under test.
+    fraction_threshold : float, optional
+        The low contrast fraction threshold. An image is considered low-
+        contrast when its range of brightness spans less than this
+        fraction of its data type's full range. [1]_
+    lower_percentile : float, optional
+        Disregard values below this percentile when computing image contrast.
+    upper_percentile : float, optional
+        Disregard values above this percentile when computing image contrast.
+    method : str, optional
+        The contrast determination method.  Right now the only available
+        option is "linear".
+
+    Returns
+    -------
+    out : bool
+        True when the image is determined to be low contrast.
+
+    Notes
+    -----
+    For boolean images, this function returns False only if all values are
+    the same (the method, threshold, and percentile arguments are ignored).
+
+    References
+    ----------
+    .. [1] https://scikit-image.org/docs/dev/user_guide/data_types.html
+
+    Examples
+    --------
+    >>> image = np.linspace(0, 0.04, 100)
+    >>> is_low_contrast(image)
+    True
+    >>> image[-1] = 1
+    >>> is_low_contrast(image)
+    True
+    >>> is_low_contrast(image, upper_percentile=100)
+    False
+    """
+    image = np.asanyarray(image)
+
+    if image.dtype == bool:
+        return not ((image.max() == 1) and (image.min() == 0))
+
+    if image.ndim == 3:
+        from ..color import rgb2gray, rgba2rgb  # avoid circular import
+
+        if image.shape[2] == 4:
+            image = rgba2rgb(image)
+        if image.shape[2] == 3:
+            image = rgb2gray(image)
+
+    dlimits = dtype_limits(image, clip_negative=False)
+    limits = np.percentile(image, [lower_percentile, upper_percentile])
+    ratio = (limits[1] - limits[0]) / (dlimits[1] - dlimits[0])
+
+    return ratio < fraction_threshold

envs/kitoverlay/skimage/exposure/histogram_matching.py

@@ -0,0 +1,93 @@
+import numpy as np
+
+from .._shared import utils
+
+
+def _match_cumulative_cdf(source, template):
+    """
+    Return modified source array so that the cumulative density function of
+    its values matches the cumulative density function of the template.
+    """
+    if source.dtype.kind == 'u':
+        src_lookup = source.reshape(-1)
+        src_counts = np.bincount(src_lookup)
+        tmpl_counts = np.bincount(template.reshape(-1))
+
+        # omit values where the count was 0
+        tmpl_values = np.nonzero(tmpl_counts)[0]
+        tmpl_counts = tmpl_counts[tmpl_values]
+    else:
+        src_values, src_lookup, src_counts = np.unique(
+            source.reshape(-1), return_inverse=True, return_counts=True
+        )
+        tmpl_values, tmpl_counts = np.unique(template.reshape(-1), return_counts=True)
+
+    # calculate normalized quantiles for each array
+    src_quantiles = np.cumsum(src_counts) / source.size
+    tmpl_quantiles = np.cumsum(tmpl_counts) / template.size
+
+    interp_a_values = np.interp(src_quantiles, tmpl_quantiles, tmpl_values)
+    return interp_a_values[src_lookup].reshape(source.shape)
+
+
+@utils.channel_as_last_axis(channel_arg_positions=(0, 1))
+def match_histograms(image, reference, *, channel_axis=None):
+    """Adjust an image so that its cumulative histogram matches that of another.
+
+    The adjustment is applied separately for each channel.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image. Can be gray-scale or in color.
+    reference : ndarray
+        Image to match histogram of. Must have the same number of channels as
+        image.
+    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.
+
+    Returns
+    -------
+    matched : ndarray
+        Transformed input image.
+
+    Raises
+    ------
+    ValueError
+        Thrown when the number of channels in the input image and the reference
+        differ.
+
+    References
+    ----------
+    .. [1] http://paulbourke.net/miscellaneous/equalisation/
+
+    """
+    if image.ndim != reference.ndim:
+        raise ValueError(
+            'Image and reference must have the same number ' 'of channels.'
+        )
+
+    if channel_axis is not None:
+        if image.shape[-1] != reference.shape[-1]:
+            raise ValueError(
+                'Number of channels in the input image and '
+                'reference image must match!'
+            )
+
+        matched = np.empty(image.shape, dtype=image.dtype)
+        for channel in range(image.shape[-1]):
+            matched_channel = _match_cumulative_cdf(
+                image[..., channel], reference[..., channel]
+            )
+            matched[..., channel] = matched_channel
+    else:
+        # _match_cumulative_cdf will always return float64 due to np.interp
+        matched = _match_cumulative_cdf(image, reference)
+
+    if matched.dtype.kind == 'f':
+        # output a float32 result when the input is float16 or float32
+        out_dtype = utils._supported_float_type(image.dtype)
+        matched = matched.astype(out_dtype, copy=False)
+    return matched

envs/kitoverlay/skimage/filters/__init__.py

@@ -0,0 +1,5 @@
+"""Sharpening, edge finding, rank filters, thresholding, etc."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/filters/__init__.pyi

@@ -0,0 +1,109 @@
+# 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__ = [
+    "LPIFilter2D",
+    "apply_hysteresis_threshold",
+    "butterworth",
+    "correlate_sparse",
+    "difference_of_gaussians",
+    "farid",
+    "farid_h",
+    "farid_v",
+    "filter_inverse",
+    "filter_forward",
+    "frangi",
+    "gabor",
+    "gabor_kernel",
+    "gaussian",
+    "hessian",
+    "laplace",
+    "median",
+    "meijering",
+    "prewitt",
+    "prewitt_h",
+    "prewitt_v",
+    "rank",
+    "rank_order",
+    "roberts",
+    "roberts_neg_diag",
+    "roberts_pos_diag",
+    "sato",
+    "scharr",
+    "scharr_h",
+    "scharr_v",
+    "sobel",
+    "sobel_h",
+    "sobel_v",
+    "threshold_isodata",
+    "threshold_li",
+    "threshold_local",
+    "threshold_mean",
+    "threshold_minimum",
+    "threshold_multiotsu",
+    "threshold_niblack",
+    "threshold_otsu",
+    "threshold_sauvola",
+    "threshold_triangle",
+    "threshold_yen",
+    "try_all_threshold",
+    "unsharp_mask",
+    "wiener",
+    "window",
+]
+
+from . import rank
+from ._fft_based import butterworth
+from ._gabor import gabor, gabor_kernel
+from ._gaussian import difference_of_gaussians, gaussian
+from ._median import median
+from ._rank_order import rank_order
+from ._sparse import correlate_sparse
+from ._unsharp_mask import unsharp_mask
+from ._window import window
+from .edges import (
+    farid,
+    farid_h,
+    farid_v,
+    laplace,
+    prewitt,
+    prewitt_h,
+    prewitt_v,
+    roberts,
+    roberts_neg_diag,
+    roberts_pos_diag,
+    scharr,
+    scharr_h,
+    scharr_v,
+    sobel,
+    sobel_h,
+    sobel_v,
+)
+from .lpi_filter import (
+    LPIFilter2D,
+    filter_inverse,
+    filter_forward,
+    wiener,
+)
+from .ridges import (
+    frangi,
+    hessian,
+    meijering,
+    sato,
+)
+from .thresholding import (
+    apply_hysteresis_threshold,
+    threshold_isodata,
+    threshold_li,
+    threshold_local,
+    threshold_mean,
+    threshold_minimum,
+    threshold_multiotsu,
+    threshold_niblack,
+    threshold_otsu,
+    threshold_sauvola,
+    threshold_triangle,
+    threshold_yen,
+    try_all_threshold,
+)

envs/kitoverlay/skimage/filters/_fft_based.py

@@ -0,0 +1,189 @@
+import functools
+
+import numpy as np
+import scipy.fft as fft
+
+from .._shared.utils import _supported_float_type
+
+
+def _get_nd_butterworth_filter(
+    shape, factor, order, high_pass, real, dtype=np.float64, squared_butterworth=True
+):
+    """Create a N-dimensional Butterworth mask for an FFT
+
+    Parameters
+    ----------
+    shape : tuple of int
+        Shape of the n-dimensional FFT and mask.
+    factor : float
+        Fraction of mask dimensions where the cutoff should be.
+    order : float
+        Controls the slope in the cutoff region.
+    high_pass : bool
+        Whether the filter is high pass (low frequencies attenuated) or
+        low pass (high frequencies are attenuated).
+    real : bool
+        Whether the FFT is of a real (True) or complex (False) image
+    squared_butterworth : bool, optional
+        When True, the square of the Butterworth filter is used.
+
+    Returns
+    -------
+    wfilt : ndarray
+        The FFT mask.
+
+    """
+    ranges = []
+    for i, d in enumerate(shape):
+        # start and stop ensures center of mask aligns with center of FFT
+        axis = np.arange(-(d - 1) // 2, (d - 1) // 2 + 1) / (d * factor)
+        ranges.append(fft.ifftshift(axis**2))
+    # for real image FFT, halve the last axis
+    if real:
+        limit = d // 2 + 1
+        ranges[-1] = ranges[-1][:limit]
+    # q2 = squared Euclidean distance grid
+    q2 = functools.reduce(np.add, np.meshgrid(*ranges, indexing="ij", sparse=True))
+    q2 = q2.astype(dtype)
+    q2 = np.power(q2, order)
+    wfilt = 1 / (1 + q2)
+    if high_pass:
+        wfilt *= q2
+    if not squared_butterworth:
+        np.sqrt(wfilt, out=wfilt)
+    return wfilt
+
+
+def butterworth(
+    image,
+    cutoff_frequency_ratio=0.005,
+    high_pass=True,
+    order=2.0,
+    channel_axis=None,
+    *,
+    squared_butterworth=True,
+    npad=0,
+):
+    """Apply a Butterworth filter to enhance high or low frequency features.
+
+    This filter is defined in the Fourier domain.
+
+    Parameters
+    ----------
+    image : (M[, N[, ..., P]][, C]) ndarray
+        Input image.
+    cutoff_frequency_ratio : float, optional
+        Determines the position of the cut-off relative to the shape of the
+        FFT. Receives a value between [0, 0.5].
+    high_pass : bool, optional
+        Whether to perform a high pass filter. If False, a low pass filter is
+        performed.
+    order : float, optional
+        Order of the filter which affects the slope near the cut-off. Higher
+        order means steeper slope in frequency space.
+    channel_axis : int, optional
+        If there is a channel dimension, provide the index here. If None
+        (default) then all axes are assumed to be spatial dimensions.
+    squared_butterworth : bool, optional
+        When True, the square of a Butterworth filter is used. See notes below
+        for more details.
+    npad : int, optional
+        Pad each edge of the image by `npad` pixels using `numpy.pad`'s
+        ``mode='edge'`` extension.
+
+    Returns
+    -------
+    result : ndarray
+        The Butterworth-filtered image.
+
+    Notes
+    -----
+    A band-pass filter can be achieved by combining a high-pass and low-pass
+    filter. The user can increase `npad` if boundary artifacts are apparent.
+
+    The "Butterworth filter" used in image processing textbooks (e.g. [1]_,
+    [2]_) is often the square of the traditional Butterworth filters as
+    described by [3]_, [4]_. The squared version will be used here if
+    `squared_butterworth` is set to ``True``. The lowpass, squared Butterworth
+    filter is given by the following expression for the lowpass case:
+
+    .. math::
+        H_{low}(f) = \\frac{1}{1 + \\left(\\frac{f}{c f_s}\\right)^{2n}}
+
+    with the highpass case given by
+
+    .. math::
+        H_{hi}(f) = 1 - H_{low}(f)
+
+    where :math:`f=\\sqrt{\\sum_{d=0}^{\\mathrm{ndim}} f_{d}^{2}}` is the
+    absolute value of the spatial frequency, :math:`f_s` is the sampling
+    frequency, :math:`c` the ``cutoff_frequency_ratio``, and :math:`n` is the
+    filter `order` [1]_. When ``squared_butterworth=False``, the square root of
+    the above expressions are used instead.
+
+    Note that ``cutoff_frequency_ratio`` is defined in terms of the sampling
+    frequency, :math:`f_s`. The FFT spectrum covers the Nyquist range
+    (:math:`[-f_s/2, f_s/2]`) so ``cutoff_frequency_ratio`` should have a value
+    between 0 and 0.5. The frequency response (gain) at the cutoff is 0.5 when
+    ``squared_butterworth`` is true and :math:`1/\\sqrt{2}` when it is false.
+
+    Examples
+    --------
+    Apply a high-pass and low-pass Butterworth filter to a grayscale and
+    color image respectively:
+
+    >>> from skimage.data import camera, astronaut
+    >>> from skimage.filters import butterworth
+    >>> high_pass = butterworth(camera(), 0.07, True, 8)
+    >>> low_pass = butterworth(astronaut(), 0.01, False, 4, channel_axis=-1)
+
+    References
+    ----------
+    .. [1] Russ, John C., et al. The Image Processing Handbook, 3rd. Ed.
+           1999, CRC Press, LLC.
+    .. [2] Birchfield, Stan. Image Processing and Analysis. 2018. Cengage
+           Learning.
+    .. [3] Butterworth, Stephen. "On the theory of filter amplifiers."
+           Wireless Engineer 7.6 (1930): 536-541.
+    .. [4] https://en.wikipedia.org/wiki/Butterworth_filter
+
+    """
+    if npad < 0:
+        raise ValueError("npad must be >= 0")
+    elif npad > 0:
+        center_slice = tuple(slice(npad, s + npad) for s in image.shape)
+        image = np.pad(image, npad, mode='edge')
+    fft_shape = (
+        image.shape if channel_axis is None else np.delete(image.shape, channel_axis)
+    )
+    is_real = np.isrealobj(image)
+    float_dtype = _supported_float_type(image.dtype, allow_complex=True)
+    if cutoff_frequency_ratio < 0 or cutoff_frequency_ratio > 0.5:
+        raise ValueError("cutoff_frequency_ratio should be in the range [0, 0.5]")
+    wfilt = _get_nd_butterworth_filter(
+        fft_shape,
+        cutoff_frequency_ratio,
+        order,
+        high_pass,
+        is_real,
+        float_dtype,
+        squared_butterworth,
+    )
+    axes = np.arange(image.ndim)
+    if channel_axis is not None:
+        axes = np.delete(axes, channel_axis)
+        abs_channel = channel_axis % image.ndim
+        post = image.ndim - abs_channel - 1
+        sl = (slice(None),) * abs_channel + (np.newaxis,) + (slice(None),) * post
+        wfilt = wfilt[sl]
+    if is_real:
+        butterfilt = fft.irfftn(
+            wfilt * fft.rfftn(image, axes=axes), s=fft_shape, axes=axes
+        )
+    else:
+        butterfilt = fft.ifftn(
+            wfilt * fft.fftn(image, axes=axes), s=fft_shape, axes=axes
+        )
+    if npad > 0:
+        butterfilt = butterfilt[center_slice]
+    return butterfilt

envs/kitoverlay/skimage/filters/_gabor.py

@@ -0,0 +1,220 @@
+import math
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from .._shared.utils import _supported_float_type, check_nD
+
+__all__ = ['gabor_kernel', 'gabor']
+
+
+def _sigma_prefactor(bandwidth):
+    b = bandwidth
+    # See http://www.cs.rug.nl/~imaging/simplecell.html
+    return 1.0 / np.pi * math.sqrt(math.log(2) / 2.0) * (2.0**b + 1) / (2.0**b - 1)
+
+
+def gabor_kernel(
+    frequency,
+    theta=0,
+    bandwidth=1,
+    sigma_x=None,
+    sigma_y=None,
+    n_stds=3,
+    offset=0,
+    dtype=np.complex128,
+):
+    """Return complex 2D Gabor filter kernel.
+
+    Gabor kernel is a Gaussian kernel modulated by a complex harmonic function.
+    Harmonic function consists of an imaginary sine function and a real
+    cosine function. Spatial frequency is inversely proportional to the
+    wavelength of the harmonic and to the standard deviation of a Gaussian
+    kernel. The bandwidth is also inversely proportional to the standard
+    deviation.
+
+    Parameters
+    ----------
+    frequency : float
+        Spatial frequency of the harmonic function. Specified in pixels.
+    theta : float, optional
+        Orientation in radians. If 0, the harmonic is in the x-direction.
+    bandwidth : float, optional
+        The bandwidth captured by the filter. For fixed bandwidth, ``sigma_x``
+        and ``sigma_y`` will decrease with increasing frequency. This value is
+        ignored if ``sigma_x`` and ``sigma_y`` are set by the user.
+    sigma_x, sigma_y : float, optional
+        Standard deviation in x- and y-directions. These directions apply to
+        the kernel *before* rotation. If `theta = pi/2`, then the kernel is
+        rotated 90 degrees so that ``sigma_x`` controls the *vertical*
+        direction.
+    n_stds : scalar, optional
+        The linear size of the kernel is n_stds (3 by default) standard
+        deviations
+    offset : float, optional
+        Phase offset of harmonic function in radians.
+    dtype : {np.complex64, np.complex128}
+        Specifies if the filter is single or double precision complex.
+
+    Returns
+    -------
+    g : complex array
+        Complex filter kernel.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Gabor_filter
+    .. [2] https://web.archive.org/web/20180127125930/http://mplab.ucsd.edu/tutorials/gabor.pdf
+
+    Examples
+    --------
+    >>> from skimage.filters import gabor_kernel
+    >>> from matplotlib import pyplot as plt  # doctest: +SKIP
+
+    >>> gk = gabor_kernel(frequency=0.2)
+    >>> fig, ax = plt.subplots()  # doctest: +SKIP
+    >>> ax.imshow(gk.real)        # doctest: +SKIP
+    >>> plt.show()                # doctest: +SKIP
+
+    >>> # more ripples (equivalent to increasing the size of the
+    >>> # Gaussian spread)
+    >>> gk = gabor_kernel(frequency=0.2, bandwidth=0.1)
+    >>> fig, ax = plt.suplots()  # doctest: +SKIP
+    >>> ax.imshow(gk.real)       # doctest: +SKIP
+    >>> plt.show()               # doctest: +SKIP
+    """
+    if sigma_x is None:
+        sigma_x = _sigma_prefactor(bandwidth) / frequency
+    if sigma_y is None:
+        sigma_y = _sigma_prefactor(bandwidth) / frequency
+
+    if np.dtype(dtype).kind != 'c':
+        raise ValueError("dtype must be complex")
+
+    ct = math.cos(theta)
+    st = math.sin(theta)
+    x0 = math.ceil(max(abs(n_stds * sigma_x * ct), abs(n_stds * sigma_y * st), 1))
+    y0 = math.ceil(max(abs(n_stds * sigma_y * ct), abs(n_stds * sigma_x * st), 1))
+    y, x = np.meshgrid(
+        np.arange(-y0, y0 + 1), np.arange(-x0, x0 + 1), indexing='ij', sparse=True
+    )
+    rotx = x * ct + y * st
+    roty = -x * st + y * ct
+
+    g = np.empty(roty.shape, dtype=dtype)
+    np.exp(
+        -0.5 * (rotx**2 / sigma_x**2 + roty**2 / sigma_y**2)
+        + 1j * (2 * np.pi * frequency * rotx + offset),
+        out=g,
+    )
+    g *= 1 / (2 * np.pi * sigma_x * sigma_y)
+
+    return g
+
+
+def gabor(
+    image,
+    frequency,
+    theta=0,
+    bandwidth=1,
+    sigma_x=None,
+    sigma_y=None,
+    n_stds=3,
+    offset=0,
+    mode='reflect',
+    cval=0,
+):
+    """Return real and imaginary responses to Gabor filter.
+
+    The real and imaginary parts of the Gabor filter kernel are applied to the
+    image and the response is returned as a pair of arrays.
+
+    Gabor filter is a linear filter with a Gaussian kernel which is modulated
+    by a sinusoidal plane wave. Frequency and orientation representations of
+    the Gabor filter are similar to those of the human visual system.
+    Gabor filter banks are commonly used in computer vision and image
+    processing. They are especially suitable for edge detection and texture
+    classification.
+
+    Parameters
+    ----------
+    image : 2-D array
+        Input image.
+    frequency : float
+        Spatial frequency of the harmonic function. Specified in pixels.
+    theta : float, optional
+        Orientation in radians. If 0, the harmonic is in the x-direction.
+    bandwidth : float, optional
+        The bandwidth captured by the filter. For fixed bandwidth, ``sigma_x``
+        and ``sigma_y`` will decrease with increasing frequency. This value is
+        ignored if ``sigma_x`` and ``sigma_y`` are set by the user.
+    sigma_x, sigma_y : float, optional
+        Standard deviation in x- and y-directions. These directions apply to
+        the kernel *before* rotation. If `theta = pi/2`, then the kernel is
+        rotated 90 degrees so that ``sigma_x`` controls the *vertical*
+        direction.
+    n_stds : scalar, optional
+        The linear size of the kernel is n_stds (3 by default) standard
+        deviations.
+    offset : float, optional
+        Phase offset of harmonic function in radians.
+    mode : {'constant', 'nearest', 'reflect', 'mirror', 'wrap'}, optional
+        Mode used to convolve image with a kernel, passed to `ndi.convolve`
+    cval : scalar, optional
+        Value to fill past edges of input if ``mode`` of convolution is
+        'constant'. The parameter is passed to `ndi.convolve`.
+
+    Returns
+    -------
+    real, imag : arrays
+        Filtered images using the real and imaginary parts of the Gabor filter
+        kernel. Images are of the same dimensions as the input one.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Gabor_filter
+    .. [2] https://web.archive.org/web/20180127125930/http://mplab.ucsd.edu/tutorials/gabor.pdf
+
+    Examples
+    --------
+    >>> from skimage.filters import gabor
+    >>> from skimage import data
+    >>> from matplotlib import pyplot as plt  # doctest: +SKIP
+
+    >>> image = data.coins()
+    >>> # detecting edges in a coin image
+    >>> filt_real, filt_imag = gabor(image, frequency=0.6)
+    >>> fix, ax = plt.subplots()  # doctest: +SKIP
+    >>> ax.imshow(filt_real)      # doctest: +SKIP
+    >>> plt.show()                # doctest: +SKIP
+
+    >>> # less sensitivity to finer details with the lower frequency kernel
+    >>> filt_real, filt_imag = gabor(image, frequency=0.1)
+    >>> fig, ax = plt.subplots()  # doctest: +SKIP
+    >>> ax.imshow(filt_real)      # doctest: +SKIP
+    >>> plt.show()                # doctest: +SKIP
+    """
+    check_nD(image, 2)
+    # do not cast integer types to float!
+    if image.dtype.kind == 'f':
+        float_dtype = _supported_float_type(image.dtype)
+        image = image.astype(float_dtype, copy=False)
+        kernel_dtype = np.promote_types(image.dtype, np.complex64)
+    else:
+        kernel_dtype = np.complex128
+
+    g = gabor_kernel(
+        frequency,
+        theta,
+        bandwidth,
+        sigma_x,
+        sigma_y,
+        n_stds,
+        offset,
+        dtype=kernel_dtype,
+    )
+
+    filtered_real = ndi.convolve(image, np.real(g), mode=mode, cval=cval)
+    filtered_imag = ndi.convolve(image, np.imag(g), mode=mode, cval=cval)
+
+    return filtered_real, filtered_imag