Add files using upload-large-folder tool

envs/kitoverlay/skimage/_vendored/numpy_lookfor.py

@@ -0,0 +1,298 @@
+# Vendored subset of numpy/lib/utils.py in 1.26.3
+# https://github.com/numpy/numpy/blob/b4bf93b936802618ebb49ee43e382b576b29a0a6/numpy/lib/utils.py
+#
+# Can be removed after deprecation of `skimage.lookfor` is completed.
+
+import sys
+import os
+import re
+
+from numpy import ufunc
+
+
+# Cache for lookfor: {id(module): {name: (docstring, kind, index), ...}...}
+# where kind: "func", "class", "module", "object"
+# and index: index in breadth-first namespace traversal
+_lookfor_caches = {}
+
+
+# regexp whose match indicates that the string may contain a function
+# signature
+_function_signature_re = re.compile(r"[a-z0-9_]+\(.*[,=].*\)", re.I)
+
+
+def _getmembers(item):
+    import inspect
+
+    try:
+        members = inspect.getmembers(item)
+    except Exception:
+        members = [(x, getattr(item, x)) for x in dir(item) if hasattr(item, x)]
+    return members
+
+
+def _lookfor_generate_cache(module, import_modules, regenerate):
+    """
+    Generate docstring cache for given module.
+
+    Parameters
+    ----------
+    module : str, None, module
+        Module for which to generate docstring cache
+    import_modules : bool
+        Whether to import sub-modules in packages.
+    regenerate : bool
+        Re-generate the docstring cache
+
+    Returns
+    -------
+    cache : dict {obj_full_name: (docstring, kind, index), ...}
+        Docstring cache for the module, either cached one (regenerate=False)
+        or newly generated.
+
+    """
+    # Local import to speed up numpy's import time.
+    import inspect
+
+    from io import StringIO
+
+    if module is None:
+        module = "skimage"
+
+    if isinstance(module, str):
+        try:
+            __import__(module)
+        except ImportError:
+            return {}
+        module = sys.modules[module]
+    elif isinstance(module, list) or isinstance(module, tuple):
+        cache = {}
+        for mod in module:
+            cache.update(_lookfor_generate_cache(mod, import_modules, regenerate))
+        return cache
+
+    if id(module) in _lookfor_caches and not regenerate:
+        return _lookfor_caches[id(module)]
+
+    # walk items and collect docstrings
+    cache = {}
+    _lookfor_caches[id(module)] = cache
+    seen = {}
+    index = 0
+    stack = [(module.__name__, module)]
+    while stack:
+        name, item = stack.pop(0)
+        if id(item) in seen:
+            continue
+        seen[id(item)] = True
+
+        index += 1
+        kind = "object"
+
+        if inspect.ismodule(item):
+            kind = "module"
+            try:
+                _all = item.__all__
+            except AttributeError:
+                _all = None
+
+            # import sub-packages
+            if import_modules and hasattr(item, '__path__'):
+                for pth in item.__path__:
+                    if os.path.isfile(pth) or not os.path.exists(pth):
+                        continue
+                    for mod_path in os.listdir(pth):
+                        this_py = os.path.join(pth, mod_path)
+                        init_py = os.path.join(pth, mod_path, '__init__.py')
+                        if os.path.isfile(this_py) and mod_path.endswith('.py'):
+                            to_import = mod_path[:-3]
+                        elif os.path.isfile(init_py):
+                            to_import = mod_path
+                        else:
+                            continue
+                        if to_import == '__init__':
+                            continue
+
+                        try:
+                            old_stdout = sys.stdout
+                            old_stderr = sys.stderr
+                            try:
+                                sys.stdout = StringIO()
+                                sys.stderr = StringIO()
+                                __import__(f"{name}.{to_import}")
+                            finally:
+                                sys.stdout = old_stdout
+                                sys.stderr = old_stderr
+                        except KeyboardInterrupt:
+                            # Assume keyboard interrupt came from a user
+                            raise
+                        except BaseException:
+                            # Ignore also SystemExit and pytests.importorskip
+                            # `Skipped` (these are BaseExceptions; gh-22345)
+                            continue
+
+            for n, v in _getmembers(item):
+                try:
+                    item_name = getattr(
+                        v,
+                        '__name__',
+                        f"{name}.{n}",
+                    )
+                    mod_name = getattr(v, '__module__', None)
+                except NameError:
+                    # ref. SWIG's global cvars
+                    #    NameError: Unknown C global variable
+                    item_name = f"{name}.{n}"
+                    mod_name = None
+                if '.' not in item_name and mod_name:
+                    item_name = f"{mod_name}.{item_name}"
+
+                if not item_name.startswith(name + '.'):
+                    # don't crawl "foreign" objects
+                    if isinstance(v, ufunc):
+                        # ... unless they are ufuncs
+                        pass
+                    else:
+                        continue
+                elif not (inspect.ismodule(v) or _all is None or n in _all):
+                    continue
+
+                stack.append((f"{name}.{n}", v))
+        elif inspect.isclass(item):
+            kind = "class"
+            for n, v in _getmembers(item):
+                stack.append((f"{name}.{n}", v))
+        elif hasattr(item, "__call__"):
+            kind = "func"
+
+        try:
+            doc = inspect.getdoc(item)
+        except NameError:
+            # ref SWIG's NameError: Unknown C global variable
+            doc = None
+        if doc is not None:
+            cache[name] = (doc, kind, index)
+
+    return cache
+
+
+def lookfor(what, module=None, import_modules=True, regenerate=False, output=None):
+    """
+    Do a keyword search on docstrings.
+
+    A list of objects that matched the search is displayed,
+    sorted by relevance. All given keywords need to be found in the
+    docstring for it to be returned as a result, but the order does
+    not matter.
+
+    Parameters
+    ----------
+    what : str
+        String containing words to look for.
+    module : str or list, optional
+        Name of module(s) whose docstrings to go through.
+    import_modules : bool, optional
+        Whether to import sub-modules in packages. Default is True.
+    regenerate : bool, optional
+        Whether to re-generate the docstring cache. Default is False.
+    output : file-like, optional
+        File-like object to write the output to. If omitted, use a pager.
+
+    See Also
+    --------
+    source, info
+
+    Notes
+    -----
+    Relevance is determined only roughly, by checking if the keywords occur
+    in the function name, at the start of a docstring, etc.
+
+    Examples
+    --------
+    >>> np.lookfor('binary representation') # doctest: +SKIP
+    Search results for 'binary representation'
+    ------------------------------------------
+    numpy.binary_repr
+        Return the binary representation of the input number as a string.
+    numpy.core.setup_common.long_double_representation
+        Given a binary dump as given by GNU od -b, look for long double
+    numpy.base_repr
+        Return a string representation of a number in the given base system.
+    ...
+
+    """
+    import pydoc
+
+    # Cache
+    cache = _lookfor_generate_cache(module, import_modules, regenerate)
+
+    # Search
+    # XXX: maybe using a real stemming search engine would be better?
+    found = []
+    whats = str(what).lower().split()
+    if not whats:
+        return
+
+    for name, (docstring, kind, index) in cache.items():
+        if kind in ('module', 'object'):
+            # don't show modules or objects
+            continue
+        doc = docstring.lower()
+        if all(w in doc for w in whats):
+            found.append(name)
+
+    # Relevance sort
+    # XXX: this is full Harrison-Stetson heuristics now,
+    # XXX: it probably could be improved
+
+    kind_relevance = {'func': 1000, 'class': 1000, 'module': -1000, 'object': -1000}
+
+    def relevance(name, docstr, kind, index):
+        r = 0
+        # do the keywords occur within the start of the docstring?
+        first_doc = "\n".join(docstr.lower().strip().split("\n")[:3])
+        r += sum([200 for w in whats if w in first_doc])
+        # do the keywords occur in the function name?
+        r += sum([30 for w in whats if w in name])
+        # is the full name long?
+        r += -len(name) * 5
+        # is the object of bad type?
+        r += kind_relevance.get(kind, -1000)
+        # is the object deep in namespace hierarchy?
+        r += -name.count('.') * 10
+        r += max(-index / 100, -100)
+        return r
+
+    def relevance_value(a):
+        return relevance(a, *cache[a])
+
+    found.sort(key=relevance_value)
+
+    # Pretty-print
+    s = f"Search results for '{' '.join(whats)}'"
+    help_text = [s, "-" * len(s)]
+    for name in found[::-1]:
+        doc, kind, ix = cache[name]
+
+        doclines = [line.strip() for line in doc.strip().split("\n") if line.strip()]
+
+        # find a suitable short description
+        try:
+            first_doc = doclines[0].strip()
+            if _function_signature_re.search(first_doc):
+                first_doc = doclines[1].strip()
+        except IndexError:
+            first_doc = ""
+        help_text.append(f"{name}\n    {first_doc}")
+
+    if not found:
+        help_text.append("Nothing found.")
+
+    # Output
+    if output is not None:
+        output.write("\n".join(help_text))
+    elif len(help_text) > 10:
+        pager = pydoc.getpager()
+        pager("\n".join(help_text))
+    else:
+        print("\n".join(help_text))

envs/kitoverlay/skimage/draw/__init__.py

@@ -0,0 +1,5 @@
+"""Drawing primitives, such as lines, circles, text, etc."""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/draw/__init__.pyi

@@ -0,0 +1,45 @@
+# 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__ = [
+    'line',
+    'line_aa',
+    'line_nd',
+    'bezier_curve',
+    'polygon',
+    'polygon_perimeter',
+    'ellipse',
+    'ellipse_perimeter',
+    'ellipsoid',
+    'ellipsoid_stats',
+    'circle_perimeter',
+    'circle_perimeter_aa',
+    'disk',
+    'set_color',
+    'random_shapes',
+    'rectangle',
+    'rectangle_perimeter',
+    'polygon2mask',
+]
+
+from .draw3d import ellipsoid, ellipsoid_stats
+from ._draw import _bezier_segment
+from ._random_shapes import random_shapes
+from ._polygon2mask import polygon2mask
+from .draw_nd import line_nd
+from .draw import (
+    ellipse,
+    set_color,
+    polygon_perimeter,
+    line,
+    line_aa,
+    polygon,
+    ellipse_perimeter,
+    circle_perimeter,
+    circle_perimeter_aa,
+    disk,
+    bezier_curve,
+    rectangle,
+    rectangle_perimeter,
+)

envs/kitoverlay/skimage/draw/_polygon2mask.py

@@ -0,0 +1,74 @@
+import numpy as np
+
+from . import draw
+
+
+def polygon2mask(image_shape, polygon):
+    """Create a binary mask from a polygon.
+
+    Parameters
+    ----------
+    image_shape : tuple of size 2
+        The shape of the mask.
+    polygon : (N, 2) array_like
+        The polygon coordinates of shape (N, 2) where N is
+        the number of points. The coordinates are (row, column).
+
+    Returns
+    -------
+    mask : 2-D ndarray of type 'bool'
+        The binary mask that corresponds to the input polygon.
+
+    See Also
+    --------
+    polygon:
+        Generate coordinates of pixels inside a polygon.
+
+    Notes
+    -----
+    This function does not do any border checking. Parts of the polygon that
+    are outside the coordinate space defined by `image_shape` are not drawn.
+
+    Examples
+    --------
+    >>> import skimage as ski
+    >>> image_shape = (10, 10)
+    >>> polygon = np.array([[1, 1], [2, 7], [8, 4]])
+    >>> mask = ski.draw.polygon2mask(image_shape, polygon)
+    >>> mask.astype(int)
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+
+    If vertices / points of the `polygon` are outside the coordinate space
+    defined by `image_shape`, only a part (or none at all) of the polygon is
+    drawn in the mask.
+
+    >>> offset = np.array([[2, -4]])
+    >>> ski.draw.polygon2mask(image_shape, polygon - offset).astype(int)
+    array([[0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    """
+    polygon = np.asarray(polygon)
+    vertex_row_coords, vertex_col_coords = polygon.T
+    fill_row_coords, fill_col_coords = draw.polygon(
+        vertex_row_coords, vertex_col_coords, image_shape
+    )
+    mask = np.zeros(image_shape, dtype=bool)
+    mask[fill_row_coords, fill_col_coords] = True
+    return mask

envs/kitoverlay/skimage/draw/_random_shapes.py

@@ -0,0 +1,459 @@
+import math
+
+import numpy as np
+
+from .draw import polygon as draw_polygon, disk as draw_disk, ellipse as draw_ellipse
+from .._shared.utils import warn
+
+
+def _generate_rectangle_mask(point, image, shape, random):
+    """Generate a mask for a filled rectangle shape.
+
+    The height and width of the rectangle are generated randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of the rectangle.
+    image : tuple
+        The height, width and depth of the image into which the shape
+        is placed.
+    shape : tuple
+        The minimum and maximum size of the shape to fit.
+    random : `numpy.random.Generator`
+
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+
+    """
+    available_width = min(image[1] - point[1], shape[1]) - shape[0]
+    available_height = min(image[0] - point[0], shape[1]) - shape[0]
+
+    # Pick random widths and heights.
+    r = shape[0] + random.integers(max(1, available_height)) - 1
+    c = shape[0] + random.integers(max(1, available_width)) - 1
+    rectangle = draw_polygon(
+        [
+            point[0],
+            point[0] + r,
+            point[0] + r,
+            point[0],
+        ],
+        [
+            point[1],
+            point[1],
+            point[1] + c,
+            point[1] + c,
+        ],
+    )
+    label = ('rectangle', ((point[0], point[0] + r + 1), (point[1], point[1] + c + 1)))
+
+    return rectangle, label
+
+
+def _generate_circle_mask(point, image, shape, random):
+    """Generate a mask for a filled circle shape.
+
+    The radius of the circle is generated randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of the rectangle.
+    image : tuple
+        The height, width and depth of the image into which the shape is placed.
+    shape : tuple
+        The minimum and maximum size and color of the shape to fit.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+    """
+    if shape[0] == 1 or shape[1] == 1:
+        raise ValueError('size must be > 1 for circles')
+    min_radius = shape[0] // 2.0
+    max_radius = shape[1] // 2.0
+    left = point[1]
+    right = image[1] - point[1]
+    top = point[0]
+    bottom = image[0] - point[0]
+    available_radius = min(left, right, top, bottom, max_radius) - min_radius
+    if available_radius < 0:
+        raise ArithmeticError('cannot fit shape to image')
+    radius = int(min_radius + random.integers(max(1, available_radius)))
+    # TODO: think about how to deprecate this
+    # while draw_circle was deprecated in favor of draw_disk
+    # switching to a label of 'disk' here
+    # would be a breaking change for downstream libraries
+    # See discussion on naming convention here
+    # https://github.com/scikit-image/scikit-image/pull/4428
+    disk = draw_disk((point[0], point[1]), radius)
+    # Until a deprecation path is decided, always return `'circle'`
+    label = (
+        'circle',
+        (
+            (point[0] - radius + 1, point[0] + radius),
+            (point[1] - radius + 1, point[1] + radius),
+        ),
+    )
+
+    return disk, label
+
+
+def _generate_triangle_mask(point, image, shape, random):
+    """Generate a mask for a filled equilateral triangle shape.
+
+    The length of the sides of the triangle is generated randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of a up-pointing triangle.
+    image : tuple
+        The height, width and depth of the image into which the shape
+        is placed.
+    shape : tuple
+        The minimum and maximum size and color of the shape to fit.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+
+    """
+    if shape[0] == 1 or shape[1] == 1:
+        raise ValueError('dimension must be > 1 for triangles')
+    available_side = min(image[1] - point[1], point[0], shape[1]) - shape[0]
+    side = shape[0] + random.integers(max(1, available_side)) - 1
+    triangle_height = int(np.ceil(np.sqrt(3 / 4.0) * side))
+    triangle = draw_polygon(
+        [
+            point[0],
+            point[0] - triangle_height,
+            point[0],
+        ],
+        [
+            point[1],
+            point[1] + side // 2,
+            point[1] + side,
+        ],
+    )
+    label = (
+        'triangle',
+        ((point[0] - triangle_height, point[0] + 1), (point[1], point[1] + side + 1)),
+    )
+
+    return triangle, label
+
+
+def _generate_ellipse_mask(point, image, shape, random):
+    """Generate a mask for a filled ellipse shape.
+
+    The rotation, major and minor semi-axes of the ellipse are generated
+    randomly.
+
+    Parameters
+    ----------
+    point : tuple
+        The row and column of the top left corner of the rectangle.
+    image : tuple
+        The height, width and depth of the image into which the shape is
+        placed.
+    shape : tuple
+        The minimum and maximum size and color of the shape to fit.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ArithmeticError
+        When a shape cannot be fit into the image with the given starting
+        coordinates. This usually means the image dimensions are too small or
+        shape dimensions too large.
+
+    Returns
+    -------
+    label : tuple
+        A (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+    indices : 2-D array
+        A mask of indices that the shape fills.
+    """
+    if shape[0] == 1 or shape[1] == 1:
+        raise ValueError('size must be > 1 for ellipses')
+    min_radius = shape[0] / 2.0
+    max_radius = shape[1] / 2.0
+    left = point[1]
+    right = image[1] - point[1]
+    top = point[0]
+    bottom = image[0] - point[0]
+    available_radius = min(left, right, top, bottom, max_radius)
+    if available_radius < min_radius:
+        raise ArithmeticError('cannot fit shape to image')
+    # NOTE: very conservative because we could take into account the fact that
+    # we have 2 different radii, but this is a good first approximation.
+    # Also, we can afford to have a uniform sampling because the ellipse will
+    # be rotated.
+    r_radius = random.uniform(min_radius, available_radius + 1)
+    c_radius = random.uniform(min_radius, available_radius + 1)
+    rotation = random.uniform(-np.pi, np.pi)
+    ellipse = draw_ellipse(
+        point[0],
+        point[1],
+        r_radius,
+        c_radius,
+        shape=image[:2],
+        rotation=rotation,
+    )
+    max_radius = math.ceil(max(r_radius, c_radius))
+    min_x = np.min(ellipse[0])
+    max_x = np.max(ellipse[0]) + 1
+    min_y = np.min(ellipse[1])
+    max_y = np.max(ellipse[1]) + 1
+    label = ('ellipse', ((min_x, max_x), (min_y, max_y)))
+
+    return ellipse, label
+
+
+# Allows lookup by key as well as random selection.
+SHAPE_GENERATORS = dict(
+    rectangle=_generate_rectangle_mask,
+    circle=_generate_circle_mask,
+    triangle=_generate_triangle_mask,
+    ellipse=_generate_ellipse_mask,
+)
+SHAPE_CHOICES = list(SHAPE_GENERATORS.values())
+
+
+def _generate_random_colors(num_colors, num_channels, intensity_range, random):
+    """Generate an array of random colors.
+
+    Parameters
+    ----------
+    num_colors : int
+        Number of colors to generate.
+    num_channels : int
+        Number of elements representing color.
+    intensity_range : {tuple of tuples of ints, tuple of ints}, optional
+        The range of values to sample pixel values from. For grayscale images
+        the format is (min, max). For multichannel - ((min, max),) if the
+        ranges are equal across the channels, and
+        ((min_0, max_0), ... (min_N, max_N)) if they differ.
+    random : `numpy.random.Generator`
+        The random state to use for random sampling.
+
+    Raises
+    ------
+    ValueError
+        When the `intensity_range` is not in the interval (0, 255).
+
+    Returns
+    -------
+    colors : array
+        An array of shape (num_colors, num_channels), where the values for
+        each channel are drawn from the corresponding `intensity_range`.
+
+    """
+    if num_channels == 1:
+        intensity_range = (intensity_range,)
+    elif len(intensity_range) == 1:
+        intensity_range = intensity_range * num_channels
+    colors = [random.integers(r[0], r[1] + 1, size=num_colors) for r in intensity_range]
+    return np.transpose(colors)
+
+
+def random_shapes(
+    image_shape,
+    max_shapes,
+    min_shapes=1,
+    min_size=2,
+    max_size=None,
+    num_channels=3,
+    shape=None,
+    intensity_range=None,
+    allow_overlap=False,
+    num_trials=100,
+    rng=None,
+    *,
+    channel_axis=-1,
+):
+    """Generate an image with random shapes, labeled with bounding boxes.
+
+    The image is populated with random shapes with random sizes, random
+    locations, and random colors, with or without overlap.
+
+    Shapes have random (row, col) starting coordinates and random sizes bounded
+    by `min_size` and `max_size`. It can occur that a randomly generated shape
+    will not fit the image at all. In that case, the algorithm will try again
+    with new starting coordinates a certain number of times. However, it also
+    means that some shapes may be skipped altogether. In that case, this
+    function will generate fewer shapes than requested.
+
+    Parameters
+    ----------
+    image_shape : tuple
+        The number of rows and columns of the image to generate.
+    max_shapes : int
+        The maximum number of shapes to (attempt to) fit into the shape.
+    min_shapes : int, optional
+        The minimum number of shapes to (attempt to) fit into the shape.
+    min_size : int, optional
+        The minimum dimension of each shape to fit into the image.
+    max_size : int, optional
+        The maximum dimension of each shape to fit into the image.
+    num_channels : int, optional
+        Number of channels in the generated image. If 1, generate monochrome
+        images, else color images with multiple channels. Ignored if
+        ``multichannel`` is set to False.
+    shape : {rectangle, circle, triangle, ellipse, None} str, optional
+        The name of the shape to generate or `None` to pick random ones.
+    intensity_range : {tuple of tuples of uint8, tuple of uint8}, optional
+        The range of values to sample pixel values from. For grayscale
+        images the format is (min, max). For multichannel - ((min, max),)
+        if the ranges are equal across the channels, and
+        ((min_0, max_0), ... (min_N, max_N)) if they differ. As the
+        function supports generation of uint8 arrays only, the maximum
+        range is (0, 255). If None, set to (0, 254) for each channel
+        reserving color of intensity = 255 for background.
+    allow_overlap : bool, optional
+        If `True`, allow shapes to overlap.
+    num_trials : int, optional
+        How often to attempt to fit a shape into the image before skipping it.
+    rng : {`numpy.random.Generator`, int}, optional
+        Pseudo-random number generator.
+        By default, a PCG64 generator is used (see :func:`numpy.random.default_rng`).
+        If `rng` is an int, it is used to seed the generator.
+    channel_axis : int or None, optional
+        If None, the image is assumed to be a grayscale (single channel) image.
+        Otherwise, this parameter indicates which axis of the array corresponds
+        to channels.
+
+        .. versionadded:: 0.19
+           ``channel_axis`` was added in 0.19.
+
+    Returns
+    -------
+    image : uint8 array
+        An image with the fitted shapes.
+    labels : list
+        A list of labels, one per shape in the image. Each label is a
+        (category, ((r0, r1), (c0, c1))) tuple specifying the category and
+        bounding box coordinates of the shape.
+
+    Examples
+    --------
+    >>> import skimage.draw
+    >>> image, labels = skimage.draw.random_shapes((32, 32), max_shapes=3)
+    >>> image # doctest: +SKIP
+    array([
+       [[255, 255, 255],
+        [255, 255, 255],
+        [255, 255, 255],
+        ...,
+        [255, 255, 255],
+        [255, 255, 255],
+        [255, 255, 255]]], dtype=uint8)
+    >>> labels # doctest: +SKIP
+    [('circle', ((22, 18), (25, 21))),
+     ('triangle', ((5, 6), (13, 13)))]
+    """
+    if min_size > image_shape[0] or min_size > image_shape[1]:
+        raise ValueError('Minimum dimension must be less than ncols and nrows')
+    max_size = max_size or max(image_shape[0], image_shape[1])
+
+    if channel_axis is None:
+        num_channels = 1
+
+    if intensity_range is None:
+        intensity_range = (0, 254) if num_channels == 1 else ((0, 254),)
+    else:
+        tmp = (intensity_range,) if num_channels == 1 else intensity_range
+        for intensity_pair in tmp:
+            for intensity in intensity_pair:
+                if not (0 <= intensity <= 255):
+                    msg = 'Intensity range must lie within (0, 255) interval'
+                    raise ValueError(msg)
+
+    rng = np.random.default_rng(rng)
+    user_shape = shape
+    image_shape = (image_shape[0], image_shape[1], num_channels)
+    image = np.full(image_shape, 255, dtype=np.uint8)
+    filled = np.zeros(image_shape, dtype=bool)
+    labels = []
+
+    num_shapes = rng.integers(min_shapes, max_shapes + 1)
+    colors = _generate_random_colors(num_shapes, num_channels, intensity_range, rng)
+    shape = (min_size, max_size)
+    for shape_idx in range(num_shapes):
+        if user_shape is None:
+            shape_generator = rng.choice(SHAPE_CHOICES)
+        else:
+            shape_generator = SHAPE_GENERATORS[user_shape]
+        for _ in range(num_trials):
+            # Pick start coordinates.
+            column = rng.integers(max(1, image_shape[1] - min_size))
+            row = rng.integers(max(1, image_shape[0] - min_size))
+            point = (row, column)
+            try:
+                indices, label = shape_generator(point, image_shape, shape, rng)
+            except ArithmeticError:
+                # Couldn't fit the shape, skip it.
+                indices = []
+                continue
+            # Check if there is an overlap where the mask is nonzero.
+            if allow_overlap or not filled[indices].any():
+                image[indices] = colors[shape_idx]
+                filled[indices] = True
+                labels.append(label)
+                break
+        else:
+            warn(
+                'Could not fit any shapes to image, '
+                'consider reducing the minimum dimension'
+            )
+
+    if channel_axis is None:
+        image = np.squeeze(image, axis=2)
+    else:
+        image = np.moveaxis(image, -1, channel_axis)
+
+    return image, labels

envs/kitoverlay/skimage/draw/draw.py

@@ -0,0 +1,970 @@
+import numpy as np
+
+from .._shared._geometry import polygon_clip
+from .._shared.version_requirements import require
+from .._shared.compat import NP_COPY_IF_NEEDED
+from ._draw import (
+    _coords_inside_image,
+    _line,
+    _line_aa,
+    _polygon,
+    _ellipse_perimeter,
+    _circle_perimeter,
+    _circle_perimeter_aa,
+    _bezier_curve,
+)
+
+
+__doctest_requires__ = {("polygon_perimeter", "rectangle_perimeter"): ["matplotlib"]}
+
+
+def _ellipse_in_shape(shape, center, radii, rotation=0.0):
+    """Generate coordinates of points within ellipse bounded by shape.
+
+    Parameters
+    ----------
+    shape :  iterable of ints
+        Shape of the input image.  Must be at least length 2. Only the first
+        two values are used to determine the extent of the input image.
+    center : iterable of floats
+        (row, column) position of center inside the given shape.
+    radii : iterable of floats
+        Size of two half axes (for row and column)
+    rotation : float, optional
+        Rotation of the ellipse defined by the above, in radians
+        in range (-PI, PI), in contra clockwise direction,
+        with respect to the column-axis.
+
+    Returns
+    -------
+    rows : iterable of ints
+        Row coordinates representing values within the ellipse.
+    cols : iterable of ints
+        Corresponding column coordinates representing values within the ellipse.
+    """
+    r_lim, c_lim = np.ogrid[0 : float(shape[0]), 0 : float(shape[1])]
+    r_org, c_org = center
+    r_rad, c_rad = radii
+    rotation %= np.pi
+    sin_alpha, cos_alpha = np.sin(rotation), np.cos(rotation)
+    r, c = (r_lim - r_org), (c_lim - c_org)
+    distances = ((r * cos_alpha + c * sin_alpha) / r_rad) ** 2 + (
+        (r * sin_alpha - c * cos_alpha) / c_rad
+    ) ** 2
+    return np.nonzero(distances < 1)
+
+
+def ellipse(r, c, r_radius, c_radius, shape=None, rotation=0.0):
+    """Generate coordinates of pixels within ellipse.
+
+    Parameters
+    ----------
+    r, c : double
+        Centre coordinate of ellipse.
+    r_radius, c_radius : double
+        Minor and major semi-axes. ``(r/r_radius)**2 + (c/c_radius)**2 = 1``.
+    shape : tuple, optional
+        Image shape which is used to determine the maximum extent of output pixel
+        coordinates. This is useful for ellipses which exceed the image size.
+        By default the full extent of the ellipse are used. Must be at least
+        length 2. Only the first two values are used to determine the extent.
+    rotation : float, optional (default 0.)
+        Set the ellipse rotation (rotation) in range (-PI, PI)
+        in contra clock wise direction, so PI/2 degree means swap ellipse axis
+
+    Returns
+    -------
+    rr, cc : ndarray of int
+        Pixel coordinates of ellipse.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Examples
+    --------
+    >>> from skimage.draw import ellipse
+    >>> img = np.zeros((10, 12), dtype=np.uint8)
+    >>> rr, cc = ellipse(5, 6, 3, 5, rotation=np.deg2rad(30))
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+
+    Notes
+    -----
+    The ellipse equation::
+
+        ((x * cos(alpha) + y * sin(alpha)) / x_radius) ** 2 +
+        ((x * sin(alpha) - y * cos(alpha)) / y_radius) ** 2 = 1
+
+
+    Note that the positions of `ellipse` without specified `shape` can have
+    also, negative values, as this is correct on the plane. On the other hand
+    using these ellipse positions for an image afterwards may lead to appearing
+    on the other side of image, because ``image[-1, -1] = image[end-1, end-1]``
+
+    >>> rr, cc = ellipse(1, 2, 3, 6)
+    >>> img = np.zeros((6, 12), dtype=np.uint8)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1],
+           [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1],
+           [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1],
+           [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1]], dtype=uint8)
+    """
+
+    center = np.array([r, c])
+    radii = np.array([r_radius, c_radius])
+    # allow just rotation with in range +/- 180 degree
+    rotation %= np.pi
+
+    # compute rotated radii by given rotation
+    r_radius_rot = abs(r_radius * np.cos(rotation)) + c_radius * np.sin(rotation)
+    c_radius_rot = r_radius * np.sin(rotation) + abs(c_radius * np.cos(rotation))
+    # The upper_left and lower_right corners of the smallest rectangle
+    # containing the ellipse.
+    radii_rot = np.array([r_radius_rot, c_radius_rot])
+    upper_left = np.ceil(center - radii_rot).astype(int)
+    lower_right = np.floor(center + radii_rot).astype(int)
+
+    if shape is not None:
+        # Constrain upper_left and lower_right by shape boundary.
+        upper_left = np.maximum(upper_left, np.array([0, 0]))
+        lower_right = np.minimum(lower_right, np.array(shape[:2]) - 1)
+
+    shifted_center = center - upper_left
+    bounding_shape = lower_right - upper_left + 1
+
+    rr, cc = _ellipse_in_shape(bounding_shape, shifted_center, radii, rotation)
+    rr.flags.writeable = True
+    cc.flags.writeable = True
+    rr += upper_left[0]
+    cc += upper_left[1]
+    return rr, cc
+
+
+def disk(center, radius, *, shape=None):
+    """Generate coordinates of pixels within circle.
+
+    Parameters
+    ----------
+    center : tuple
+        Center coordinate of disk.
+    radius : double
+        Radius of disk.
+    shape : tuple, optional
+        Image shape as a tuple of size 2. Determines the maximum
+        extent of output pixel coordinates. This is useful for disks that
+        exceed the image size. If None, the full extent of the disk is used.
+        The  shape might result in negative coordinates and wraparound
+        behaviour.
+
+    Returns
+    -------
+    rr, cc : ndarray of int
+        Pixel coordinates of disk.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.draw import disk
+    >>> shape = (4, 4)
+    >>> img = np.zeros(shape, dtype=np.uint8)
+    >>> rr, cc = disk((0, 0), 2, shape=shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[1, 1, 0, 0],
+           [1, 1, 0, 0],
+           [0, 0, 0, 0],
+           [0, 0, 0, 0]], dtype=uint8)
+    >>> img = np.zeros(shape, dtype=np.uint8)
+    >>> # Negative coordinates in rr and cc perform a wraparound
+    >>> rr, cc = disk((0, 0), 2, shape=None)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[1, 1, 0, 1],
+           [1, 1, 0, 1],
+           [0, 0, 0, 0],
+           [1, 1, 0, 1]], dtype=uint8)
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = disk((4, 4), 5)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+           [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+           [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+           [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+           [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+           [1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
+           [0, 1, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    """
+    r, c = center
+    return ellipse(r, c, radius, radius, shape)
+
+
+@require("matplotlib", ">=3.3")
+def polygon_perimeter(r, c, shape=None, clip=False):
+    """Generate polygon perimeter coordinates.
+
+    Parameters
+    ----------
+    r : (N,) ndarray
+        Row coordinates of vertices of polygon.
+    c : (N,) ndarray
+        Column coordinates of vertices of polygon.
+    shape : tuple, optional
+        Image shape which is used to determine maximum extents of output pixel
+        coordinates. This is useful for polygons that exceed the image size.
+        If None, the full extents of the polygon is used.  Must be at least
+        length 2. Only the first two values are used to determine the extent of
+        the input image.
+    clip : bool, optional
+        Whether to clip the polygon to the provided shape.  If this is set
+        to True, the drawn figure will always be a closed polygon with all
+        edges visible.
+
+    Returns
+    -------
+    rr, cc : ndarray of int
+        Pixel coordinates of polygon.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Examples
+    --------
+    >>> from skimage.draw import polygon_perimeter
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = polygon_perimeter([5, -1, 5, 10],
+    ...                            [-1, 5, 11, 5],
+    ...                            shape=img.shape, clip=True)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0, 1, 0, 0],
+           [0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
+           [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+           [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+           [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+           [0, 1, 1, 0, 0, 0, 0, 0, 0, 1],
+           [0, 0, 0, 1, 0, 0, 0, 1, 1, 0],
+           [0, 0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8)
+
+    """
+    if clip:
+        if shape is None:
+            raise ValueError("Must specify clipping shape")
+        clip_box = np.array([0, 0, shape[0] - 1, shape[1] - 1])
+    else:
+        clip_box = np.array([np.min(r), np.min(c), np.max(r), np.max(c)])
+
+    # Do the clipping irrespective of whether clip is set.  This
+    # ensures that the returned polygon is closed and is an array.
+    r, c = polygon_clip(r, c, *clip_box)
+
+    r = np.round(r).astype(int)
+    c = np.round(c).astype(int)
+
+    # Construct line segments
+    rr, cc = [], []
+    for i in range(len(r) - 1):
+        line_r, line_c = line(r[i], c[i], r[i + 1], c[i + 1])
+        rr.extend(line_r)
+        cc.extend(line_c)
+
+    rr = np.asarray(rr)
+    cc = np.asarray(cc)
+
+    if shape is None:
+        return rr, cc
+    else:
+        return _coords_inside_image(rr, cc, shape)
+
+
+def set_color(image, coords, color, alpha=1):
+    """Set pixel color in the image at the given coordinates.
+
+    Note that this function modifies the color of the image in-place.
+    Coordinates that exceed the shape of the image will be ignored.
+
+    Parameters
+    ----------
+    image : (M, N, C) ndarray
+        Image
+    coords : tuple of ((K,) ndarray, (K,) ndarray)
+        Row and column coordinates of pixels to be colored.
+    color : (C,) ndarray
+        Color to be assigned to coordinates in the image.
+    alpha : scalar or (K,) ndarray
+        Alpha values used to blend color with image.  0 is transparent,
+        1 is opaque.
+
+    Examples
+    --------
+    >>> from skimage.draw import line, set_color
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = line(1, 1, 20, 20)
+    >>> set_color(img, (rr, cc), 1)
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]], dtype=uint8)
+
+    """
+    rr, cc = coords
+
+    if image.ndim == 2:
+        image = image[..., np.newaxis]
+
+    color = np.array(color, ndmin=1, copy=NP_COPY_IF_NEEDED)
+
+    if image.shape[-1] != color.shape[-1]:
+        raise ValueError(
+            f'Color shape ({color.shape[0]}) must match last '
+            'image dimension ({image.shape[-1]}).'
+        )
+
+    if np.isscalar(alpha):
+        # Can be replaced by ``full_like`` when numpy 1.8 becomes
+        # minimum dependency
+        alpha = np.ones_like(rr) * alpha
+
+    rr, cc, alpha = _coords_inside_image(rr, cc, image.shape, val=alpha)
+
+    alpha = alpha[..., np.newaxis]
+
+    color = color * alpha
+    vals = image[rr, cc] * (1 - alpha)
+
+    image[rr, cc] = vals + color
+
+
+def line(r0, c0, r1, c1):
+    """Generate line pixel coordinates.
+
+    Parameters
+    ----------
+    r0, c0 : int
+        Starting position (row, column).
+    r1, c1 : int
+        End position (row, column).
+
+    Returns
+    -------
+    rr, cc : (N,) ndarray of int
+        Indices of pixels that belong to the line.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Notes
+    -----
+    Anti-aliased line generator is available with `line_aa`.
+
+    Examples
+    --------
+    >>> from skimage.draw import line
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = line(1, 1, 8, 8)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    """
+    return _line(r0, c0, r1, c1)
+
+
+def line_aa(r0, c0, r1, c1):
+    """Generate anti-aliased line pixel coordinates.
+
+    Parameters
+    ----------
+    r0, c0 : int
+        Starting position (row, column).
+    r1, c1 : int
+        End position (row, column).
+
+    Returns
+    -------
+    rr, cc, val : (N,) ndarray (int, int, float)
+        Indices of pixels (`rr`, `cc`) and intensity values (`val`).
+        ``img[rr, cc] = val``.
+
+    References
+    ----------
+    .. [1] A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012
+           http://members.chello.at/easyfilter/Bresenham.pdf
+
+    Examples
+    --------
+    >>> from skimage.draw import line_aa
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc, val = line_aa(1, 1, 8, 8)
+    >>> img[rr, cc] = val * 255
+    >>> img
+    array([[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0],
+           [  0, 255,  74,   0,   0,   0,   0,   0,   0,   0],
+           [  0,  74, 255,  74,   0,   0,   0,   0,   0,   0],
+           [  0,   0,  74, 255,  74,   0,   0,   0,   0,   0],
+           [  0,   0,   0,  74, 255,  74,   0,   0,   0,   0],
+           [  0,   0,   0,   0,  74, 255,  74,   0,   0,   0],
+           [  0,   0,   0,   0,   0,  74, 255,  74,   0,   0],
+           [  0,   0,   0,   0,   0,   0,  74, 255,  74,   0],
+           [  0,   0,   0,   0,   0,   0,   0,  74, 255,   0],
+           [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0]], dtype=uint8)
+    """
+    return _line_aa(r0, c0, r1, c1)
+
+
+def polygon(r, c, shape=None):
+    """Generate coordinates of pixels inside a polygon.
+
+    Parameters
+    ----------
+    r : (N,) array_like
+        Row coordinates of the polygon's vertices.
+    c : (N,) array_like
+        Column coordinates of the polygon's vertices.
+    shape : tuple, optional
+        Image shape which is used to determine the maximum extent of output
+        pixel coordinates. This is useful for polygons that exceed the image
+        size. If None, the full extent of the polygon is used.  Must be at
+        least length 2. Only the first two values are used to determine the
+        extent of the input image.
+
+    Returns
+    -------
+    rr, cc : ndarray of int
+        Pixel coordinates of polygon.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    See Also
+    --------
+    polygon2mask:
+        Create a binary mask from a polygon.
+
+    Notes
+    -----
+    This function ensures that `rr` and `cc` don't contain negative values.
+    Pixels of the polygon that whose coordinates are smaller 0, are not drawn.
+
+    Examples
+    --------
+    >>> import skimage as ski
+    >>> r = np.array([1, 2, 8])
+    >>> c = np.array([1, 7, 4])
+    >>> rr, cc = ski.draw.polygon(r, c)
+    >>> img = np.zeros((10, 10), dtype=int)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+
+    If the image `shape` is defined and vertices / points of the `polygon` are
+    outside this coordinate space, only a part (or none at all) of the polygon's
+    pixels is returned. Shifting the polygon's vertices by an offset can be used
+    to move the polygon around and potentially draw an arbitrary sub-region of
+    the polygon.
+
+    >>> offset = (2, -4)
+    >>> rr, cc = ski.draw.polygon(r - offset[0], c - offset[1], shape=img.shape)
+    >>> img = np.zeros((10, 10), dtype=int)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+    """
+    return _polygon(r, c, shape)
+
+
+def circle_perimeter(r, c, radius, method='bresenham', shape=None):
+    """Generate circle perimeter coordinates.
+
+    Parameters
+    ----------
+    r, c : int
+        Centre coordinate of circle.
+    radius : int
+        Radius of circle.
+    method : {'bresenham', 'andres'}, optional
+        bresenham : Bresenham method (default)
+        andres : Andres method
+    shape : tuple, optional
+        Image shape which is used to determine the maximum extent of output
+        pixel coordinates. This is useful for circles that exceed the image
+        size. If None, the full extent of the circle is used.  Must be at least
+        length 2. Only the first two values are used to determine the extent of
+        the input image.
+
+    Returns
+    -------
+    rr, cc : (N,) ndarray of int
+        Bresenham and Andres' method:
+        Indices of pixels that belong to the circle perimeter.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Notes
+    -----
+    Andres method presents the advantage that concentric
+    circles create a disc whereas Bresenham can make holes. There
+    is also less distortions when Andres circles are rotated.
+    Bresenham method is also known as midpoint circle algorithm.
+    Anti-aliased circle generator is available with `circle_perimeter_aa`.
+
+    References
+    ----------
+    .. [1] J.E. Bresenham, "Algorithm for computer control of a digital
+           plotter", IBM Systems journal, 4 (1965) 25-30.
+    .. [2] E. Andres, "Discrete circles, rings and spheres", Computers &
+           Graphics, 18 (1994) 695-706.
+
+    Examples
+    --------
+    >>> from skimage.draw import circle_perimeter
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = circle_perimeter(4, 4, 3)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+           [0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+           [0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    """
+    return _circle_perimeter(r, c, radius, method, shape)
+
+
+def circle_perimeter_aa(r, c, radius, shape=None):
+    """Generate anti-aliased circle perimeter coordinates.
+
+    Parameters
+    ----------
+    r, c : int
+        Centre coordinate of circle.
+    radius : int
+        Radius of circle.
+    shape : tuple, optional
+        Image shape which is used to determine the maximum extent of output
+        pixel coordinates. This is useful for circles that exceed the image
+        size. If None, the full extent of the circle is used.  Must be at least
+        length 2. Only the first two values are used to determine the extent of
+        the input image.
+
+    Returns
+    -------
+    rr, cc, val : (N,) ndarray (int, int, float)
+        Indices of pixels (`rr`, `cc`) and intensity values (`val`).
+        ``img[rr, cc] = val``.
+
+    Notes
+    -----
+    Wu's method draws anti-aliased circle. This implementation doesn't use
+    lookup table optimization.
+
+    Use the function ``draw.set_color`` to apply ``circle_perimeter_aa``
+    results to color images.
+
+    References
+    ----------
+    .. [1] X. Wu, "An efficient antialiasing technique", In ACM SIGGRAPH
+           Computer Graphics, 25 (1991) 143-152.
+
+    Examples
+    --------
+    >>> from skimage.draw import circle_perimeter_aa
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc, val = circle_perimeter_aa(4, 4, 3)
+    >>> img[rr, cc] = val * 255
+    >>> img
+    array([[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0],
+           [  0,   0,  60, 211, 255, 211,  60,   0,   0,   0],
+           [  0,  60, 194,  43,   0,  43, 194,  60,   0,   0],
+           [  0, 211,  43,   0,   0,   0,  43, 211,   0,   0],
+           [  0, 255,   0,   0,   0,   0,   0, 255,   0,   0],
+           [  0, 211,  43,   0,   0,   0,  43, 211,   0,   0],
+           [  0,  60, 194,  43,   0,  43, 194,  60,   0,   0],
+           [  0,   0,  60, 211, 255, 211,  60,   0,   0,   0],
+           [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0],
+           [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0]], dtype=uint8)
+
+    >>> from skimage import data, draw
+    >>> image = data.chelsea()
+    >>> rr, cc, val = draw.circle_perimeter_aa(r=100, c=100, radius=75)
+    >>> draw.set_color(image, (rr, cc), [1, 0, 0], alpha=val)
+    """
+    return _circle_perimeter_aa(r, c, radius, shape)
+
+
+def ellipse_perimeter(r, c, r_radius, c_radius, orientation=0, shape=None):
+    """Generate ellipse perimeter coordinates.
+
+    Parameters
+    ----------
+    r, c : int
+        Centre coordinate of ellipse.
+    r_radius, c_radius : int
+        Minor and major semi-axes. ``(r/r_radius)**2 + (c/c_radius)**2 = 1``.
+    orientation : double, optional
+        Major axis orientation in clockwise direction as radians.
+    shape : tuple, optional
+        Image shape which is used to determine the maximum extent of output
+        pixel coordinates. This is useful for ellipses that exceed the image
+        size. If None, the full extent of the ellipse is used.  Must be at
+        least length 2. Only the first two values are used to determine the
+        extent of the input image.
+
+    Returns
+    -------
+    rr, cc : (N,) ndarray of int
+        Indices of pixels that belong to the ellipse perimeter.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    References
+    ----------
+    .. [1] A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012
+           http://members.chello.at/easyfilter/Bresenham.pdf
+
+    Examples
+    --------
+    >>> from skimage.draw import ellipse_perimeter
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = ellipse_perimeter(5, 5, 3, 4)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
+           [0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+
+
+    Note that the positions of `ellipse` without specified `shape` can have
+    also, negative values, as this is correct on the plane. On the other hand
+    using these ellipse positions for an image afterwards may lead to appearing
+    on the other side of image, because ``image[-1, -1] = image[end-1, end-1]``
+
+    >>> rr, cc = ellipse_perimeter(2, 3, 4, 5)
+    >>> img = np.zeros((9, 12), dtype=np.uint8)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
+           [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+           [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
+           [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
+           [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]], dtype=uint8)
+    """
+    return _ellipse_perimeter(r, c, r_radius, c_radius, orientation, shape)
+
+
+def bezier_curve(r0, c0, r1, c1, r2, c2, weight, shape=None):
+    """Generate Bezier curve coordinates.
+
+    Parameters
+    ----------
+    r0, c0 : int
+        Coordinates of the first control point.
+    r1, c1 : int
+        Coordinates of the middle control point.
+    r2, c2 : int
+        Coordinates of the last control point.
+    weight : double
+        Middle control point weight, it describes the line tension.
+    shape : tuple, optional
+        Image shape which is used to determine the maximum extent of output
+        pixel coordinates. This is useful for curves that exceed the image
+        size. If None, the full extent of the curve is used.
+
+    Returns
+    -------
+    rr, cc : (N,) ndarray of int
+        Indices of pixels that belong to the Bezier curve.
+        May be used to directly index into an array, e.g.
+        ``img[rr, cc] = 1``.
+
+    Notes
+    -----
+    The algorithm is the rational quadratic algorithm presented in
+    reference [1]_.
+
+    References
+    ----------
+    .. [1] A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012
+           http://members.chello.at/easyfilter/Bresenham.pdf
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.draw import bezier_curve
+    >>> img = np.zeros((10, 10), dtype=np.uint8)
+    >>> rr, cc = bezier_curve(1, 5, 5, -2, 8, 8, 2)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+           [0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
+           [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    """
+    return _bezier_curve(r0, c0, r1, c1, r2, c2, weight, shape)
+
+
+def rectangle(start, end=None, extent=None, shape=None):
+    """Generate coordinates of pixels within a rectangle.
+
+    Parameters
+    ----------
+    start : tuple
+        Origin point of the rectangle, e.g., ``([plane,] row, column)``.
+    end : tuple
+        End point of the rectangle ``([plane,] row, column)``.
+        For a 2D matrix, the slice defined by the rectangle is
+        ``[start:(end+1)]``.
+        Either `end` or `extent` must be specified.
+    extent : tuple
+        The extent (size) of the drawn rectangle.  E.g.,
+        ``([num_planes,] num_rows, num_cols)``.
+        Either `end` or `extent` must be specified.
+        A negative extent is valid, and will result in a rectangle
+        going along the opposite direction. If extent is negative, the
+        `start` point is not included.
+    shape : tuple, optional
+        Image shape used to determine the maximum bounds of the output
+        coordinates. This is useful for clipping rectangles that exceed
+        the image size. By default, no clipping is done.
+
+    Returns
+    -------
+    coords : array of int, shape (Ndim, Npoints)
+        The coordinates of all pixels in the rectangle.
+
+    Notes
+    -----
+    This function can be applied to N-dimensional images, by passing `start` and
+    `end` or `extent` as tuples of length N.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.draw import rectangle
+    >>> img = np.zeros((5, 5), dtype=np.uint8)
+    >>> start = (1, 1)
+    >>> extent = (3, 3)
+    >>> rr, cc = rectangle(start, extent=extent, shape=img.shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 0, 0, 0, 0]], dtype=uint8)
+
+
+    >>> img = np.zeros((5, 5), dtype=np.uint8)
+    >>> start = (0, 1)
+    >>> end = (3, 3)
+    >>> rr, cc = rectangle(start, end=end, shape=img.shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 1, 1, 1, 0],
+           [0, 0, 0, 0, 0]], dtype=uint8)
+
+    >>> import numpy as np
+    >>> from skimage.draw import rectangle
+    >>> img = np.zeros((6, 6), dtype=np.uint8)
+    >>> start = (3, 3)
+    >>>
+    >>> rr, cc = rectangle(start, extent=(2, 2))
+    >>> img[rr, cc] = 1
+    >>> rr, cc = rectangle(start, extent=(-2, 2))
+    >>> img[rr, cc] = 2
+    >>> rr, cc = rectangle(start, extent=(-2, -2))
+    >>> img[rr, cc] = 3
+    >>> rr, cc = rectangle(start, extent=(2, -2))
+    >>> img[rr, cc] = 4
+    >>> print(img)
+    [[0 0 0 0 0 0]
+     [0 3 3 2 2 0]
+     [0 3 3 2 2 0]
+     [0 4 4 1 1 0]
+     [0 4 4 1 1 0]
+     [0 0 0 0 0 0]]
+
+    """
+    tl, br = _rectangle_slice(start=start, end=end, extent=extent)
+
+    if shape is not None:
+        n_dim = len(start)
+        br = np.minimum(shape[0:n_dim], br)
+        tl = np.maximum(np.zeros_like(shape[0:n_dim]), tl)
+    coords = np.meshgrid(*[np.arange(st, en) for st, en in zip(tuple(tl), tuple(br))])
+    return coords
+
+
+@require("matplotlib", ">=3.3")
+def rectangle_perimeter(start, end=None, extent=None, shape=None, clip=False):
+    """Generate coordinates of pixels that are exactly around a rectangle.
+
+    Parameters
+    ----------
+    start : tuple
+        Origin point of the inner rectangle, e.g., ``(row, column)``.
+    end : tuple
+        End point of the inner rectangle ``(row, column)``.
+        For a 2D matrix, the slice defined by inner the rectangle is
+        ``[start:(end+1)]``.
+        Either `end` or `extent` must be specified.
+    extent : tuple
+        The extent (size) of the inner rectangle.  E.g.,
+        ``(num_rows, num_cols)``.
+        Either `end` or `extent` must be specified.
+        Negative extents are permitted. See `rectangle` to better
+        understand how they behave.
+    shape : tuple, optional
+        Image shape used to determine the maximum bounds of the output
+        coordinates. This is useful for clipping perimeters that exceed
+        the image size. By default, no clipping is done.  Must be at least
+        length 2. Only the first two values are used to determine the extent of
+        the input image.
+    clip : bool, optional
+        Whether to clip the perimeter to the provided shape. If this is set
+        to True, the drawn figure will always be a closed polygon with all
+        edges visible.
+
+    Returns
+    -------
+    coords : array of int, shape (2, Npoints)
+        The coordinates of all pixels in the rectangle.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.draw import rectangle_perimeter
+    >>> img = np.zeros((5, 6), dtype=np.uint8)
+    >>> start = (2, 3)
+    >>> end = (3, 4)
+    >>> rr, cc = rectangle_perimeter(start, end=end, shape=img.shape)
+    >>> img[rr, cc] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 1],
+           [0, 0, 1, 0, 0, 1],
+           [0, 0, 1, 0, 0, 1],
+           [0, 0, 1, 1, 1, 1]], dtype=uint8)
+
+    >>> img = np.zeros((5, 5), dtype=np.uint8)
+    >>> r, c = rectangle_perimeter(start, (10, 10), shape=img.shape, clip=True)
+    >>> img[r, c] = 1
+    >>> img
+    array([[0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1],
+           [0, 0, 1, 0, 1],
+           [0, 0, 1, 0, 1],
+           [0, 0, 1, 1, 1]], dtype=uint8)
+
+    """
+    top_left, bottom_right = _rectangle_slice(start=start, end=end, extent=extent)
+
+    top_left -= 1
+    r = [top_left[0], top_left[0], bottom_right[0], bottom_right[0], top_left[0]]
+    c = [top_left[1], bottom_right[1], bottom_right[1], top_left[1], top_left[1]]
+    return polygon_perimeter(r, c, shape=shape, clip=clip)
+
+
+def _rectangle_slice(start, end=None, extent=None):
+    """Return the slice ``(top_left, bottom_right)`` of the rectangle.
+
+    Returns
+    -------
+    (top_left, bottom_right)
+        The slice you would need to select the region in the rectangle defined
+        by the parameters.
+        Select it like:
+
+        ``rect[top_left[0]:bottom_right[0], top_left[1]:bottom_right[1]]``
+    """
+    if end is None and extent is None:
+        raise ValueError("Either `end` or `extent` must be given.")
+    if end is not None and extent is not None:
+        raise ValueError("Cannot provide both `end` and `extent`.")
+
+    if extent is not None:
+        end = np.asarray(start) + np.asarray(extent)
+    top_left = np.minimum(start, end)
+    bottom_right = np.maximum(start, end)
+
+    top_left = np.round(top_left).astype(int)
+    bottom_right = np.round(bottom_right).astype(int)
+
+    if extent is None:
+        bottom_right += 1
+
+    return (top_left, bottom_right)

envs/kitoverlay/skimage/draw/draw3d.py

@@ -0,0 +1,107 @@
+import numpy as np
+from scipy.special import elliprg
+
+
+def ellipsoid(a, b, c, spacing=(1.0, 1.0, 1.0), levelset=False):
+    """Generate ellipsoid for given semi-axis lengths.
+
+    The respective semi-axis lengths are given along three dimensions in
+    Cartesian coordinates. Each dimension may use a different grid spacing.
+
+    Parameters
+    ----------
+    a : float
+        Length of semi-axis along x-axis.
+    b : float
+        Length of semi-axis along y-axis.
+    c : float
+        Length of semi-axis along z-axis.
+    spacing : 3-tuple of floats
+        Grid spacing in three spatial dimensions.
+    levelset : bool
+        If True, returns the level set for this ellipsoid (signed level
+        set about zero, with positive denoting interior) as np.float64.
+        False returns a binarized version of said level set.
+
+    Returns
+    -------
+    ellipsoid : (M, N, P) array
+        Ellipsoid centered in a correctly sized array for given `spacing`.
+        Boolean dtype unless `levelset=True`, in which case a float array is
+        returned with the level set above 0.0 representing the ellipsoid.
+
+    """
+    if (a <= 0) or (b <= 0) or (c <= 0):
+        raise ValueError('Parameters a, b, and c must all be > 0')
+
+    offset = np.r_[1, 1, 1] * np.r_[spacing]
+
+    # Calculate limits, and ensure output volume is odd & symmetric
+    low = np.ceil(-np.r_[a, b, c] - offset)
+    high = np.floor(np.r_[a, b, c] + offset + 1)
+
+    for dim in range(3):
+        if (high[dim] - low[dim]) % 2 == 0:
+            low[dim] -= 1
+        num = np.arange(low[dim], high[dim], spacing[dim])
+        if 0 not in num:
+            low[dim] -= np.max(num[num < 0])
+
+    # Generate (anisotropic) spatial grid
+    x, y, z = np.mgrid[
+        low[0] : high[0] : spacing[0],
+        low[1] : high[1] : spacing[1],
+        low[2] : high[2] : spacing[2],
+    ]
+
+    if not levelset:
+        arr = ((x / float(a)) ** 2 + (y / float(b)) ** 2 + (z / float(c)) ** 2) <= 1
+    else:
+        arr = ((x / float(a)) ** 2 + (y / float(b)) ** 2 + (z / float(c)) ** 2) - 1
+
+    return arr
+
+
+def ellipsoid_stats(a, b, c):
+    """Calculate analytical volume and surface area of an ellipsoid.
+
+    The surface area of an ellipsoid is given by
+
+    .. math:: S=4\\pi b c R_G\\!\\left(1, \\frac{a^2}{b^2}, \\frac{a^2}{c^2}\\right)
+
+    where :math:`R_G` is Carlson's completely symmetric elliptic integral of
+    the second kind [1]_. The latter is implemented as
+    :py:func:`scipy.special.elliprg`.
+
+    Parameters
+    ----------
+    a : float
+        Length of semi-axis along x-axis.
+    b : float
+        Length of semi-axis along y-axis.
+    c : float
+        Length of semi-axis along z-axis.
+
+    Returns
+    -------
+    vol : float
+        Calculated volume of ellipsoid.
+    surf : float
+        Calculated surface area of ellipsoid.
+
+    References
+    ----------
+    .. [1] Paul Masson (2020). Surface Area of an Ellipsoid.
+           https://analyticphysics.com/Mathematical%20Methods/Surface%20Area%20of%20an%20Ellipsoid.htm
+
+    """
+    if (a <= 0) or (b <= 0) or (c <= 0):
+        raise ValueError('Parameters a, b, and c must all be > 0')
+
+    # Volume
+    vol = 4 / 3.0 * np.pi * a * b * c
+
+    # Surface area
+    surf = 3 * vol * elliprg(1 / a**2, 1 / b**2, 1 / c**2)
+
+    return vol, surf

envs/kitoverlay/skimage/draw/draw_nd.py

@@ -0,0 +1,108 @@
+import numpy as np
+
+
+def _round_safe(coords):
+    """Round coords while ensuring successive values are less than 1 apart.
+
+    When rounding coordinates for `line_nd`, we want coordinates that are less
+    than 1 apart (always the case, by design) to remain less than one apart.
+    However, NumPy rounds values to the nearest *even* integer, so:
+
+    >>> np.round([0.5, 1.5, 2.5, 3.5, 4.5])
+    array([0., 2., 2., 4., 4.])
+
+    So, for our application, we detect whether the above case occurs, and use
+    ``np.floor`` if so. It is sufficient to detect that the first coordinate
+    falls on 0.5 and that the second coordinate is 1.0 apart, since we assume
+    by construction that the inter-point distance is less than or equal to 1
+    and that all successive points are equidistant.
+
+    Parameters
+    ----------
+    coords : 1D array of float
+        The coordinates array. We assume that all successive values are
+        equidistant (``np.all(np.diff(coords) = coords[1] - coords[0])``)
+        and that this distance is no more than 1
+        (``np.abs(coords[1] - coords[0]) <= 1``).
+
+    Returns
+    -------
+    rounded : 1D array of int
+        The array correctly rounded for an indexing operation, such that no
+        successive indices will be more than 1 apart.
+
+    Examples
+    --------
+    >>> coords0 = np.array([0.5, 1.25, 2., 2.75, 3.5])
+    >>> _round_safe(coords0)
+    array([0, 1, 2, 3, 4])
+    >>> coords1 = np.arange(0.5, 8, 1)
+    >>> coords1
+    array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5])
+    >>> _round_safe(coords1)
+    array([0, 1, 2, 3, 4, 5, 6, 7])
+    """
+    if len(coords) > 1 and coords[0] % 1 == 0.5 and coords[1] - coords[0] == 1:
+        _round_function = np.floor
+    else:
+        _round_function = np.round
+    return _round_function(coords).astype(int)
+
+
+def line_nd(start, stop, *, endpoint=False, integer=True):
+    """Draw a single-pixel thick line in n dimensions.
+
+    The line produced will be ndim-connected. That is, two subsequent
+    pixels in the line will be either direct or diagonal neighbors in
+    n dimensions.
+
+    Parameters
+    ----------
+    start : array-like, shape (N,)
+        The start coordinates of the line.
+    stop : array-like, shape (N,)
+        The end coordinates of the line.
+    endpoint : bool, optional
+        Whether to include the endpoint in the returned line. Defaults
+        to False, which allows for easy drawing of multi-point paths.
+    integer : bool, optional
+        Whether to round the coordinates to integer. If True (default),
+        the returned coordinates can be used to directly index into an
+        array. `False` could be used for e.g. vector drawing.
+
+    Returns
+    -------
+    coords : tuple of arrays
+        The coordinates of points on the line.
+
+    Examples
+    --------
+    >>> lin = line_nd((1, 1), (5, 2.5), endpoint=False)
+    >>> lin
+    (array([1, 2, 3, 4]), array([1, 1, 2, 2]))
+    >>> im = np.zeros((6, 5), dtype=int)
+    >>> im[lin] = 1
+    >>> im
+    array([[0, 0, 0, 0, 0],
+           [0, 1, 0, 0, 0],
+           [0, 1, 0, 0, 0],
+           [0, 0, 1, 0, 0],
+           [0, 0, 1, 0, 0],
+           [0, 0, 0, 0, 0]])
+    >>> line_nd([2, 1, 1], [5, 5, 2.5], endpoint=True)
+    (array([2, 3, 4, 4, 5]), array([1, 2, 3, 4, 5]), array([1, 1, 2, 2, 2]))
+    """
+    start = np.asarray(start)
+    stop = np.asarray(stop)
+    npoints = int(np.ceil(np.max(np.abs(stop - start))))
+    if endpoint:
+        npoints += 1
+
+    coords = np.linspace(start, stop, num=npoints, endpoint=endpoint).T
+    if integer:
+        for dim in range(len(start)):
+            coords[dim, :] = _round_safe(coords[dim, :])
+
+        coords = coords.astype(int)
+
+    return tuple(coords)

envs/kitoverlay/skimage/io/__init__.py

@@ -0,0 +1,43 @@
+"""Reading and saving of images and videos."""
+
+import warnings
+
+from .manage_plugins import *
+from .manage_plugins import _hide_plugin_deprecation_warnings
+from .sift import *
+from .collection import *
+
+from ._io import *
+from ._image_stack import *
+
+
+with _hide_plugin_deprecation_warnings():
+    reset_plugins()
+
+
+__all__ = [
+    "concatenate_images",
+    "imread",
+    "imread_collection",
+    "imread_collection_wrapper",
+    "imsave",
+    "load_sift",
+    "load_surf",
+    "pop",
+    "push",
+    "ImageCollection",
+    "MultiImage",
+]
+
+
+def __getattr__(name):
+    if name == "available_plugins":
+        warnings.warn(
+            "`available_plugins` is deprecated since version 0.25 and will "
+            "be removed in version 0.27. Instead, use `imageio` or other "
+            "I/O packages directly.",
+            category=FutureWarning,
+            stacklevel=2,
+        )
+        return globals()["_available_plugins"]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

envs/kitoverlay/skimage/io/_image_stack.py

@@ -0,0 +1,35 @@
+import numpy as np
+
+
+__all__ = ['image_stack', 'push', 'pop']
+
+
+# Shared image queue
+image_stack = []
+
+
+def push(img):
+    """Push an image onto the shared image stack.
+
+    Parameters
+    ----------
+    img : ndarray
+        Image to push.
+
+    """
+    if not isinstance(img, np.ndarray):
+        raise ValueError("Can only push ndarrays to the image stack.")
+
+    image_stack.append(img)
+
+
+def pop():
+    """Pop an image from the shared image stack.
+
+    Returns
+    -------
+    img : ndarray
+        Image popped from the stack.
+
+    """
+    return image_stack.pop()

envs/kitoverlay/skimage/io/_io.py

@@ -0,0 +1,286 @@
+import pathlib
+import warnings
+
+import numpy as np
+
+from .._shared.utils import warn, deprecate_func, deprecate_parameter, DEPRECATED
+from .._shared.version_requirements import require
+from ..exposure import is_low_contrast
+from ..color.colorconv import rgb2gray, rgba2rgb
+from ..io.manage_plugins import call_plugin, _hide_plugin_deprecation_warnings
+from .util import file_or_url_context
+
+__all__ = [
+    'imread',
+    'imsave',
+    'imshow',
+    'show',
+    'imread_collection',
+    'imshow_collection',
+]
+
+
+_remove_plugin_param_template = (
+    "The plugin infrastructure in `skimage.io` and the parameter "
+    "`{deprecated_name}` are deprecated since version {deprecated_version} and "
+    "will be removed in {changed_version} (or later). To avoid this warning, "
+    "please do not use the parameter `{deprecated_name}`. Instead, use `imageio` "
+    "or other I/O packages directly. See also `{func_name}`."
+)
+
+
+@deprecate_parameter(
+    "plugin",
+    start_version="0.25",
+    stop_version="0.27",
+    template=_remove_plugin_param_template,
+)
+def imread(fname, as_gray=False, plugin=DEPRECATED, **plugin_args):
+    """Load an image from file.
+
+    Parameters
+    ----------
+    fname : str or pathlib.Path
+        Image file name, e.g. ``test.jpg`` or URL.
+    as_gray : bool, optional
+        If True, convert color images to gray-scale (64-bit floats).
+        Images that are already in gray-scale format are not converted.
+
+    Other Parameters
+    ----------------
+    plugin_args : DEPRECATED
+        The plugin infrastructure is deprecated.
+
+    Returns
+    -------
+    img_array : ndarray
+        The different color bands/channels are stored in the
+        third dimension, such that a gray-image is MxN, an
+        RGB-image MxNx3 and an RGBA-image MxNx4.
+
+    """
+    if plugin is DEPRECATED:
+        plugin = None
+    if plugin_args:
+        msg = (
+            "The plugin infrastructure in `skimage.io` is deprecated since "
+            "version 0.25 and will be removed in 0.27 (or later). To avoid "
+            "this warning, please do not pass additional keyword arguments "
+            "for plugins (`**plugin_args`). Instead, use `imageio` or other "
+            "I/O packages directly. See also `skimage.io.imread`."
+        )
+        warnings.warn(msg, category=FutureWarning, stacklevel=3)
+
+    if isinstance(fname, pathlib.Path):
+        fname = str(fname.resolve())
+
+    if plugin is None and hasattr(fname, 'lower'):
+        if fname.lower().endswith(('.tiff', '.tif')):
+            plugin = 'tifffile'
+
+    with file_or_url_context(fname) as fname, _hide_plugin_deprecation_warnings():
+        img = call_plugin('imread', fname, plugin=plugin, **plugin_args)
+
+    if not hasattr(img, 'ndim'):
+        return img
+
+    if img.ndim > 2:
+        if img.shape[-1] not in (3, 4) and img.shape[-3] in (3, 4):
+            img = np.swapaxes(img, -1, -3)
+            img = np.swapaxes(img, -2, -3)
+
+        if as_gray:
+            if img.shape[2] == 4:
+                img = rgba2rgb(img)
+            img = rgb2gray(img)
+
+    return img
+
+
+@deprecate_parameter(
+    "plugin",
+    start_version="0.25",
+    stop_version="0.27",
+    template=_remove_plugin_param_template,
+)
+def imread_collection(
+    load_pattern, conserve_memory=True, plugin=DEPRECATED, **plugin_args
+):
+    """
+    Load a collection of images.
+
+    Parameters
+    ----------
+    load_pattern : str or list
+        List of objects to load. These are usually filenames, but may
+        vary depending on the currently active plugin. See :class:`ImageCollection`
+        for the default behaviour of this parameter.
+    conserve_memory : bool, optional
+        If True, never keep more than one in memory at a specific
+        time.  Otherwise, images will be cached once they are loaded.
+
+    Returns
+    -------
+    ic : :class:`ImageCollection`
+        Collection of images.
+
+    Other Parameters
+    ----------------
+    plugin_args : DEPRECATED
+        The plugin infrastructure is deprecated.
+
+    """
+    if plugin is DEPRECATED:
+        plugin = None
+    if plugin_args:
+        msg = (
+            "The plugin infrastructure in `skimage.io` is deprecated since "
+            "version 0.25 and will be removed in 0.27 (or later). To avoid "
+            "this warning, please do not pass additional keyword arguments "
+            "for plugins (`**plugin_args`). Instead, use `imageio` or other "
+            "I/O packages directly. See also `skimage.io.imread_collection`."
+        )
+        warnings.warn(msg, category=FutureWarning, stacklevel=3)
+    with _hide_plugin_deprecation_warnings():
+        return call_plugin(
+            'imread_collection',
+            load_pattern,
+            conserve_memory,
+            plugin=plugin,
+            **plugin_args,
+        )
+
+
+@deprecate_parameter(
+    "plugin",
+    start_version="0.25",
+    stop_version="0.27",
+    template=_remove_plugin_param_template,
+)
+def imsave(fname, arr, plugin=DEPRECATED, *, check_contrast=True, **plugin_args):
+    """Save an image to file.
+
+    Parameters
+    ----------
+    fname : str or pathlib.Path
+        Target filename.
+    arr : ndarray of shape (M,N) or (M,N,3) or (M,N,4)
+        Image data.
+    check_contrast : bool, optional
+        Check for low contrast and print warning (default: True).
+
+    Other Parameters
+    ----------------
+    plugin_args : DEPRECATED
+        The plugin infrastructure is deprecated.
+    """
+    if plugin is DEPRECATED:
+        plugin = None
+    if plugin_args:
+        msg = (
+            "The plugin infrastructure in `skimage.io` is deprecated since "
+            "version 0.25 and will be removed in 0.27 (or later). To avoid "
+            "this warning, please do not pass additional keyword arguments "
+            "for plugins (`**plugin_args`). Instead, use `imageio` or other "
+            "I/O packages directly. See also `skimage.io.imsave`."
+        )
+        warnings.warn(msg, category=FutureWarning, stacklevel=3)
+
+    if isinstance(fname, pathlib.Path):
+        fname = str(fname.resolve())
+    if plugin is None and hasattr(fname, 'lower'):
+        if fname.lower().endswith(('.tiff', '.tif')):
+            plugin = 'tifffile'
+    if arr.dtype == bool:
+        warn(
+            f'{fname} is a boolean image: setting True to 255 and False to 0. '
+            'To silence this warning, please convert the image using '
+            'img_as_ubyte.',
+            stacklevel=3,
+        )
+        arr = arr.astype('uint8') * 255
+    if check_contrast and is_low_contrast(arr):
+        warn(f'{fname} is a low contrast image')
+
+    with _hide_plugin_deprecation_warnings():
+        return call_plugin('imsave', fname, arr, plugin=plugin, **plugin_args)
+
+
+@deprecate_func(
+    deprecated_version="0.25",
+    removed_version="0.27",
+    hint="Please use `matplotlib`, `napari`, etc. to visualize images.",
+)
+def imshow(arr, plugin=None, **plugin_args):
+    """Display an image.
+
+    Parameters
+    ----------
+    arr : ndarray or str
+        Image data or name of image file.
+    plugin : str
+        Name of plugin to use.  By default, the different plugins are
+        tried (starting with imageio) until a suitable candidate is found.
+
+    Other Parameters
+    ----------------
+    plugin_args : keywords
+        Passed to the given plugin.
+
+    """
+    if isinstance(arr, str):
+        arr = call_plugin('imread', arr, plugin=plugin)
+    with _hide_plugin_deprecation_warnings():
+        return call_plugin('imshow', arr, plugin=plugin, **plugin_args)
+
+
+@deprecate_func(
+    deprecated_version="0.25",
+    removed_version="0.27",
+    hint="Please use `matplotlib`, `napari`, etc. to visualize images.",
+)
+def imshow_collection(ic, plugin=None, **plugin_args):
+    """Display a collection of images.
+
+    Parameters
+    ----------
+    ic : :class:`ImageCollection`
+        Collection to display.
+
+    Other Parameters
+    ----------------
+    plugin_args : keywords
+        Passed to the given plugin.
+
+    """
+    with _hide_plugin_deprecation_warnings():
+        return call_plugin('imshow_collection', ic, plugin=plugin, **plugin_args)
+
+
+@require("matplotlib", ">=3.3")
+@deprecate_func(
+    deprecated_version="0.25",
+    removed_version="0.27",
+    hint="Please use `matplotlib`, `napari`, etc. to visualize images.",
+)
+def show():
+    """Display pending images.
+
+    Launch the event loop of the current GUI plugin, and display all
+    pending images, queued via `imshow`. This is required when using
+    `imshow` from non-interactive scripts.
+
+    A call to `show` will block execution of code until all windows
+    have been closed.
+
+    Examples
+    --------
+    >>> import skimage.io as io
+    >>> rng = np.random.default_rng()
+    >>> for i in range(4):
+    ...     ax_im = io.imshow(rng.random((50, 50)))  # doctest: +SKIP
+    >>> io.show() # doctest: +SKIP
+
+    """
+    with _hide_plugin_deprecation_warnings():
+        return call_plugin('_app_show')