update

.CondaPkg/env/Lib/site-packages/skimage/io/__init__.py

@@ -0,0 +1,65 @@
+"""Utilities to read and write images in various formats.
+
+The following plug-ins are available:
+
+"""
+
+from .manage_plugins import *
+from .sift import *
+from .collection import *
+
+from ._io import *
+from ._image_stack import *
+
+
+reset_plugins()
+
+WRAP_LEN = 73
+
+
+def _separator(char, lengths):
+    return [char * separator_length for separator_length in lengths]
+
+
+def _format_plugin_info_table(info_table, column_lengths):
+    """Add separators and column titles to plugin info table."""
+    info_table.insert(0, _separator('=', column_lengths))
+    info_table.insert(1, ('Plugin', 'Description'))
+    info_table.insert(2, _separator('-', column_lengths))
+    info_table.append(_separator('=', column_lengths))
+
+
+def _update_doc(doc):
+    """Add a list of plugins to the module docstring, formatted as
+    a ReStructuredText table.
+    """
+    from textwrap import wrap
+
+    info_table = [
+        (p, plugin_info(p).get('description', 'no description'))
+        for p in available_plugins
+        if not p == 'test'
+    ]
+
+    if len(info_table) > 0:
+        name_length = max([len(n) for (n, _) in info_table])
+    else:
+        name_length = 0
+
+    description_length = WRAP_LEN - 1 - name_length
+    column_lengths = [name_length, description_length]
+    _format_plugin_info_table(info_table, column_lengths)
+
+    for name, plugin_description in info_table:
+        description_lines = wrap(plugin_description, description_length)
+        name_column = [name]
+        name_column.extend(['' for _ in range(len(description_lines) - 1)])
+        for name, description in zip(name_column, description_lines):
+            doc += f"{name.ljust(name_length)} {description}\n"
+    doc = doc.strip()
+
+    return doc
+
+
+if __doc__ is not None:
+    __doc__ = _update_doc(__doc__)

.CondaPkg/env/Lib/site-packages/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()

.CondaPkg/env/Lib/site-packages/skimage/io/_io.py

@@ -0,0 +1,221 @@
+import pathlib
+
+import numpy as np
+
+from .._shared.utils import warn
+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
+from .util import file_or_url_context
+
+
+__all__ = [
+    'imread',
+    'imsave',
+    'imshow',
+    'show',
+    'imread_collection',
+    'imshow_collection',
+]
+
+
+def imread(fname, as_gray=False, plugin=None, **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.
+    plugin : str, optional
+        Name of plugin to use.  By default, the different plugins are
+        tried (starting with imageio) until a suitable
+        candidate is found.  If not given and fname is a tiff file, the
+        tifffile plugin will be used.
+
+    Other Parameters
+    ----------------
+    plugin_args : keywords
+        Passed to the given plugin.
+
+    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 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:
+        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
+
+
+def imread_collection(load_pattern, conserve_memory=True, plugin=None, **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 : keywords
+        Passed to the given plugin.
+
+    """
+    return call_plugin(
+        'imread_collection', load_pattern, conserve_memory, plugin=plugin, **plugin_args
+    )
+
+
+def imsave(fname, arr, plugin=None, 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.
+    plugin : str, optional
+        Name of plugin to use.  By default, the different plugins are
+        tried (starting with imageio) until a suitable
+        candidate is found.  If not given and fname is a tiff file, the
+        tifffile plugin will be used.
+    check_contrast : bool, optional
+        Check for low contrast and print warning (default: True).
+
+    Other Parameters
+    ----------------
+    plugin_args : keywords
+        Passed to the given plugin.
+
+    Notes
+    -----
+    When saving a JPEG, the compression ratio may be controlled using the
+    ``quality`` keyword argument which is an integer with values in [1, 100],
+    where 1 is worst quality and smallest file size, and 100 is the best quality
+    and largest file size (default 75). This is only available when using
+    the PIL and imageio plugins.
+    """
+    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=2,
+        )
+        arr = arr.astype('uint8') * 255
+    if check_contrast and is_low_contrast(arr):
+        warn(f'{fname} is a low contrast image')
+    return call_plugin('imsave', fname, arr, plugin=plugin, **plugin_args)
+
+
+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)
+    return call_plugin('imshow', arr, plugin=plugin, **plugin_args)
+
+
+def imshow_collection(ic, plugin=None, **plugin_args):
+    """Display a collection of images.
+
+    Parameters
+    ----------
+    ic : :class:`ImageCollection`
+        Collection to display.
+    plugin : str
+        Name of plugin to use.  By default, the different plugins are
+        tried until a suitable candidate is found.
+
+    Other Parameters
+    ----------------
+    plugin_args : keywords
+        Passed to the given plugin.
+
+    """
+    return call_plugin('imshow_collection', ic, plugin=plugin, **plugin_args)
+
+
+@require("matplotlib", ">=3.3")
+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
+    --------
+    .. testsetup::
+        >>> import pytest; _ = pytest.importorskip('matplotlib')
+
+    >>> import skimage.io as io
+    >>> rng = np.random.default_rng()
+    >>> for i in range(4):
+    ...     ax_im = io.imshow(rng.random((50, 50)))
+    >>> io.show() # doctest: +SKIP
+
+    """
+    return call_plugin('_app_show')

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/fits_plugin.ini

@@ -0,0 +1,3 @@
+[fits]
+description = FITS image reading via PyFITS
+provides = imread, imread_collection

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/fits_plugin.py

@@ -0,0 +1,135 @@
+__all__ = ['imread', 'imread_collection']
+
+import skimage.io as io
+
+try:
+    from astropy.io import fits
+except ImportError:
+    raise ImportError(
+        "Astropy could not be found. It is needed to read FITS files.\n"
+        "Please refer to https://www.astropy.org for installation\n"
+        "instructions."
+    )
+
+
+def imread(fname):
+    """Load an image from a FITS file.
+
+    Parameters
+    ----------
+    fname : string
+        Image file name, e.g. ``test.fits``.
+
+    Returns
+    -------
+    img_array : ndarray
+        Unlike plugins such as PIL, where different color bands/channels are
+        stored in the third dimension, FITS images are grayscale-only and can
+        be N-dimensional, so an array of the native FITS dimensionality is
+        returned, without color channels.
+
+        Currently if no image is found in the file, None will be returned
+
+    Notes
+    -----
+    Currently FITS ``imread()`` always returns the first image extension when
+    given a Multi-Extension FITS file; use ``imread_collection()`` (which does
+    lazy loading) to get all the extensions at once.
+
+    """
+
+    with fits.open(fname) as hdulist:
+        # Iterate over FITS image extensions, ignoring any other extension types
+        # such as binary tables, and get the first image data array:
+        img_array = None
+        for hdu in hdulist:
+            if isinstance(hdu, fits.ImageHDU) or isinstance(hdu, fits.PrimaryHDU):
+                if hdu.data is not None:
+                    img_array = hdu.data
+                    break
+
+    return img_array
+
+
+def imread_collection(load_pattern, conserve_memory=True):
+    """Load a collection of images from one or more FITS files
+
+    Parameters
+    ----------
+    load_pattern : str or list
+        List of extensions to load. Filename globbing is currently
+        unsupported.
+    conserve_memory : bool
+        If True, never keep more than one in memory at a specific
+        time. Otherwise, images will be cached once they are loaded.
+
+    Returns
+    -------
+    ic : ImageCollection
+        Collection of images.
+
+    """
+
+    intype = type(load_pattern)
+    if intype is not list and intype is not str:
+        raise TypeError("Input must be a filename or list of filenames")
+
+    # Ensure we have a list, otherwise we'll end up iterating over the string:
+    if intype is not list:
+        load_pattern = [load_pattern]
+
+    # Generate a list of filename/extension pairs by opening the list of
+    # files and finding the image extensions in each one:
+    ext_list = []
+    for filename in load_pattern:
+        with fits.open(filename) as hdulist:
+            for n, hdu in zip(range(len(hdulist)), hdulist):
+                if isinstance(hdu, fits.ImageHDU) or isinstance(hdu, fits.PrimaryHDU):
+                    # Ignore (primary) header units with no data (use '.size'
+                    # rather than '.data' to avoid actually loading the image):
+                    try:
+                        data_size = hdu.size  # size is int in Astropy 3.1.2
+                    except TypeError:
+                        data_size = hdu.size()
+                    if data_size > 0:
+                        ext_list.append((filename, n))
+
+    return io.ImageCollection(
+        ext_list, load_func=FITSFactory, conserve_memory=conserve_memory
+    )
+
+
+def FITSFactory(image_ext):
+    """Load an image extension from a FITS file and return a NumPy array
+
+    Parameters
+    ----------
+    image_ext : tuple
+        FITS extension to load, in the format ``(filename, ext_num)``.
+        The FITS ``(extname, extver)`` format is unsupported, since this
+        function is not called directly by the user and
+        ``imread_collection()`` does the work of figuring out which
+        extensions need loading.
+
+    """
+
+    # Expect a length-2 tuple with a filename as the first element:
+    if not isinstance(image_ext, tuple):
+        raise TypeError("Expected a tuple")
+
+    if len(image_ext) != 2:
+        raise ValueError("Expected a tuple of length 2")
+
+    filename = image_ext[0]
+    extnum = image_ext[1]
+
+    if not (isinstance(filename, str) and isinstance(extnum, int)):
+        raise ValueError("Expected a (filename, extension) tuple")
+
+    with fits.open(filename) as hdulist:
+        data = hdulist[extnum].data
+
+    if data is None:
+        raise RuntimeError(f"Extension {extnum} of {filename} has no data")
+
+    return data

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/gdal_plugin.ini

@@ -0,0 +1,3 @@
+[gdal]
+description = Image reading via the GDAL Library (www.gdal.org)
+provides = imread

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/gdal_plugin.py

@@ -0,0 +1,17 @@
+__all__ = ['imread']
+
+try:
+    import osgeo.gdal as gdal
+except ImportError:
+    raise ImportError(
+        "The GDAL Library could not be found. "
+        "Please refer to http://www.gdal.org/ "
+        "for further instructions."
+    )
+
+
+def imread(fname):
+    """Load an image from file."""
+    ds = gdal.Open(fname)
+
+    return ds.ReadAsArray()

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/imageio_plugin.ini

@@ -0,0 +1,3 @@
+[imageio]
+description = Image reading via the ImageIO Library
+provides = imread, imsave

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/imageio_plugin.py

@@ -0,0 +1,14 @@
+__all__ = ['imread', 'imsave']
+
+from functools import wraps
+import numpy as np
+
+from imageio.v3 import imread as imageio_imread, imwrite as imsave
+
+
+@wraps(imageio_imread)
+def imread(*args, **kwargs):
+    out = np.asarray(imageio_imread(*args, **kwargs))
+    if not out.flags['WRITEABLE']:
+        out = out.copy()
+    return out

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/imread_plugin.ini

@@ -0,0 +1,3 @@
+[imread]
+description = Image reading and writing via imread
+provides = imread, imsave

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/imread_plugin.py

@@ -0,0 +1,46 @@
+__all__ = ['imread', 'imsave']
+
+from ...util.dtype import _convert
+
+try:
+    import imread as _imread
+except ImportError:
+    raise ImportError(
+        "Imread could not be found"
+        "Please refer to http://pypi.python.org/pypi/imread/ "
+        "for further instructions."
+    )
+
+
+def imread(fname, dtype=None):
+    """Load an image from file.
+
+    Parameters
+    ----------
+    fname : str
+        Name of input file
+
+    """
+    im = _imread.imread(fname)
+    if dtype is not None:
+        im = _convert(im, dtype)
+    return im
+
+
+def imsave(fname, arr, format_str=None):
+    """Save an image to disk.
+
+    Parameters
+    ----------
+    fname : str
+        Name of destination file.
+    arr : ndarray of uint8 or uint16
+        Array (image) to save.
+    format_str : str,optional
+        Format to save as.
+
+    Notes
+    -----
+    Currently, only 8-bit precision is supported.
+    """
+    return _imread.imsave(fname, arr, formatstr=format_str)

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/matplotlib_plugin.ini

@@ -0,0 +1,3 @@
+[matplotlib]
+description = Display or save images using Matplotlib
+provides = imshow, imread, imshow_collection, _app_show

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/matplotlib_plugin.py

@@ -0,0 +1,220 @@
+from collections import namedtuple
+import numpy as np
+from ...util import dtype as dtypes
+from ...exposure import is_low_contrast
+from ..._shared.utils import warn
+from math import floor, ceil
+
+
+_default_colormap = 'gray'
+_nonstandard_colormap = 'viridis'
+_diverging_colormap = 'RdBu'
+
+
+ImageProperties = namedtuple(
+    'ImageProperties',
+    ['signed', 'out_of_range_float', 'low_data_range', 'unsupported_dtype'],
+)
+
+
+def _get_image_properties(image):
+    """Determine nonstandard properties of an input image.
+
+    Parameters
+    ----------
+    image : array
+        The input image.
+
+    Returns
+    -------
+    ip : ImageProperties named tuple
+        The properties of the image:
+
+        - signed: whether the image has negative values.
+        - out_of_range_float: if the image has floating point data
+          outside of [-1, 1].
+        - low_data_range: if the image is in the standard image
+          range (e.g. [0, 1] for a floating point image) but its
+          data range would be too small to display with standard
+          image ranges.
+        - unsupported_dtype: if the image data type is not a
+          standard skimage type, e.g. ``numpy.uint64``.
+    """
+    immin, immax = np.min(image), np.max(image)
+    imtype = image.dtype.type
+    try:
+        lo, hi = dtypes.dtype_range[imtype]
+    except KeyError:
+        lo, hi = immin, immax
+
+    signed = immin < 0
+    out_of_range_float = np.issubdtype(image.dtype, np.floating) and (
+        immin < lo or immax > hi
+    )
+    low_data_range = immin != immax and is_low_contrast(image)
+    unsupported_dtype = image.dtype not in dtypes._supported_types
+
+    return ImageProperties(
+        signed, out_of_range_float, low_data_range, unsupported_dtype
+    )
+
+
+def _raise_warnings(image_properties):
+    """Raise the appropriate warning for each nonstandard image type.
+
+    Parameters
+    ----------
+    image_properties : ImageProperties named tuple
+        The properties of the considered image.
+    """
+    ip = image_properties
+    if ip.unsupported_dtype:
+        warn(
+            "Non-standard image type; displaying image with " "stretched contrast.",
+            stacklevel=3,
+        )
+    if ip.low_data_range:
+        warn(
+            "Low image data range; displaying image with " "stretched contrast.",
+            stacklevel=3,
+        )
+    if ip.out_of_range_float:
+        warn(
+            "Float image out of standard range; displaying "
+            "image with stretched contrast.",
+            stacklevel=3,
+        )
+
+
+def _get_display_range(image):
+    """Return the display range for a given set of image properties.
+
+    Parameters
+    ----------
+    image : array
+        The input image.
+
+    Returns
+    -------
+    lo, hi : same type as immin, immax
+        The display range to be used for the input image.
+    cmap : string
+        The name of the colormap to use.
+    """
+    ip = _get_image_properties(image)
+    immin, immax = np.min(image), np.max(image)
+    if ip.signed:
+        magnitude = max(abs(immin), abs(immax))
+        lo, hi = -magnitude, magnitude
+        cmap = _diverging_colormap
+    elif any(ip):
+        _raise_warnings(ip)
+        lo, hi = immin, immax
+        cmap = _nonstandard_colormap
+    else:
+        lo = 0
+        imtype = image.dtype.type
+        hi = dtypes.dtype_range[imtype][1]
+        cmap = _default_colormap
+    return lo, hi, cmap
+
+
+def imshow(image, ax=None, show_cbar=None, **kwargs):
+    """Show the input image and return the current axes.
+
+    By default, the image is displayed in grayscale, rather than
+    the matplotlib default colormap.
+
+    Images are assumed to have standard range for their type. For
+    example, if a floating point image has values in [0, 0.5], the
+    most intense color will be gray50, not white.
+
+    If the image exceeds the standard range, or if the range is too
+    small to display, we fall back on displaying exactly the range of
+    the input image, along with a colorbar to clearly indicate that
+    this range transformation has occurred.
+
+    For signed images, we use a diverging colormap centered at 0.
+
+    Parameters
+    ----------
+    image : array, shape (M, N[, 3])
+        The image to display.
+    ax : `matplotlib.axes.Axes`, optional
+        The axis to use for the image, defaults to plt.gca().
+    show_cbar : boolean, optional.
+        Whether to show the colorbar (used to override default behavior).
+    **kwargs : Keyword arguments
+        These are passed directly to `matplotlib.pyplot.imshow`.
+
+    Returns
+    -------
+    ax_im : `matplotlib.pyplot.AxesImage`
+        The `AxesImage` object returned by `plt.imshow`.
+    """
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+    lo, hi, cmap = _get_display_range(image)
+
+    kwargs.setdefault('interpolation', 'nearest')
+    kwargs.setdefault('cmap', cmap)
+    kwargs.setdefault('vmin', lo)
+    kwargs.setdefault('vmax', hi)
+
+    ax = ax or plt.gca()
+    ax_im = ax.imshow(image, **kwargs)
+    if (cmap != _default_colormap and show_cbar is not False) or show_cbar:
+        divider = make_axes_locatable(ax)
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        plt.colorbar(ax_im, cax=cax)
+    ax.get_figure().tight_layout()
+
+    return ax_im
+
+
+def imshow_collection(ic, *args, **kwargs):
+    """Display all images in the collection.
+
+    Returns
+    -------
+    fig : `matplotlib.figure.Figure`
+        The `Figure` object returned by `plt.subplots`.
+    """
+    import matplotlib.pyplot as plt
+
+    if len(ic) < 1:
+        raise ValueError('Number of images to plot must be greater than 0')
+
+    # The target is to plot images on a grid with aspect ratio 4:3
+    num_images = len(ic)
+    # Two pairs of `nrows, ncols` are possible
+    k = (num_images * 12) ** 0.5
+    r1 = max(1, floor(k / 4))
+    r2 = ceil(k / 4)
+    c1 = ceil(num_images / r1)
+    c2 = ceil(num_images / r2)
+    # Select the one which is closer to 4:3
+    if abs(r1 / c1 - 0.75) < abs(r2 / c2 - 0.75):
+        nrows, ncols = r1, c1
+    else:
+        nrows, ncols = r2, c2
+
+    fig, axes = plt.subplots(nrows=nrows, ncols=ncols)
+    ax = np.asarray(axes).ravel()
+    for n, image in enumerate(ic):
+        ax[n].imshow(image, *args, **kwargs)
+    kwargs['ax'] = axes
+    return fig
+
+
+def imread(*args, **kwargs):
+    import matplotlib.image
+
+    return matplotlib.image.imread(*args, **kwargs)
+
+
+def _app_show():
+    from matplotlib.pyplot import show
+
+    show()

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/pil_plugin.ini

@@ -0,0 +1,3 @@
+[pil]
+description = Image reading via the Python Imaging Library
+provides = imread, imsave

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/pil_plugin.py

@@ -0,0 +1,261 @@
+__all__ = ['imread', 'imsave']
+
+import numpy as np
+from PIL import Image
+
+from ...util import img_as_ubyte, img_as_uint
+
+
+def imread(fname, dtype=None, img_num=None, **kwargs):
+    """Load an image from file.
+
+    Parameters
+    ----------
+    fname : str or file
+        File name or file-like-object.
+    dtype : numpy dtype object or string specifier
+        Specifies data type of array elements.
+    img_num : int, optional
+        Specifies which image to read in a file with multiple images
+        (zero-indexed).
+    kwargs : keyword pairs, optional
+        Addition keyword arguments to pass through.
+
+    Notes
+    -----
+    Files are read using the Python Imaging Library.
+    See PIL docs [1]_ for a list of supported formats.
+
+    References
+    ----------
+    .. [1] http://pillow.readthedocs.org/en/latest/handbook/image-file-formats.html
+    """
+    if isinstance(fname, str):
+        with open(fname, 'rb') as f:
+            im = Image.open(f)
+            return pil_to_ndarray(im, dtype=dtype, img_num=img_num)
+    else:
+        im = Image.open(fname)
+        return pil_to_ndarray(im, dtype=dtype, img_num=img_num)
+
+
+def pil_to_ndarray(image, dtype=None, img_num=None):
+    """Import a PIL Image object to an ndarray, in memory.
+
+    Parameters
+    ----------
+    Refer to ``imread``.
+
+    """
+    try:
+        # this will raise an IOError if the file is not readable
+        image.getdata()[0]
+    except OSError as e:
+        site = "http://pillow.readthedocs.org/en/latest/installation.html#external-libraries"
+        pillow_error_message = str(e)
+        error_message = (
+            f"Could not load '{image.filename}' \n"
+            f"Reason: '{pillow_error_message}'\n"
+            f"Please see documentation at: {site}"
+        )
+        raise ValueError(error_message)
+    frames = []
+    grayscale = None
+    i = 0
+    while 1:
+        try:
+            image.seek(i)
+        except EOFError:
+            break
+
+        frame = image
+
+        if img_num is not None and img_num != i:
+            image.getdata()[0]
+            i += 1
+            continue
+
+        if image.format == 'PNG' and image.mode == 'I' and dtype is None:
+            dtype = 'uint16'
+
+        if image.mode == 'P':
+            if grayscale is None:
+                grayscale = _palette_is_grayscale(image)
+
+            if grayscale:
+                frame = image.convert('L')
+            else:
+                if image.format == 'PNG' and 'transparency' in image.info:
+                    frame = image.convert('RGBA')
+                else:
+                    frame = image.convert('RGB')
+
+        elif image.mode == '1':
+            frame = image.convert('L')
+
+        elif 'A' in image.mode:
+            frame = image.convert('RGBA')
+
+        elif image.mode == 'CMYK':
+            frame = image.convert('RGB')
+
+        if image.mode.startswith('I;16'):
+            shape = image.size
+            dtype = '>u2' if image.mode.endswith('B') else '<u2'
+            if 'S' in image.mode:
+                dtype = dtype.replace('u', 'i')
+            frame = np.frombuffer(frame.tobytes(), dtype)
+            frame.shape = shape[::-1]
+
+        else:
+            frame = np.array(frame, dtype=dtype)
+
+        frames.append(frame)
+        i += 1
+
+        if img_num is not None:
+            break
+
+    if hasattr(image, 'fp') and image.fp:
+        image.fp.close()
+
+    if img_num is None and len(frames) > 1:
+        return np.array(frames)
+    elif frames:
+        return frames[0]
+    elif img_num:
+        raise IndexError(f'Could not find image  #{img_num}')
+
+
+def _palette_is_grayscale(pil_image):
+    """Return True if PIL image in palette mode is grayscale.
+
+    Parameters
+    ----------
+    pil_image : PIL image
+        PIL Image that is in Palette mode.
+
+    Returns
+    -------
+    is_grayscale : bool
+        True if all colors in image palette are gray.
+    """
+    if pil_image.mode != 'P':
+        raise ValueError('pil_image.mode must be equal to "P".')
+    # get palette as an array with R, G, B columns
+    # Starting in pillow 9.1 palettes may have less than 256 entries
+    palette = np.asarray(pil_image.getpalette()).reshape((-1, 3))
+    # Not all palette colors are used; unused colors have junk values.
+    start, stop = pil_image.getextrema()
+    valid_palette = palette[start : stop + 1]
+    # Image is grayscale if channel differences (R - G and G - B)
+    # are all zero.
+    return np.allclose(np.diff(valid_palette), 0)
+
+
+def ndarray_to_pil(arr, format_str=None):
+    """Export an ndarray to a PIL object.
+
+    Parameters
+    ----------
+    Refer to ``imsave``.
+
+    """
+    if arr.ndim == 3:
+        arr = img_as_ubyte(arr)
+        mode = {3: 'RGB', 4: 'RGBA'}[arr.shape[2]]
+
+    elif format_str in ['png', 'PNG']:
+        mode = 'I;16'
+        mode_base = 'I'
+
+        if arr.dtype.kind == 'f':
+            arr = img_as_uint(arr)
+
+        elif arr.max() < 256 and arr.min() >= 0:
+            arr = arr.astype(np.uint8)
+            mode = mode_base = 'L'
+
+        else:
+            arr = img_as_uint(arr)
+
+    else:
+        arr = img_as_ubyte(arr)
+        mode = 'L'
+        mode_base = 'L'
+
+    try:
+        array_buffer = arr.tobytes()
+    except AttributeError:
+        array_buffer = arr.tostring()  # Numpy < 1.9
+
+    if arr.ndim == 2:
+        im = Image.new(mode_base, arr.T.shape)
+        try:
+            im.frombytes(array_buffer, 'raw', mode)
+        except AttributeError:
+            im.fromstring(array_buffer, 'raw', mode)  # PIL 1.1.7
+    else:
+        image_shape = (arr.shape[1], arr.shape[0])
+        try:
+            im = Image.frombytes(mode, image_shape, array_buffer)
+        except AttributeError:
+            im = Image.fromstring(mode, image_shape, array_buffer)  # PIL 1.1.7
+    return im
+
+
+def imsave(fname, arr, format_str=None, **kwargs):
+    """Save an image to disk.
+
+    Parameters
+    ----------
+    fname : str or file-like object
+        Name of destination file.
+    arr : ndarray of uint8 or float
+        Array (image) to save.  Arrays of data-type uint8 should have
+        values in [0, 255], whereas floating-point arrays must be
+        in [0, 1].
+    format_str: str
+        Format to save as, this is defaulted to PNG if using a file-like
+        object; this will be derived from the extension if fname is a string
+    kwargs: dict
+        Keyword arguments to the Pillow save function (or tifffile save
+        function, for Tiff files). These are format dependent. For example,
+        Pillow's JPEG save function supports an integer ``quality`` argument
+        with values in [1, 95], while TIFFFile supports a ``compress``
+        integer argument with values in [0, 9].
+
+    Notes
+    -----
+    Use the Python Imaging Library.
+    See PIL docs [1]_ for a list of other supported formats.
+    All images besides single channel PNGs are converted using `img_as_uint8`.
+    Single Channel PNGs have the following behavior:
+    - Integer values in [0, 255] and Boolean types -> img_as_uint8
+    - Floating point and other integers -> img_as_uint16
+
+    References
+    ----------
+    .. [1] http://pillow.readthedocs.org/en/latest/handbook/image-file-formats.html
+    """
+    # default to PNG if file-like object
+    if not isinstance(fname, str) and format_str is None:
+        format_str = "PNG"
+    # Check for png in filename
+    if isinstance(fname, str) and fname.lower().endswith(".png"):
+        format_str = "PNG"
+
+    arr = np.asanyarray(arr)
+
+    if arr.dtype.kind == 'b':
+        arr = arr.astype(np.uint8)
+
+    if arr.ndim not in (2, 3):
+        raise ValueError(f"Invalid shape for image array: {arr.shape}")
+
+    if arr.ndim == 3:
+        if arr.shape[2] not in (3, 4):
+            raise ValueError("Invalid number of channels in image array.")
+
+    img = ndarray_to_pil(arr, format_str=format_str)
+    img.save(fname, format=format_str, **kwargs)

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/simpleitk_plugin.ini

@@ -0,0 +1,3 @@
+[simpleitk]
+description = Image reading and writing via SimpleITK
+provides = imread, imsave

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/simpleitk_plugin.py

@@ -0,0 +1,23 @@
+__all__ = ['imread', 'imsave']
+
+try:
+    import SimpleITK as sitk
+except ImportError:
+    raise ImportError(
+        "SimpleITK could not be found. "
+        "Please try "
+        "  easy_install SimpleITK "
+        "or refer to "
+        "  http://simpleitk.org/ "
+        "for further instructions."
+    )
+
+
+def imread(fname):
+    sitk_img = sitk.ReadImage(fname)
+    return sitk.GetArrayFromImage(sitk_img)
+
+
+def imsave(fname, arr):
+    sitk_img = sitk.GetImageFromArray(arr, isVector=True)
+    sitk.WriteImage(sitk_img, fname)

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/tifffile_plugin.ini

@@ -0,0 +1,3 @@
+[tifffile]
+description = Load and save TIFF and TIFF-based images using tifffile.py
+provides = imread, imsave

.CondaPkg/env/Lib/site-packages/skimage/io/_plugins/tifffile_plugin.py

@@ -0,0 +1,74 @@
+from tifffile import imread as tifffile_imread
+from tifffile import imwrite as tifffile_imwrite
+
+__all__ = ['imread', 'imsave']
+
+
+def imsave(fname, arr, **kwargs):
+    """Load a tiff image to file.
+
+    Parameters
+    ----------
+    fname : str or file
+        File name or file-like object.
+    arr : ndarray
+        The array to write.
+    kwargs : keyword pairs, optional
+        Additional keyword arguments to pass through (see ``tifffile``'s
+        ``imwrite`` function).
+
+    Notes
+    -----
+    Provided by the tifffile library [1]_, and supports many
+    advanced image types including multi-page and floating-point.
+
+    This implementation will set ``photometric='RGB'`` when writing if the first
+    or last axis of `arr` has length 3 or 4. To override this, explicitly
+    pass the ``photometric`` kwarg.
+
+    This implementation will set ``planarconfig='SEPARATE'`` when writing if the
+    first axis of arr has length 3 or 4. To override this, explicitly
+    specify the ``planarconfig`` kwarg.
+
+    References
+    ----------
+    .. [1] https://pypi.org/project/tifffile/
+
+    """
+    if arr.shape[0] in [3, 4]:
+        if 'planarconfig' not in kwargs:
+            kwargs['planarconfig'] = 'SEPARATE'
+        rgb = True
+    else:
+        rgb = arr.shape[-1] in [3, 4]
+    if rgb and 'photometric' not in kwargs:
+        kwargs['photometric'] = 'RGB'
+
+    return tifffile_imwrite(fname, arr, **kwargs)
+
+
+def imread(fname, **kwargs):
+    """Load a tiff image from file.
+
+    Parameters
+    ----------
+    fname : str or file
+        File name or file-like-object.
+    kwargs : keyword pairs, optional
+        Additional keyword arguments to pass through (see ``tifffile``'s
+        ``imread`` function).
+
+    Notes
+    -----
+    Provided by the tifffile library [1]_, and supports many
+    advanced image types including multi-page and floating point.
+
+    References
+    ----------
+    .. [1] https://pypi.org/project/tifffile/
+
+    """
+    if 'img_num' in kwargs:
+        kwargs['key'] = kwargs.pop('img_num')
+
+    return tifffile_imread(fname, **kwargs)

.CondaPkg/env/Lib/site-packages/skimage/io/collection.py

@@ -0,0 +1,493 @@
+"""Data structures to hold collections of images, with optional caching."""
+
+import os
+from glob import glob
+import re
+from collections.abc import Sequence
+from copy import copy
+
+import numpy as np
+from PIL import Image
+
+from tifffile import TiffFile
+
+
+__all__ = [
+    'MultiImage',
+    'ImageCollection',
+    'concatenate_images',
+    'imread_collection_wrapper',
+]
+
+
+def concatenate_images(ic):
+    """Concatenate all images in the image collection into an array.
+
+    Parameters
+    ----------
+    ic : an iterable of images
+        The images to be concatenated.
+
+    Returns
+    -------
+    array_cat : ndarray
+        An array having one more dimension than the images in `ic`.
+
+    See Also
+    --------
+    ImageCollection.concatenate
+    MultiImage.concatenate
+
+    Raises
+    ------
+    ValueError
+        If images in `ic` don't have identical shapes.
+
+    Notes
+    -----
+    ``concatenate_images`` receives any iterable object containing images,
+    including ImageCollection and MultiImage, and returns a NumPy array.
+    """
+    all_images = [image[np.newaxis, ...] for image in ic]
+    try:
+        array_cat = np.concatenate(all_images)
+    except ValueError:
+        raise ValueError('Image dimensions must agree.')
+    return array_cat
+
+
+def alphanumeric_key(s):
+    """Convert string to list of strings and ints that gives intuitive sorting.
+
+    Parameters
+    ----------
+    s : string
+
+    Returns
+    -------
+    k : a list of strings and ints
+
+    Examples
+    --------
+    >>> alphanumeric_key('z23a')
+    ['z', 23, 'a']
+    >>> filenames = ['f9.10.png', 'e10.png', 'f9.9.png', 'f10.10.png',
+    ...              'f10.9.png']
+    >>> sorted(filenames)
+    ['e10.png', 'f10.10.png', 'f10.9.png', 'f9.10.png', 'f9.9.png']
+    >>> sorted(filenames, key=alphanumeric_key)
+    ['e10.png', 'f9.9.png', 'f9.10.png', 'f10.9.png', 'f10.10.png']
+    """
+    k = [int(c) if c.isdigit() else c for c in re.split('([0-9]+)', s)]
+    return k
+
+
+def _is_multipattern(input_pattern):
+    """Helping function. Returns True if pattern contains a tuple, list, or a
+    string separated with os.pathsep."""
+    # Conditions to be accepted by ImageCollection:
+    has_str_ospathsep = isinstance(input_pattern, str) and os.pathsep in input_pattern
+    not_a_string = not isinstance(input_pattern, str)
+    has_iterable = isinstance(input_pattern, Sequence)
+    has_strings = all(isinstance(pat, str) for pat in input_pattern)
+
+    is_multipattern = has_str_ospathsep or (
+        not_a_string and has_iterable and has_strings
+    )
+    return is_multipattern
+
+
+class ImageCollection:
+    """Load and manage a collection of image files.
+
+    Parameters
+    ----------
+    load_pattern : str or list of str
+        Pattern string or list of strings to load. The filename path can be
+        absolute or relative.
+    conserve_memory : bool, optional
+        If True, :class:`skimage.io.ImageCollection` does not keep more than one in
+        memory at a specific time. Otherwise, images will be cached once they are loaded.
+
+    Other parameters
+    ----------------
+    load_func : callable
+        ``imread`` by default. See Notes below.
+    **load_func_kwargs : dict
+        Any other keyword arguments are passed to `load_func`.
+
+    Attributes
+    ----------
+    files : list of str
+        If a pattern string is given for `load_pattern`, this attribute
+        stores the expanded file list. Otherwise, this is equal to
+        `load_pattern`.
+
+    Notes
+    -----
+    Note that files are always returned in alphanumerical order. Also note that slicing
+    returns a new :class:`skimage.io.ImageCollection`, *not* a view into the data.
+
+    ImageCollection image loading can be customized through
+    `load_func`. For an ImageCollection ``ic``, ``ic[5]`` calls
+    ``load_func(load_pattern[5])`` to load that image.
+
+    For example, here is an ImageCollection that, for each video provided,
+    loads every second frame::
+
+      import imageio.v3 as iio3
+      import itertools
+
+      def vidread_step(f, step):
+          vid = iio3.imiter(f)
+          return list(itertools.islice(vid, None, None, step)
+
+      video_file = 'no_time_for_that_tiny.gif'
+      ic = ImageCollection(video_file, load_func=vidread_step, step=2)
+
+      ic  # is an ImageCollection object of length 1 because 1 video is provided
+
+      x = ic[0]
+      x[5]  # the 10th frame of the first video
+
+    Alternatively, if `load_func` is provided and `load_pattern` is a
+    sequence, an :class:`skimage.io.ImageCollection` of corresponding length will
+    be created, and the individual images will be loaded by calling `load_func` with the
+    matching element of the `load_pattern` as its first argument. In this
+    case, the elements of the sequence do not need to be names of existing
+    files (or strings at all). For example, to create an :class:`skimage.io.ImageCollection`
+    containing 500 images from a video::
+
+      class FrameReader:
+          def __init__ (self, f):
+              self.f = f
+          def __call__ (self, index):
+              return iio3.imread(self.f, index=index)
+
+      ic = ImageCollection(range(500), load_func=FrameReader('movie.mp4'))
+
+      ic  # is an ImageCollection object of length 500
+
+    Another use of `load_func` would be to convert all images to ``uint8``::
+
+      def imread_convert(f):
+          return imread(f).astype(np.uint8)
+
+      ic = ImageCollection('/tmp/*.png', load_func=imread_convert)
+
+    Examples
+    --------
+    >>> import imageio.v3 as iio3
+    >>> import skimage.io as io
+
+    # Where your images are located
+    >>> data_dir = os.path.join(os.path.dirname(__file__), '../data')
+
+    >>> coll = io.ImageCollection(data_dir + '/chess*.png')
+    >>> len(coll)
+    2
+    >>> coll[0].shape
+    (200, 200)
+
+    >>> image_col = io.ImageCollection([f'{data_dir}/*.png', '{data_dir}/*.jpg'])
+
+    >>> class MultiReader:
+    ...     def __init__ (self, f):
+    ...         self.f = f
+    ...     def __call__ (self, index):
+    ...         return iio3.imread(self.f, index=index)
+    ...
+    >>> filename = data_dir + '/no_time_for_that_tiny.gif'
+    >>> ic = io.ImageCollection(range(24), load_func=MultiReader(filename))
+    >>> len(image_col)
+    23
+    >>> isinstance(ic[0], np.ndarray)
+    True
+    """
+
+    def __init__(
+        self, load_pattern, conserve_memory=True, load_func=None, **load_func_kwargs
+    ):
+        """Load and manage a collection of images."""
+        self._files = []
+        if _is_multipattern(load_pattern):
+            if isinstance(load_pattern, str):
+                load_pattern = load_pattern.split(os.pathsep)
+            for pattern in load_pattern:
+                self._files.extend(glob(pattern))
+            self._files = sorted(self._files, key=alphanumeric_key)
+        elif isinstance(load_pattern, str):
+            self._files.extend(glob(load_pattern))
+            self._files = sorted(self._files, key=alphanumeric_key)
+        elif isinstance(load_pattern, Sequence) and load_func is not None:
+            self._files = list(load_pattern)
+        else:
+            raise TypeError('Invalid pattern as input.')
+
+        if load_func is None:
+            from ._io import imread
+
+            self.load_func = imread
+            self._numframes = self._find_images()
+        else:
+            self.load_func = load_func
+            self._numframes = len(self._files)
+            self._frame_index = None
+
+        if conserve_memory:
+            memory_slots = 1
+        else:
+            memory_slots = self._numframes
+
+        self._conserve_memory = conserve_memory
+        self._cached = None
+
+        self.load_func_kwargs = load_func_kwargs
+        self.data = np.empty(memory_slots, dtype=object)
+
+    @property
+    def files(self):
+        return self._files
+
+    @property
+    def conserve_memory(self):
+        return self._conserve_memory
+
+    def _find_images(self):
+        index = []
+        for fname in self._files:
+            if fname.lower().endswith(('.tiff', '.tif')):
+                with open(fname, 'rb') as f:
+                    img = TiffFile(f)
+                    index += [(fname, i) for i in range(len(img.pages))]
+            else:
+                try:
+                    im = Image.open(fname)
+                    im.seek(0)
+                except OSError:
+                    continue
+                i = 0
+                while True:
+                    try:
+                        im.seek(i)
+                    except EOFError:
+                        break
+                    index.append((fname, i))
+                    i += 1
+                if hasattr(im, 'fp') and im.fp:
+                    im.fp.close()
+        self._frame_index = index
+        return len(index)
+
+    def __getitem__(self, n):
+        """Return selected image(s) in the collection.
+
+        Loading is done on demand.
+
+        Parameters
+        ----------
+        n : int or slice
+            The image number to be returned, or a slice selecting the images
+            and ordering to be returned in a new ImageCollection.
+
+        Returns
+        -------
+        img : ndarray or :class:`skimage.io.ImageCollection`
+            The `n`-th image in the collection, or a new ImageCollection with
+            the selected images.
+        """
+        if hasattr(n, '__index__'):
+            n = n.__index__()
+
+        if not isinstance(n, (int, slice)):
+            raise TypeError('slicing must be with an int or slice object')
+
+        if isinstance(n, int):
+            n = self._check_imgnum(n)
+            idx = n % len(self.data)
+
+            if (self.conserve_memory and n != self._cached) or (self.data[idx] is None):
+                kwargs = self.load_func_kwargs
+                if self._frame_index:
+                    fname, img_num = self._frame_index[n]
+                    if img_num is not None:
+                        kwargs['img_num'] = img_num
+                    try:
+                        self.data[idx] = self.load_func(fname, **kwargs)
+                    # Account for functions that do not accept an img_num kwarg
+                    except TypeError as e:
+                        if "unexpected keyword argument 'img_num'" in str(e):
+                            del kwargs['img_num']
+                            self.data[idx] = self.load_func(fname, **kwargs)
+                        else:
+                            raise
+                else:
+                    self.data[idx] = self.load_func(self.files[n], **kwargs)
+                self._cached = n
+
+            return self.data[idx]
+        else:
+            # A slice object was provided, so create a new ImageCollection
+            # object. Any loaded image data in the original ImageCollection
+            # will be copied by reference to the new object.  Image data
+            # loaded after this creation is not linked.
+            fidx = range(self._numframes)[n]
+            new_ic = copy(self)
+
+            if self._frame_index:
+                new_ic._files = [self._frame_index[i][0] for i in fidx]
+                new_ic._frame_index = [self._frame_index[i] for i in fidx]
+            else:
+                new_ic._files = [self._files[i] for i in fidx]
+
+            new_ic._numframes = len(fidx)
+
+            if self.conserve_memory:
+                if self._cached in fidx:
+                    new_ic._cached = fidx.index(self._cached)
+                    new_ic.data = np.copy(self.data)
+                else:
+                    new_ic.data = np.empty(1, dtype=object)
+            else:
+                new_ic.data = self.data[fidx]
+            return new_ic
+
+    def _check_imgnum(self, n):
+        """Check that the given image number is valid."""
+        num = self._numframes
+        if -num <= n < num:
+            n = n % num
+        else:
+            raise IndexError(f"There are only {num} images in the collection")
+        return n
+
+    def __iter__(self):
+        """Iterate over the images."""
+        for i in range(len(self)):
+            yield self[i]
+
+    def __len__(self):
+        """Number of images in collection."""
+        return self._numframes
+
+    def __str__(self):
+        return str(self.files)
+
+    def reload(self, n=None):
+        """Clear the image cache.
+
+        Parameters
+        ----------
+        n : None or int
+            Clear the cache for this image only. By default, the
+            entire cache is erased.
+
+        """
+        self.data = np.empty_like(self.data)
+
+    def concatenate(self):
+        """Concatenate all images in the collection into an array.
+
+        Returns
+        -------
+        ar : np.ndarray
+            An array having one more dimension than the images in `self`.
+
+        See Also
+        --------
+        skimage.io.concatenate_images
+
+        Raises
+        ------
+        ValueError
+            If images in the :class:`skimage.io.ImageCollection` do not have identical
+            shapes.
+        """
+        return concatenate_images(self)
+
+
+def imread_collection_wrapper(imread):
+    def imread_collection(load_pattern, conserve_memory=True):
+        """Return an `ImageCollection` from files matching the given pattern.
+
+        Note that files are always stored in alphabetical order. Also note that
+        slicing returns a new ImageCollection, *not* a view into the data.
+
+        See `skimage.io.ImageCollection` for details.
+
+        Parameters
+        ----------
+        load_pattern : str or list
+            Pattern glob or filenames to load. The path can be absolute or
+            relative.  Multiple patterns should be separated by a colon,
+            e.g. ``/tmp/work/*.png:/tmp/other/*.jpg``.  Also see
+            implementation notes below.
+        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.
+
+        """
+        return ImageCollection(
+            load_pattern, conserve_memory=conserve_memory, load_func=imread
+        )
+
+    return imread_collection
+
+
+class MultiImage(ImageCollection):
+    """A class containing all frames from multi-frame TIFF images.
+
+    Parameters
+    ----------
+    load_pattern : str or list of str
+        Pattern glob or filenames to load. The path can be absolute or
+        relative.
+    conserve_memory : bool, optional
+        Whether to conserve memory by only caching the frames of a single
+        image. Default is True.
+
+    Notes
+    -----
+    `MultiImage` returns a list of image-data arrays. In this
+    regard, it is very similar to `ImageCollection`, but the two differ in
+    their treatment of multi-frame images.
+
+    For a TIFF image containing N frames of size WxH, `MultiImage` stores
+    all frames of that image as a single element of shape `(N, W, H)` in the
+    list. `ImageCollection` instead creates N elements of shape `(W, H)`.
+
+    For an animated GIF image, `MultiImage` reads only the first frame, while
+    `ImageCollection` reads all frames by default.
+
+    Examples
+    --------
+    # Where your images are located
+    >>> data_dir = os.path.join(os.path.dirname(__file__), '../data')
+
+    >>> multipage_tiff = data_dir + '/multipage.tif'
+    >>> multi_img = MultiImage(multipage_tiff)
+    >>> len(multi_img)  # multi_img contains one element
+    1
+    >>> multi_img[0].shape  # this element is a two-frame image of shape:
+    (2, 15, 10)
+
+    >>> image_col = ImageCollection(multipage_tiff)
+    >>> len(image_col)  # image_col contains two elements
+    2
+    >>> for frame in image_col:
+    ...     print(frame.shape)  # each element is a frame of shape (15, 10)
+    ...
+    (15, 10)
+    (15, 10)
+    """
+
+    def __init__(self, filename, conserve_memory=True, dtype=None, **imread_kwargs):
+        """Load a multi-img."""
+        from ._io import imread
+
+        self._filename = filename
+        super().__init__(filename, conserve_memory, load_func=imread, **imread_kwargs)
+
+    @property
+    def filename(self):
+        return self._filename

.CondaPkg/env/Lib/site-packages/skimage/io/manage_plugins.py

@@ -0,0 +1,349 @@
+"""Handle image reading, writing and plotting plugins.
+
+To improve performance, plugins are only loaded as needed. As a result, there
+can be multiple states for a given plugin:
+
+    available: Defined in an *ini file located in ``skimage.io._plugins``.
+        See also :func:`skimage.io.available_plugins`.
+    partial definition: Specified in an *ini file, but not defined in the
+        corresponding plugin module. This will raise an error when loaded.
+    available but not on this system: Defined in ``skimage.io._plugins``, but
+        a dependent library (e.g. Qt, PIL) is not available on your system.
+        This will raise an error when loaded.
+    loaded: The real availability is determined when it's explicitly loaded,
+        either because it's one of the default plugins, or because it's
+        loaded explicitly by the user.
+
+"""
+
+import os.path
+import warnings
+from configparser import ConfigParser
+from glob import glob
+
+from .collection import imread_collection_wrapper
+
+__all__ = [
+    'use_plugin',
+    'call_plugin',
+    'plugin_info',
+    'plugin_order',
+    'reset_plugins',
+    'find_available_plugins',
+    'available_plugins',
+]
+
+# The plugin store will save a list of *loaded* io functions for each io type
+# (e.g. 'imread', 'imsave', etc.). Plugins are loaded as requested.
+plugin_store = None
+# Dictionary mapping plugin names to a list of functions they provide.
+plugin_provides = {}
+# The module names for the plugins in `skimage.io._plugins`.
+plugin_module_name = {}
+# Meta-data about plugins provided by *.ini files.
+plugin_meta_data = {}
+# For each plugin type, default to the first available plugin as defined by
+# the following preferences.
+preferred_plugins = {
+    # Default plugins for all types (overridden by specific types below).
+    'all': ['imageio', 'pil', 'matplotlib'],
+    'imshow': ['matplotlib'],
+    'imshow_collection': ['matplotlib'],
+}
+
+
+def _clear_plugins():
+    """Clear the plugin state to the default, i.e., where no plugins are loaded"""
+    global plugin_store
+    plugin_store = {
+        'imread': [],
+        'imsave': [],
+        'imshow': [],
+        'imread_collection': [],
+        'imshow_collection': [],
+        '_app_show': [],
+    }
+
+
+_clear_plugins()
+
+
+def _load_preferred_plugins():
+    # Load preferred plugin for each io function.
+    io_types = ['imsave', 'imshow', 'imread_collection', 'imshow_collection', 'imread']
+    for p_type in io_types:
+        _set_plugin(p_type, preferred_plugins['all'])
+
+    plugin_types = (p for p in preferred_plugins.keys() if p != 'all')
+    for p_type in plugin_types:
+        _set_plugin(p_type, preferred_plugins[p_type])
+
+
+def _set_plugin(plugin_type, plugin_list):
+    for plugin in plugin_list:
+        if plugin not in available_plugins:
+            continue
+        try:
+            use_plugin(plugin, kind=plugin_type)
+            break
+        except (ImportError, RuntimeError, OSError):
+            pass
+
+
+def reset_plugins():
+    _clear_plugins()
+    _load_preferred_plugins()
+
+
+def _parse_config_file(filename):
+    """Return plugin name and meta-data dict from plugin config file."""
+    parser = ConfigParser()
+    parser.read(filename)
+    name = parser.sections()[0]
+
+    meta_data = {}
+    for opt in parser.options(name):
+        meta_data[opt] = parser.get(name, opt)
+
+    return name, meta_data
+
+
+def _scan_plugins():
+    """Scan the plugins directory for .ini files and parse them
+    to gather plugin meta-data.
+    """
+    pd = os.path.dirname(__file__)
+    config_files = glob(os.path.join(pd, '_plugins', '*.ini'))
+
+    for filename in config_files:
+        name, meta_data = _parse_config_file(filename)
+        if 'provides' not in meta_data:
+            warnings.warn(
+                f'file {filename} not recognized as a scikit-image io plugin, skipping.'
+            )
+            continue
+        plugin_meta_data[name] = meta_data
+        provides = [s.strip() for s in meta_data['provides'].split(',')]
+        valid_provides = [p for p in provides if p in plugin_store]
+
+        for p in provides:
+            if p not in plugin_store:
+                print(f"Plugin `{name}` wants to provide non-existent `{p}`. Ignoring.")
+
+        # Add plugins that provide 'imread' as provider of 'imread_collection'.
+        need_to_add_collection = (
+            'imread_collection' not in valid_provides and 'imread' in valid_provides
+        )
+        if need_to_add_collection:
+            valid_provides.append('imread_collection')
+
+        plugin_provides[name] = valid_provides
+
+        plugin_module_name[name] = os.path.basename(filename)[:-4]
+
+
+_scan_plugins()
+
+
+def find_available_plugins(loaded=False):
+    """List available plugins.
+
+    Parameters
+    ----------
+    loaded : bool
+        If True, show only those plugins currently loaded.  By default,
+        all plugins are shown.
+
+    Returns
+    -------
+    p : dict
+        Dictionary with plugin names as keys and exposed functions as
+        values.
+
+    """
+    active_plugins = set()
+    for plugin_func in plugin_store.values():
+        for plugin, func in plugin_func:
+            active_plugins.add(plugin)
+
+    d = {}
+    for plugin in plugin_provides:
+        if not loaded or plugin in active_plugins:
+            d[plugin] = [f for f in plugin_provides[plugin] if not f.startswith('_')]
+
+    return d
+
+
+available_plugins = find_available_plugins()
+
+
+def call_plugin(kind, *args, **kwargs):
+    """Find the appropriate plugin of 'kind' and execute it.
+
+    Parameters
+    ----------
+    kind : {'imshow', 'imsave', 'imread', 'imread_collection'}
+        Function to look up.
+    plugin : str, optional
+        Plugin to load.  Defaults to None, in which case the first
+        matching plugin is used.
+    *args, **kwargs : arguments and keyword arguments
+        Passed to the plugin function.
+
+    """
+    if kind not in plugin_store:
+        raise ValueError(f'Invalid function ({kind}) requested.')
+
+    plugin_funcs = plugin_store[kind]
+    if len(plugin_funcs) == 0:
+        msg = (
+            f"No suitable plugin registered for {kind}.\n\n"
+            "You may load I/O plugins with the `skimage.io.use_plugin` "
+            "command.  A list of all available plugins are shown in the "
+            "`skimage.io` docstring."
+        )
+        raise RuntimeError(msg)
+
+    plugin = kwargs.pop('plugin', None)
+    if plugin is None:
+        _, func = plugin_funcs[0]
+    else:
+        _load(plugin)
+        try:
+            func = [f for (p, f) in plugin_funcs if p == plugin][0]
+        except IndexError:
+            raise RuntimeError(f'Could not find the plugin "{plugin}" for {kind}.')
+
+    return func(*args, **kwargs)
+
+
+def use_plugin(name, kind=None):
+    """Set the default plugin for a specified operation.  The plugin
+    will be loaded if it hasn't been already.
+
+    Parameters
+    ----------
+    name : str
+        Name of plugin. See ``skimage.io.available_plugins`` for a list of available
+        plugins.
+    kind : {'imsave', 'imread', 'imshow', 'imread_collection', 'imshow_collection'}, optional
+        Set the plugin for this function.  By default,
+        the plugin is set for all functions.
+
+    Examples
+    --------
+    To use Matplotlib as the default image reader, you would write:
+
+    >>> from skimage import io
+    >>> io.use_plugin('matplotlib', 'imread')
+
+    To see a list of available plugins run ``skimage.io.available_plugins``. Note
+    that this lists plugins that are defined, but the full list may not be usable
+    if your system does not have the required libraries installed.
+
+    """
+    if kind is None:
+        kind = plugin_store.keys()
+    else:
+        if kind not in plugin_provides[name]:
+            raise RuntimeError(f"Plugin {name} does not support `{kind}`.")
+
+        if kind == 'imshow':
+            kind = [kind, '_app_show']
+        else:
+            kind = [kind]
+
+    _load(name)
+
+    for k in kind:
+        if k not in plugin_store:
+            raise RuntimeError(f"'{k}' is not a known plugin function.")
+
+        funcs = plugin_store[k]
+
+        # Shuffle the plugins so that the requested plugin stands first
+        # in line
+        funcs = [(n, f) for (n, f) in funcs if n == name] + [
+            (n, f) for (n, f) in funcs if n != name
+        ]
+
+        plugin_store[k] = funcs
+
+
+def _inject_imread_collection_if_needed(module):
+    """Add `imread_collection` to module if not already present."""
+    if not hasattr(module, 'imread_collection') and hasattr(module, 'imread'):
+        imread = getattr(module, 'imread')
+        func = imread_collection_wrapper(imread)
+        setattr(module, 'imread_collection', func)
+
+
+def _load(plugin):
+    """Load the given plugin.
+
+    Parameters
+    ----------
+    plugin : str
+        Name of plugin to load.
+
+    See Also
+    --------
+    plugins : List of available plugins
+
+    """
+    if plugin in find_available_plugins(loaded=True):
+        return
+    if plugin not in plugin_module_name:
+        raise ValueError(f"Plugin {plugin} not found.")
+    else:
+        modname = plugin_module_name[plugin]
+        plugin_module = __import__('skimage.io._plugins.' + modname, fromlist=[modname])
+
+    provides = plugin_provides[plugin]
+    for p in provides:
+        if p == 'imread_collection':
+            _inject_imread_collection_if_needed(plugin_module)
+        elif not hasattr(plugin_module, p):
+            print(f"Plugin {plugin} does not provide {p} as advertised.  Ignoring.")
+            continue
+
+        store = plugin_store[p]
+        func = getattr(plugin_module, p)
+        if (plugin, func) not in store:
+            store.append((plugin, func))
+
+
+def plugin_info(plugin):
+    """Return plugin meta-data.
+
+    Parameters
+    ----------
+    plugin : str
+        Name of plugin.
+
+    Returns
+    -------
+    m : dict
+        Meta data as specified in plugin ``.ini``.
+
+    """
+    try:
+        return plugin_meta_data[plugin]
+    except KeyError:
+        raise ValueError(f'No information on plugin "{plugin}"')
+
+
+def plugin_order():
+    """Return the currently preferred plugin order.
+
+    Returns
+    -------
+    p : dict
+        Dictionary of preferred plugin order, with function name as key and
+        plugins (in order of preference) as value.
+
+    """
+    p = {}
+    for func in plugin_store:
+        p[func] = [plugin_name for (plugin_name, f) in plugin_store[func]]
+    return p

.CondaPkg/env/Lib/site-packages/skimage/io/sift.py

@@ -0,0 +1,93 @@
+import numpy as np
+
+__all__ = ['load_sift', 'load_surf']
+
+
+def _sift_read(filelike, mode='SIFT'):
+    """Read SIFT or SURF features from externally generated file.
+
+    This routine reads SIFT or SURF files generated by binary utilities from
+    http://people.cs.ubc.ca/~lowe/keypoints/ and
+    http://www.vision.ee.ethz.ch/~surf/.
+
+    This routine *does not* generate SIFT/SURF features from an image. These
+    algorithms are patent encumbered. Please use :obj:`skimage.feature.CENSURE`
+    instead.
+
+    Parameters
+    ----------
+    filelike : string or open file
+        Input file generated by the feature detectors from
+        http://people.cs.ubc.ca/~lowe/keypoints/ or
+        http://www.vision.ee.ethz.ch/~surf/ .
+    mode : {'SIFT', 'SURF'}, optional
+        Kind of descriptor used to generate `filelike`.
+
+    Returns
+    -------
+    data : record array with fields
+        - row: int
+            row position of feature
+        - column: int
+            column position of feature
+        - scale: float
+            feature scale
+        - orientation: float
+            feature orientation
+        - data: array
+            feature values
+
+    """
+    if isinstance(filelike, str):
+        f = open(filelike)
+        filelike_is_str = True
+    else:
+        f = filelike
+        filelike_is_str = False
+
+    if mode == 'SIFT':
+        nr_features, feature_len = map(int, f.readline().split())
+        datatype = np.dtype(
+            [
+                ('row', float),
+                ('column', float),
+                ('scale', float),
+                ('orientation', float),
+                ('data', (float, feature_len)),
+            ]
+        )
+    else:
+        mode = 'SURF'
+        feature_len = int(f.readline()) - 1
+        nr_features = int(f.readline())
+        datatype = np.dtype(
+            [
+                ('column', float),
+                ('row', float),
+                ('second_moment', (float, 3)),
+                ('sign', float),
+                ('data', (float, feature_len)),
+            ]
+        )
+
+    data = np.fromfile(f, sep=' ')
+    if data.size != nr_features * datatype.itemsize / np.dtype(float).itemsize:
+        raise OSError(f'Invalid {mode} feature file.')
+
+    # If `filelike` is passed to the function as filename - close the file
+    if filelike_is_str:
+        f.close()
+
+    return data.view(datatype)
+
+
+def load_sift(f):
+    return _sift_read(f, mode='SIFT')
+
+
+def load_surf(f):
+    return _sift_read(f, mode='SURF')
+
+
+load_sift.__doc__ = _sift_read.__doc__
+load_surf.__doc__ = _sift_read.__doc__

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_collection.py

@@ -0,0 +1,168 @@
+import os
+import itertools
+
+import numpy as np
+import imageio.v3 as iio3
+from skimage import data_dir
+from skimage.io.collection import ImageCollection, MultiImage, alphanumeric_key
+from skimage.io import reset_plugins
+
+from skimage._shared import testing
+from skimage._shared.testing import assert_equal, assert_allclose, fetch
+
+import pytest
+
+
+try:
+    has_pooch = True
+except ModuleNotFoundError:
+    has_pooch = False
+
+
+def test_string_split():
+    test_string = 'z23a'
+    test_str_result = ['z', 23, 'a']
+    assert_equal(alphanumeric_key(test_string), test_str_result)
+
+
+def test_string_sort():
+    filenames = [
+        'f9.10.png',
+        'f9.9.png',
+        'f10.10.png',
+        'f10.9.png',
+        'e9.png',
+        'e10.png',
+        'em.png',
+    ]
+    expected_filenames = [
+        'e9.png',
+        'e10.png',
+        'em.png',
+        'f9.9.png',
+        'f9.10.png',
+        'f10.9.png',
+        'f10.10.png',
+    ]
+    sorted_filenames = sorted(filenames, key=alphanumeric_key)
+    assert_equal(expected_filenames, sorted_filenames)
+
+
+def test_imagecollection_input():
+    """Test function for ImageCollection. The new behavior (implemented
+    in 0.16) allows the `pattern` argument to accept a list of strings
+    as the input.
+
+    Notes
+    -----
+        If correct, `images` will receive three images.
+    """
+    # Ensure that these images are part of the legacy datasets
+    # this means they will always be available in the user's install
+    # regardless of the availability of pooch
+    pics = [
+        fetch('data/coffee.png'),
+        fetch('data/chessboard_GRAY.png'),
+        fetch('data/rocket.jpg'),
+    ]
+    pattern = [os.path.join(data_dir, pic) for pic in pics]
+    images = ImageCollection(pattern)
+    assert len(images) == 3
+
+
+class TestImageCollection:
+    pics = [fetch('data/brick.png'), fetch('data/color.png'), fetch('data/moon.png')]
+    pattern = pics[:2]
+    pattern_same_shape = pics[::2]
+
+    def setup_method(self):
+        reset_plugins()
+        # Generic image collection with images of different shapes.
+        self.images = ImageCollection(self.pattern)
+        # Image collection with images having shapes that match.
+        self.images_matched = ImageCollection(self.pattern_same_shape)
+        # Same images as a collection of frames
+        self.frames_matched = MultiImage(self.pattern_same_shape)
+
+    def test_len(self):
+        assert len(self.images) == 2
+
+    def test_getitem(self):
+        num = len(self.images)
+        for i in range(-num, num):
+            assert isinstance(self.images[i], np.ndarray)
+        assert_allclose(self.images[0], self.images[-num])
+
+        def return_img(n):
+            return self.images[n]
+
+        with testing.raises(IndexError):
+            return_img(num)
+        with testing.raises(IndexError):
+            return_img(-num - 1)
+
+    def test_slicing(self):
+        assert type(self.images[:]) is ImageCollection
+        assert len(self.images[:]) == 2
+        assert len(self.images[:1]) == 1
+        assert len(self.images[1:]) == 1
+        assert_allclose(self.images[0], self.images[:1][0])
+        assert_allclose(self.images[1], self.images[1:][0])
+        assert_allclose(self.images[1], self.images[::-1][0])
+        assert_allclose(self.images[0], self.images[::-1][1])
+
+    def test_files_property(self):
+        assert isinstance(self.images.files, list)
+
+        def set_files(f):
+            self.images.files = f
+
+        with testing.raises(AttributeError):
+            set_files('newfiles')
+
+    @pytest.mark.skipif(not has_pooch, reason="needs pooch to download data")
+    def test_custom_load_func_sequence(self):
+        filename = fetch('data/no_time_for_that_tiny.gif')
+
+        def reader(index):
+            return iio3.imread(filename, index=index)
+
+        ic = ImageCollection(range(24), load_func=reader)
+        # the length of ic should be that of the given load_pattern sequence
+        assert len(ic) == 24
+        # GIF file has frames of size 25x14 with 4 channels (RGBA)
+        assert ic[0].shape == (25, 14, 3)
+
+    @pytest.mark.skipif(not has_pooch, reason="needs pooch to download data")
+    def test_custom_load_func_w_kwarg(self):
+        load_pattern = fetch('data/no_time_for_that_tiny.gif')
+
+        def load_fn(f, step):
+            vid = iio3.imiter(f)
+            return list(itertools.islice(vid, None, None, step))
+
+        ic = ImageCollection(load_pattern, load_func=load_fn, step=3)
+        # Each file should map to one image (array).
+        assert len(ic) == 1
+        # GIF file has 24 frames, so 24 / 3 equals 8.
+        assert len(ic[0]) == 8
+
+    def test_custom_load_func(self):
+        def load_fn(x):
+            return x
+
+        ic = ImageCollection(os.pathsep.join(self.pattern), load_func=load_fn)
+        assert_equal(ic[0], self.pattern[0])
+
+    def test_concatenate(self):
+        array = self.images_matched.concatenate()
+        expected_shape = (len(self.images_matched),) + self.images[0].shape
+        assert_equal(array.shape, expected_shape)
+
+    def test_concatenate_mismatched_image_shapes(self):
+        with testing.raises(ValueError):
+            self.images.concatenate()
+
+    def test_multiimage_imagecollection(self):
+        assert_equal(self.images_matched[0], self.frames_matched[0])
+        assert_equal(self.images_matched[1], self.frames_matched[1])

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_fits.py

@@ -0,0 +1,35 @@
+import numpy as np
+import skimage.io as io
+from skimage._shared import testing
+
+
+testing.pytest.importorskip('astropy')
+
+
+@testing.pytest.fixture(autouse=True)
+def _reset_plugin():
+    yield
+    io.reset_plugins()
+
+
+def test_imread():
+    # Make sure we get an import exception if Astropy isn't there
+    # (not sure how useful this is, but it ensures there isn't some other
+    # error when trying to load the plugin)
+    try:
+        io.use_plugin('fits')
+    except ImportError:
+        raise ()
+
+
+def _same_ImageCollection(collection1, collection2):
+    """
+    Ancillary function to compare two ImageCollection objects, checking that
+    their constituent arrays are equal.
+    """
+    if len(collection1) != len(collection2):
+        return False
+    for ext1, ext2 in zip(collection1, collection2):
+        if not np.all(ext1 == ext2):
+            return False
+    return True

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_histograms.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+from skimage.io._plugins._histograms import histograms
+
+
+class TestHistogram:
+    def test_basic(self):
+        img = np.ones((50, 50, 3), dtype=np.uint8)
+        bands = histograms(img, 255)
+        for band in bands:
+            np.testing.assert_equal(band.sum(), 50**2)
+
+    def test_counts(self):
+        channel = np.arange(255).reshape(51, 5)
+        img = np.empty((51, 5, 3), dtype='uint8')
+        img[:, :, 0] = channel
+        img[:, :, 1] = channel
+        img[:, :, 2] = channel
+        r, g, b, v = histograms(img, 255)
+        np.testing.assert_array_equal(r, g)
+        np.testing.assert_array_equal(r, b)
+        np.testing.assert_array_equal(r, v)
+        np.testing.assert_array_equal(r, np.ones(255))

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_imageio.py

@@ -0,0 +1,85 @@
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+from skimage.io import imread, imsave, plugin_order
+
+from skimage._shared import testing
+from skimage._shared.testing import fetch, assert_stacklevel
+
+import pytest
+
+
+def test_prefered_plugin():
+    # Don't call use_plugin("imageio") before, this way we test that imageio is used
+    # by default
+    order = plugin_order()
+    assert order["imread"][0] == "imageio"
+    assert order["imsave"][0] == "imageio"
+    assert order["imread_collection"][0] == "imageio"
+
+
+def test_imageio_as_gray():
+    img = imread(fetch('data/color.png'), as_gray=True)
+    assert img.ndim == 2
+    assert img.dtype == np.float64
+    img = imread(fetch('data/camera.png'), as_gray=True)
+    # check that conversion does not happen for a gray image
+    assert np.dtype(img.dtype).char in np.typecodes['AllInteger']
+
+
+def test_imageio_palette():
+    img = imread(fetch('data/palette_color.png'))
+    assert img.ndim == 3
+
+
+def test_imageio_truncated_jpg():
+    # imageio>2.0 uses Pillow / PIL to try and load the file.
+    # Oddly, PIL explicitly raises a SyntaxError when the file read fails.
+    # The exception type changed from SyntaxError to OSError in PIL 8.2.0, so
+    # allow for either to be raised.
+    with testing.raises((OSError, SyntaxError)):
+        imread(fetch('data/truncated.jpg'))
+
+
+class TestSave:
+    @pytest.mark.parametrize(
+        "shape,dtype",
+        [
+            # float32, float64 can't be saved as PNG and raise
+            # uint32 is not roundtripping properly
+            ((10, 10), np.uint8),
+            ((10, 10), np.uint16),
+            ((10, 10, 2), np.uint8),
+            ((10, 10, 3), np.uint8),
+            ((10, 10, 4), np.uint8),
+        ],
+    )
+    def test_imsave_roundtrip(self, shape, dtype, tmp_path):
+        if np.issubdtype(dtype, np.floating):
+            min_ = 0
+            max_ = 1
+        else:
+            min_ = 0
+            max_ = np.iinfo(dtype).max
+        expected = np.linspace(
+            min_, max_, endpoint=True, num=np.prod(shape), dtype=dtype
+        )
+        expected = expected.reshape(shape)
+        file_path = tmp_path / "roundtrip.png"
+        imsave(file_path, expected)
+        actual = imread(file_path)
+        np.testing.assert_array_almost_equal(actual, expected)
+
+    def test_bool_array_save(self):
+        with NamedTemporaryFile(suffix='.png') as f:
+            fname = f.name
+
+        with pytest.warns(UserWarning, match=r'.* is a boolean image') as record:
+            a = np.zeros((5, 5), bool)
+            a[2, 2] = True
+            imsave(fname, a)
+        assert_stacklevel(record)
+
+
+def test_return_class():
+    testing.assert_equal(type(imread(fetch('data/color.png'))), np.ndarray)

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_imread.py

@@ -0,0 +1,75 @@
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+from skimage import io
+from skimage.io import imread, imsave, use_plugin, reset_plugins
+
+from skimage._shared import testing
+from skimage._shared.testing import (
+    TestCase,
+    assert_array_equal,
+    assert_array_almost_equal,
+    fetch,
+)
+
+import pytest
+
+pytest.importorskip('imread')
+
+
+@pytest.fixture(autouse=True)
+def _use_imread_plugin():
+    """Ensure that PIL plugin is used in tests here."""
+    use_plugin('imread')
+    yield
+    reset_plugins()
+
+
+def test_imread_as_gray():
+    img = imread(fetch('data/color.png'), as_gray=True)
+    assert img.ndim == 2
+    assert img.dtype == np.float64
+    img = imread(fetch('data/camera.png'), as_gray=True)
+    # check that conversion does not happen for a gray image
+    assert np.dtype(img.dtype).char in np.typecodes['AllInteger']
+
+
+def test_imread_palette():
+    img = imread(fetch('data/palette_color.png'))
+    assert img.ndim == 3
+
+
+def test_imread_truncated_jpg():
+    with testing.raises(RuntimeError):
+        io.imread(fetch('data/truncated.jpg'))
+
+
+def test_bilevel():
+    expected = np.zeros((10, 10), bool)
+    expected[::2] = 1
+
+    img = imread(fetch('data/checker_bilevel.png'))
+    assert_array_equal(img.astype(bool), expected)
+
+
+class TestSave(TestCase):
+    def roundtrip(self, x, scaling=1):
+        with NamedTemporaryFile(suffix='.png') as f:
+            fname = f.name
+
+        imsave(fname, x)
+        y = imread(fname)
+
+        assert_array_almost_equal((x * scaling).astype(np.int32), y)
+
+    def test_imsave_roundtrip(self):
+        dtype = np.uint8
+        np.random.seed(0)
+        for shape in [(10, 10), (10, 10, 3), (10, 10, 4)]:
+            x = np.ones(shape, dtype=dtype) * np.random.rand(*shape)
+
+            if np.issubdtype(dtype, np.floating):
+                yield self.roundtrip, x, 255
+            else:
+                x = (x * 255).astype(dtype)
+                yield self.roundtrip, x

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_io.py

@@ -0,0 +1,122 @@
+import os
+import pathlib
+import tempfile
+
+import numpy as np
+import pytest
+
+from skimage import io
+from skimage._shared.testing import assert_array_equal, fetch
+from skimage._shared._dependency_checks import is_wasm
+from skimage.data import data_dir
+
+
+one_by_one_jpeg = (
+    b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01'
+    b'\x00\x01\x00\x00\xff\xdb\x00C\x00\x03\x02\x02\x02\x02'
+    b'\x02\x03\x02\x02\x02\x03\x03\x03\x03\x04\x06\x04\x04'
+    b'\x04\x04\x04\x08\x06\x06\x05\x06\t\x08\n\n\t\x08\t\t'
+    b'\n\x0c\x0f\x0c\n\x0b\x0e\x0b\t\t\r\x11\r\x0e\x0f\x10'
+    b'\x10\x11\x10\n\x0c\x12\x13\x12\x10\x13\x0f\x10\x10'
+    b'\x10\xff\xc0\x00\x0b\x08\x00\x01\x00\x01\x01\x01\x11'
+    b'\x00\xff\xc4\x00\x14\x00\x01\x00\x00\x00\x00\x00\x00'
+    b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\xff\xc4\x00'
+    b'\x14\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    b'\x00\x00\x00\x00\x00\x00\xff\xda\x00\x08\x01\x01\x00'
+    b'\x00?\x00*\x9f\xff\xd9'
+)
+
+
+def test_stack_basic():
+    x = np.arange(12).reshape(3, 4)
+    io.push(x)
+
+    assert_array_equal(io.pop(), x)
+
+
+def test_stack_non_array():
+    with pytest.raises(ValueError):
+        io.push([[1, 2, 3]])
+
+
+def test_imread_file_url():
+    # tweak data path so that file URI works on both unix and windows.
+    data_path = str(fetch('data/camera.png'))
+    data_path = data_path.replace(os.path.sep, '/')
+    image_url = f'file:///{data_path}'
+    image = io.imread(image_url)
+    assert image.shape == (512, 512)
+
+
+@pytest.mark.skipif(is_wasm, reason="no access to pytest-localserver")
+def test_imread_http_url(httpserver):
+    # httpserver is a fixture provided by pytest-localserver
+    # https://bitbucket.org/pytest-dev/pytest-localserver/
+    httpserver.serve_content(one_by_one_jpeg)
+    # it will serve anything you provide to it on its url.
+    # we add a /test.jpg so that we can identify the content
+    # by extension
+    image = io.imread(httpserver.url + '/test.jpg' + '?' + 's' * 266)
+    assert image.shape == (1, 1)
+
+
+def test_imread_pathlib_tiff():
+    """Tests reading from Path object (issue gh-5545)."""
+
+    # read via fetch
+    fname = fetch('data/multipage.tif')
+    expected = io.imread(fname)
+
+    # read by passing in a pathlib.Path object
+    path = pathlib.Path(fname)
+    img = io.imread(path)
+
+    assert img.shape == (2, 15, 10)
+    assert_array_equal(expected, img)
+
+
+def _named_tempfile_func(error_class):
+    """Create a mock function for NamedTemporaryFile that always raises.
+
+    Parameters
+    ----------
+    error_class : exception class
+        The error that should be raised when asking for a NamedTemporaryFile.
+
+    Returns
+    -------
+    named_temp_file : callable
+        A function that always raises the desired error.
+
+    Notes
+    -----
+    Although this function has general utility for raising errors, it is
+    expected to be used to raise errors that ``tempfile.NamedTemporaryFile``
+    from the Python standard library could raise. As of this writing, these
+    are ``FileNotFoundError``, ``FileExistsError``, ``PermissionError``, and
+    ``BaseException``. See
+    `this comment <https://github.com/scikit-image/scikit-image/issues/3785#issuecomment-486598307>`__  # noqa
+    for more information.
+    """
+
+    def named_temp_file(*args, **kwargs):
+        raise error_class()
+
+    return named_temp_file
+
+
+@pytest.mark.parametrize(
+    'error_class', [FileNotFoundError, FileExistsError, PermissionError, BaseException]
+)
+def test_failed_temporary_file(monkeypatch, error_class):
+    fetch('data/camera.png')
+    # tweak data path so that file URI works on both unix and windows.
+    data_path = data_dir.lstrip(os.path.sep)
+    data_path = data_path.replace(os.path.sep, '/')
+    image_url = f'file:///{data_path}/camera.png'
+    with monkeypatch.context():
+        monkeypatch.setattr(
+            tempfile, 'NamedTemporaryFile', _named_tempfile_func(error_class)
+        )
+        with pytest.raises(error_class):
+            io.imread(image_url)

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_mpl_imshow.py

@@ -0,0 +1,146 @@
+import numpy as np
+import pytest
+
+from skimage import io
+from skimage._shared._warnings import expected_warnings
+from skimage._shared._dependency_checks import is_wasm
+
+plt = pytest.importorskip("matplotlib.pyplot")
+
+if plt:
+    plt.switch_backend("Agg")
+
+
+@pytest.fixture(autouse=True)
+def _reset_plugins():
+    io.reset_plugins()
+
+
+# test images. Note that they don't have their full range for their dtype,
+# but we still expect the display range to equal the full dtype range.
+im8 = np.array([[0, 64], [128, 240]], np.uint8)
+im16 = im8.astype(np.uint16) * 256
+im64 = im8.astype(np.uint64)
+imf = im8 / 255
+im_lo = imf / 1000
+im_hi = imf + 10
+
+imshow_expected_warnings = [
+    r"tight_layout : falling back to Agg|\A\Z",
+    r"tight_layout: falling back to Agg|\A\Z",  # formatting change in mpl
+    # Maptlotlib 2.2.3 seems to use np.asscalar which issues a warning
+    # with numpy 1.16
+    # Matplotlib 2.2.3 is the last supported version for python 2.7
+    r"np.asscalar|\A\Z",
+    r"The figure layout has changed to tight|\A\Z",
+]
+
+# This warning comes from the Python 3.12.1 interpreter powered by Pyodide
+# and is not relevant to the tests where it is raised.
+if is_wasm:
+    imshow_expected_warnings.append(
+        r"Pickle, copy, and deepcopy support will be removed from itertools in Python 3.14|\A\Z"
+    )
+
+
+def n_subplots(ax_im):
+    """Return the number of subplots in the figure containing an ``AxesImage``.
+
+    Parameters
+    ----------
+    ax_im : matplotlib.pyplot.AxesImage object
+        The input ``AxesImage``.
+
+    Returns
+    -------
+    n : int
+        The number of subplots in the corresponding figure.
+
+    Notes
+    -----
+    This function is intended to check whether a colorbar was drawn, in
+    which case two subplots are expected. For standard imshows, one
+    subplot is expected.
+    """
+    return len(ax_im.get_figure().get_axes())
+
+
+def test_uint8():
+    plt.figure()
+    with expected_warnings(imshow_expected_warnings + [r"CObject type is marked|\A\Z"]):
+        ax_im = io.imshow(im8)
+    assert ax_im.cmap.name == 'gray'
+    assert ax_im.get_clim() == (0, 255)
+    assert n_subplots(ax_im) == 1
+    assert ax_im.colorbar is None
+
+
+def test_uint16():
+    plt.figure()
+    with expected_warnings(imshow_expected_warnings + [r"CObject type is marked|\A\Z"]):
+        ax_im = io.imshow(im16)
+    assert ax_im.cmap.name == 'gray'
+    assert ax_im.get_clim() == (0, 65535)
+    assert n_subplots(ax_im) == 1
+    assert ax_im.colorbar is None
+
+
+def test_float():
+    plt.figure()
+    with expected_warnings(imshow_expected_warnings + [r"CObject type is marked|\A\Z"]):
+        ax_im = io.imshow(imf)
+    assert ax_im.cmap.name == 'gray'
+    assert ax_im.get_clim() == (0, 1)
+    assert n_subplots(ax_im) == 1
+    assert ax_im.colorbar is None
+
+
+def test_low_data_range():
+    with expected_warnings(
+        imshow_expected_warnings + ["Low image data range|CObject type is marked"]
+    ):
+        ax_im = io.imshow(im_lo)
+    assert ax_im.get_clim() == (im_lo.min(), im_lo.max())
+    # check that a colorbar was created
+    assert ax_im.colorbar is not None
+
+
+def test_outside_standard_range():
+    plt.figure()
+    # Warning raised by matplotlib on Windows:
+    # "The CObject type is marked Pending Deprecation in Python 2.7.
+    #  Please use capsule objects instead."
+    # Ref: https://docs.python.org/2/c-api/cobject.html
+    with expected_warnings(
+        imshow_expected_warnings + ["out of standard range|CObject type is marked"]
+    ):
+        ax_im = io.imshow(im_hi)
+    assert ax_im.get_clim() == (im_hi.min(), im_hi.max())
+    assert n_subplots(ax_im) == 2
+    assert ax_im.colorbar is not None
+
+
+def test_nonstandard_type():
+    plt.figure()
+    # Warning raised by matplotlib on Windows:
+    # "The CObject type is marked Pending Deprecation in Python 2.7.
+    #  Please use capsule objects instead."
+    # Ref: https://docs.python.org/2/c-api/cobject.html
+    with expected_warnings(
+        imshow_expected_warnings + ["Low image data range|CObject type is marked"]
+    ):
+        ax_im = io.imshow(im64)
+    assert ax_im.get_clim() == (im64.min(), im64.max())
+    assert n_subplots(ax_im) == 2
+    assert ax_im.colorbar is not None
+
+
+def test_signed_image():
+    plt.figure()
+    im_signed = np.array([[-0.5, -0.2], [0.1, 0.4]])
+
+    with expected_warnings(imshow_expected_warnings + [r"CObject type is marked|\A\Z"]):
+        ax_im = io.imshow(im_signed)
+    assert ax_im.get_clim() == (-0.5, 0.5)
+    assert n_subplots(ax_im) == 2
+    assert ax_im.colorbar is not None

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_multi_image.py

@@ -0,0 +1,100 @@
+import os
+
+import numpy as np
+from skimage.io import use_plugin, reset_plugins
+from skimage.io.collection import MultiImage
+
+from skimage._shared import testing
+from skimage._shared.testing import assert_equal, assert_allclose
+
+from pytest import fixture
+
+
+@fixture
+def imgs():
+    use_plugin('pil')
+
+    paths = [
+        testing.fetch('data/multipage_rgb.tif'),
+        testing.fetch('data/no_time_for_that_tiny.gif'),
+    ]
+    imgs = [
+        MultiImage(paths[0]),
+        MultiImage(paths[0], conserve_memory=False),
+        MultiImage(paths[1]),
+        MultiImage(paths[1], conserve_memory=False),
+        MultiImage(os.pathsep.join(paths)),
+    ]
+    yield imgs
+
+    reset_plugins()
+
+
+def test_shapes(imgs):
+    imgs = imgs[-1]
+    assert imgs[0][0].shape == imgs[0][1].shape
+    assert imgs[0][0].shape == (10, 10, 3)
+
+
+def test_len(imgs):
+    assert len(imgs[0][0]) == len(imgs[1][0]) == 2
+    assert len(imgs[2][0]) == len(imgs[3][0]) == 24
+    assert len(imgs[-1]) == 2, len(imgs[-1])
+
+
+def test_slicing(imgs):
+    img = imgs[-1]
+    assert type(img[:]) is MultiImage
+    assert len(img[0][:]) + len(img[1][:]) == 26, len(img[:])
+    assert len(img[0][:1]) == 1
+    assert len(img[1][1:]) == 23
+    assert_allclose(img[0], img[:1][0])
+    assert_allclose(img[1], img[1:][0])
+    assert_allclose(img[-1], img[::-1][0])
+    assert_allclose(img[0], img[::-1][-1])
+
+
+def test_getitem(imgs):
+    for img in imgs[0]:
+        num = len(img)
+
+        for i in range(-num, num):
+            assert type(img[i]) is np.ndarray
+        assert_allclose(img[0], img[-num])
+
+        with testing.raises(AssertionError):
+            assert_allclose(img[0], img[1])
+
+        with testing.raises(IndexError):
+            img[num]
+        with testing.raises(IndexError):
+            img[-num - 1]
+
+
+def test_files_property(imgs):
+    for img in imgs:
+        if isinstance(img, MultiImage):
+            continue
+
+        assert isinstance(img.filename, str)
+
+        with testing.raises(AttributeError):
+            img.filename = "newfile"
+
+
+def test_conserve_memory_property(imgs):
+    for img in imgs:
+        assert isinstance(img.conserve_memory, bool)
+
+        with testing.raises(AttributeError):
+            img.conserve_memory = True
+
+
+def test_concatenate(imgs):
+    for img in imgs:
+        if img[0].shape != img[-1].shape:
+            with testing.raises(ValueError):
+                img.concatenate()
+            continue
+        array = img.concatenate()
+        assert_equal(array.shape, (len(img),) + img[0].shape)

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_pil.py

@@ -0,0 +1,311 @@
+import os
+from io import BytesIO
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+import pytest
+from PIL import Image
+from skimage._shared import testing
+from skimage._shared._tempfile import temporary_file
+from skimage._shared._warnings import expected_warnings
+from skimage._shared.testing import (
+    assert_allclose,
+    assert_array_almost_equal,
+    assert_array_equal,
+    assert_equal,
+    color_check,
+    fetch,
+    mono_check,
+)
+from skimage.metrics import structural_similarity
+
+from ... import img_as_float
+from ...color import rgb2lab
+from .. import imread, imsave, reset_plugins, use_plugin, plugin_order
+from .._plugins.pil_plugin import _palette_is_grayscale, ndarray_to_pil, pil_to_ndarray
+
+
+@pytest.fixture(autouse=True)
+def use_pil_plugin():
+    """Ensure that PIL plugin is used in tests here."""
+    use_plugin('pil')
+    yield
+    reset_plugins()
+
+
+def test_prefered_plugin():
+    order = plugin_order()
+    assert order["imread"][0] == "pil"
+    assert order["imsave"][0] == "pil"
+    assert order["imread_collection"][0] == "pil"
+
+
+def test_png_round_trip():
+    with NamedTemporaryFile(suffix='.png') as f:
+        fname = f.name
+
+    I = np.eye(3)
+    imsave(fname, I)
+    Ip = img_as_float(imread(fname))
+    os.remove(fname)
+    assert np.sum(np.abs(Ip - I)) < 1e-3
+
+
+def test_imread_as_gray():
+    img = imread(fetch('data/color.png'), as_gray=True)
+    assert img.ndim == 2
+    assert img.dtype == np.float64
+    img = imread(fetch('data/camera.png'), as_gray=True)
+    # check that conversion does not happen for a gray image
+    assert np.dtype(img.dtype).char in np.typecodes['AllInteger']
+
+
+@pytest.mark.parametrize('explicit_kwargs', [False, True])
+def test_imread_separate_channels(explicit_kwargs):
+    # Test that imread returns RGB(A) values contiguously even when they are
+    # stored in separate planes.
+    x = np.random.rand(3, 16, 8)
+    with NamedTemporaryFile(suffix='.tif') as f:
+        fname = f.name
+
+    # Tifffile is used as backend whenever suffix is .tif or .tiff
+    # To avoid pending changes to tifffile defaults, we must specify this is an
+    # RGB image with separate planes (i.e., channel_axis=0).
+    if explicit_kwargs:
+        pass
+    else:
+        pass
+
+    imsave(fname, x)
+    img = imread(fname)
+    os.remove(fname)
+    assert img.shape == (16, 8, 3), img.shape
+
+
+def test_imread_multipage_rgb_tif():
+    img = imread(fetch('data/multipage_rgb.tif'))
+    assert img.shape == (2, 10, 10, 3), img.shape
+
+
+def test_imread_palette():
+    img = imread(fetch('data/palette_gray.png'))
+    assert img.ndim == 2
+    img = imread(fetch('data/palette_color.png'))
+    assert img.ndim == 3
+
+
+def test_imread_index_png_with_alpha():
+    # The file `foo3x5x4indexed.png` was created with this array
+    # (3x5 is (height)x(width)):
+    dfoo = np.array(
+        [
+            [
+                [127, 0, 255, 255],
+                [127, 0, 255, 255],
+                [127, 0, 255, 255],
+                [127, 0, 255, 255],
+                [127, 0, 255, 255],
+            ],
+            [
+                [192, 192, 255, 0],
+                [192, 192, 255, 0],
+                [0, 0, 255, 0],
+                [0, 0, 255, 0],
+                [0, 0, 255, 0],
+            ],
+            [
+                [0, 31, 255, 255],
+                [0, 31, 255, 255],
+                [0, 31, 255, 255],
+                [0, 31, 255, 255],
+                [0, 31, 255, 255],
+            ],
+        ],
+        dtype=np.uint8,
+    )
+    img = imread(fetch('data/foo3x5x4indexed.png'))
+    assert_array_equal(img, dfoo)
+
+
+def test_palette_is_gray():
+    gray = Image.open(fetch('data/palette_gray.png'))
+    assert _palette_is_grayscale(gray)
+    color = Image.open(fetch('data/palette_color.png'))
+    assert not _palette_is_grayscale(color)
+
+
+def test_bilevel():
+    expected = np.zeros((10, 10))
+    expected[::2] = 255
+
+    img = imread(fetch('data/checker_bilevel.png'))
+    assert_array_equal(img, expected)
+
+
+def test_imread_uint16():
+    expected = np.load(fetch('data/chessboard_GRAY_U8.npy'))
+    img = imread(fetch('data/chessboard_GRAY_U16.tif'))
+    assert np.issubdtype(img.dtype, np.uint16)
+    assert_array_almost_equal(img, expected)
+
+
+def test_imread_truncated_jpg():
+    with testing.raises(IOError):
+        imread(fetch('data/truncated.jpg'))
+
+
+def test_jpg_quality_arg():
+    chessboard = np.load(fetch('data/chessboard_GRAY_U8.npy'))
+    with temporary_file(suffix='.jpg') as jpg:
+        imsave(jpg, chessboard, quality=95)
+        im = imread(jpg)
+        sim = structural_similarity(
+            chessboard, im, data_range=chessboard.max() - chessboard.min()
+        )
+        assert sim > 0.99
+
+
+def test_imread_uint16_big_endian():
+    expected = np.load(fetch('data/chessboard_GRAY_U8.npy'))
+    img = imread(fetch('data/chessboard_GRAY_U16B.tif'), plugin="pil")
+    assert img.dtype.type == np.uint16
+    assert_array_almost_equal(img, expected)
+
+
+class TestSave:
+    def roundtrip_file(self, x):
+        with temporary_file(suffix='.png') as fname:
+            imsave(fname, x)
+            y = imread(fname)
+            return y
+
+    def roundtrip_pil_image(self, x):
+        pil_image = ndarray_to_pil(x)
+        y = pil_to_ndarray(pil_image)
+        return y
+
+    def verify_roundtrip(self, dtype, x, y, scaling=1):
+        assert_array_almost_equal((x * scaling).astype(np.int32), y)
+
+    def verify_imsave_roundtrip(self, roundtrip_function):
+        for shape in [(10, 10), (10, 10, 3), (10, 10, 4)]:
+            for dtype in (np.uint8, np.uint16, np.float32, np.float64):
+                x = np.ones(shape, dtype=dtype) * np.random.rand(*shape)
+
+                if np.issubdtype(dtype, np.floating):
+                    yield (self.verify_roundtrip, dtype, x, roundtrip_function(x), 255)
+                else:
+                    x = (x * 255).astype(dtype)
+                    yield (self.verify_roundtrip, dtype, x, roundtrip_function(x))
+
+    def test_imsave_roundtrip_file(self):
+        self.verify_imsave_roundtrip(self.roundtrip_file)
+
+    def test_imsave_roundtrip_pil_image(self):
+        self.verify_imsave_roundtrip(self.roundtrip_pil_image)
+
+
+def test_imsave_incorrect_dimension():
+    with temporary_file(suffix='.png') as fname:
+        with testing.raises(ValueError):
+            with expected_warnings([fname + ' is a low contrast image']):
+                imsave(fname, np.zeros((2, 3, 3, 1)))
+        with testing.raises(ValueError):
+            with expected_warnings([fname + ' is a low contrast image']):
+                imsave(fname, np.zeros((2, 3, 2)))
+        # test that low contrast check is ignored
+        with testing.raises(ValueError):
+            with expected_warnings([]):
+                imsave(fname, np.zeros((2, 3, 2)), check_contrast=False)
+
+
+def test_imsave_filelike():
+    shape = (2, 2)
+    image = np.zeros(shape)
+    s = BytesIO()
+
+    # save to file-like object
+    with expected_warnings(['is a low contrast image']):
+        imsave(s, image)
+
+    # read from file-like object
+    s.seek(0)
+    out = imread(s)
+    assert_equal(out.shape, shape)
+    assert_allclose(out, image)
+
+
+def test_imsave_boolean_input():
+    shape = (2, 2)
+    image = np.eye(*shape, dtype=bool)
+    s = BytesIO()
+
+    # save to file-like object
+    with expected_warnings(['is a boolean image: setting True to 255 and False to 0']):
+        imsave(s, image)
+
+    # read from file-like object
+    s.seek(0)
+    out = imread(s)
+    assert_equal(out.shape, shape)
+    assert_allclose(out.astype(bool), image)
+
+
+def test_imexport_imimport():
+    shape = (2, 2)
+    image = np.zeros(shape)
+    pil_image = ndarray_to_pil(image)
+    out = pil_to_ndarray(pil_image)
+    assert_equal(out.shape, shape)
+
+
+def test_all_color():
+    with expected_warnings(['.* is a boolean image']):
+        color_check('pil')
+    with expected_warnings(['.* is a boolean image']):
+        color_check('pil', 'bmp')
+
+
+def test_all_mono():
+    with expected_warnings(['.* is a boolean image']):
+        mono_check('pil')
+
+
+def test_multi_page_gif():
+    img = imread(fetch('data/no_time_for_that_tiny.gif'))
+    assert img.shape == (24, 25, 14, 3), img.shape
+    img2 = imread(fetch('data/no_time_for_that_tiny.gif'), img_num=5)
+    assert img2.shape == (25, 14, 3)
+    assert_allclose(img[5], img2)
+
+
+def test_cmyk():
+    ref = imread(fetch('data/color.png'))
+
+    img = Image.open(fetch('data/color.png'))
+    img = img.convert('CMYK')
+
+    with NamedTemporaryFile(suffix='.jpg') as f:
+        fname = f.name
+
+    img.save(fname)
+    try:
+        img.close()
+    except AttributeError:  # `close` not available on PIL
+        pass
+
+    new = imread(fname)
+
+    ref_lab = rgb2lab(ref)
+    new_lab = rgb2lab(new)
+
+    for i in range(3):
+        newi = np.ascontiguousarray(new_lab[:, :, i])
+        refi = np.ascontiguousarray(ref_lab[:, :, i])
+        sim = structural_similarity(refi, newi, data_range=refi.max() - refi.min())
+        assert sim > 0.99
+
+
+def test_extreme_palette():
+    img = imread(fetch('data/green_palette.png'))
+    assert_equal(img.ndim, 3)

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_plugin.py

@@ -0,0 +1,72 @@
+from contextlib import contextmanager
+import numpy as np
+import pytest
+
+from skimage._shared._dependency_checks import has_mpl
+from skimage import io
+from skimage.io import manage_plugins
+
+
+priority_plugin = 'pil'
+
+
+@pytest.fixture(autouse=True)
+def _use_pil_plugin():
+    io.use_plugin('pil')
+    yield
+    io.reset_plugins()
+
+
+@contextmanager
+def protect_preferred_plugins():
+    """Contexts where `preferred_plugins` can be modified w/o side-effects."""
+    preferred_plugins = manage_plugins.preferred_plugins.copy()
+    try:
+        yield
+    finally:
+        manage_plugins.preferred_plugins = preferred_plugins
+
+
+def test_failed_use():
+    with pytest.raises(ValueError):
+        manage_plugins.use_plugin('asd')
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_use_priority():
+    manage_plugins.use_plugin(priority_plugin)
+    plug, func = manage_plugins.plugin_store['imread'][0]
+    np.testing.assert_equal(plug, priority_plugin)
+
+    manage_plugins.use_plugin('matplotlib')
+    plug, func = manage_plugins.plugin_store['imread'][0]
+    np.testing.assert_equal(plug, 'matplotlib')
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_load_preferred_plugins_all():
+    from skimage.io._plugins import pil_plugin, matplotlib_plugin
+
+    with protect_preferred_plugins():
+        manage_plugins.preferred_plugins = {'all': ['pil'], 'imshow': ['matplotlib']}
+        manage_plugins.reset_plugins()
+
+        for plugin_type in ('imread', 'imsave'):
+            plug, func = manage_plugins.plugin_store[plugin_type][0]
+            assert func == getattr(pil_plugin, plugin_type)
+        plug, func = manage_plugins.plugin_store['imshow'][0]
+        assert func == getattr(matplotlib_plugin, 'imshow')
+
+
+@pytest.mark.skipif(not has_mpl, reason="matplotlib not installed")
+def test_load_preferred_plugins_imread():
+    from skimage.io._plugins import pil_plugin, matplotlib_plugin
+
+    with protect_preferred_plugins():
+        manage_plugins.preferred_plugins['imread'] = ['pil']
+        manage_plugins.reset_plugins()
+
+        plug, func = manage_plugins.plugin_store['imread'][0]
+        assert func == pil_plugin.imread
+        plug, func = manage_plugins.plugin_store['imshow'][0]
+        assert func == matplotlib_plugin.imshow, func.__module__

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_sift.py

@@ -0,0 +1,69 @@
+import os
+from tempfile import NamedTemporaryFile
+
+from skimage.io import load_sift, load_surf
+
+from skimage._shared.testing import assert_equal
+
+
+def test_load_sift():
+    with NamedTemporaryFile(delete=False) as f:
+        fname = f.name
+
+    with open(fname, 'wb') as f:
+        f.write(
+            b'''2 128
+    133.92 135.88 14.38 -2.732
+    3 12 23 38 10 15 78 20 39 67 42 8 12 8 39 35 118 43 17 0
+    0 1 12 109 9 2 6 0 0 21 46 22 14 18 51 19 5 9 41 52
+    65 30 3 21 55 49 26 30 118 118 25 12 8 3 2 60 53 56 72 20
+    7 10 16 7 88 23 13 15 12 11 11 71 45 7 4 49 82 38 38 91
+    118 15 2 16 33 3 5 118 98 38 6 19 36 1 0 15 64 22 1 2
+    6 11 18 61 31 3 0 6 15 23 118 118 13 0 0 35 38 18 40 96
+    24 1 0 13 17 3 24 98
+    132.36 99.75 11.45 -2.910
+    94 32 7 2 13 7 5 23 121 94 13 5 0 0 4 59 13 30 71 32
+    0 6 32 11 25 32 13 0 0 16 51 5 44 50 0 3 33 55 11 9
+    121 121 12 9 6 3 0 18 55 60 48 44 44 9 0 2 106 117 13 2
+    1 0 1 1 37 1 1 25 80 35 15 41 121 3 0 2 14 3 2 121
+    51 11 0 20 93 6 0 20 109 57 3 4 5 0 0 28 21 2 0 5
+    13 12 75 119 35 0 0 13 28 14 37 121 12 0 0 21 46 5 11 93
+    29 0 0 3 14 4 11 99'''
+        )
+
+    # Check whether loading by filename works
+    load_sift(fname)
+
+    with open(fname) as f:
+        features = load_sift(f)
+    os.remove(fname)
+
+    assert_equal(len(features), 2)
+    assert_equal(len(features['data'][0]), 128)
+    assert_equal(features['row'][0], 133.92)
+    assert_equal(features['column'][1], 99.75)
+
+
+def test_load_surf():
+    with NamedTemporaryFile(delete=False) as f:
+        fname = f.name
+
+    with open(fname, 'wb') as f:
+        f.write(
+            b'''65
+2
+38.3727 62.0491 0.0371343 0 0.0371343 -1 -0.0705589 0.0130983 -0.00460534 0.132168 -0.0718833 0.0320583 -0.0134032 0.0988654 -0.0542241 0.0171002 -0.00135754 0.105755 -0.0362088 0.0151748 -0.00694272 0.0610017 -0.247091 0.109605 -0.0337623 0.0813307 -0.24185 0.278548 -0.0494523 0.107804 -0.166312 0.0691584 -0.0288199 0.138476 -0.110956 0.0280772 -0.0752509 0.0736344 -0.22667 0.164226 -0.0544717 0.0388139 -0.30194 0.33065 -0.0537507 0.0596398 -0.245395 0.110925 -0.0603322 0.0239389 -0.18726 0.0374145 -0.0355872 0.0140762 -0.129022 0.135104 -0.0703396 0.0374049 -0.24256 0.222544 -0.0536354 0.0501252 -0.209004 0.0971316 -0.0550094 0.0229767 -0.125547 0.0317879 -0.0291574 0.0124569
+68.5773 61.474 0.0313267 0 0.0313267 1 -0.10198 0.130987 -0.0321845 0.0487543 -0.0900435 0.121113 -0.100917 0.0444702 -0.0151742 0.107604 -0.0542035 0.014069 -0.00594097 0.0339933 -0.00994295 0.0127262 -0.125613 0.192551 -0.0174399 0.0433488 -0.272698 0.164641 -0.0676735 0.0467444 -0.0527907 0.258005 -0.0818114 0.0440569 -0.0104433 0.0548934 -0.0323454 0.0145296 -0.112357 0.199223 -0.0532903 0.0332622 -0.342481 0.207469 -0.0526129 0.0741355 -0.256234 0.402708 -0.108296 0.117362 -0.0560274 0.128856 -0.123509 0.0510046 -0.0198793 0.0775934 -0.103863 0.00406679 -0.10264 0.1312 -0.108244 0.0812913 -0.127868 0.182924 -0.0680942 0.071913 -0.0858004 0.144806 -0.0176522 0.0686146'''
+        )
+
+    # Check whether loading by filename works
+    load_surf(fname)
+
+    with open(fname) as f:
+        features = load_surf(f)
+    os.remove(fname)
+
+    assert_equal(len(features), 2)
+    assert_equal(len(features['data'][0]), 64)
+    assert_equal(features['column'][1], 68.5773)
+    assert_equal(features['row'][0], 62.0491)

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_simpleitk.py

@@ -0,0 +1,84 @@
+import numpy as np
+import pytest
+
+from skimage.io import imread, imsave, use_plugin, reset_plugins, plugin_order
+from skimage._shared import testing
+
+
+pytest.importorskip('SimpleITK')
+
+
+@pytest.fixture(autouse=True)
+def use_simpleitk_plugin():
+    """Ensure that SimpleITK plugin is used."""
+    use_plugin('simpleitk')
+    yield
+    reset_plugins()
+
+
+def test_prefered_plugin():
+    order = plugin_order()
+    assert order["imread"][0] == "simpleitk"
+    assert order["imsave"][0] == "simpleitk"
+    assert order["imread_collection"][0] == "simpleitk"
+
+
+def test_imread_as_gray():
+    img = imread(testing.fetch('data/color.png'), as_gray=True)
+    assert img.ndim == 2
+    assert img.dtype == np.float64
+    img = imread(testing.fetch('data/camera.png'), as_gray=True)
+    # check that conversion does not happen for a gray image
+    assert np.dtype(img.dtype).char in np.typecodes['AllInteger']
+
+
+def test_bilevel():
+    expected = np.zeros((10, 10))
+    expected[::2] = 255
+
+    img = imread(testing.fetch('data/checker_bilevel.png'))
+    np.testing.assert_array_equal(img, expected)
+
+
+def test_imread_truncated_jpg():
+    with pytest.raises(RuntimeError):
+        imread(testing.fetch('data/truncated.jpg'))
+
+
+def test_imread_uint16():
+    expected = np.load(testing.fetch('data/chessboard_GRAY_U8.npy'))
+    img = imread(testing.fetch('data/chessboard_GRAY_U16.tif'))
+    assert np.issubdtype(img.dtype, np.uint16)
+    np.testing.assert_array_almost_equal(img, expected)
+
+
+def test_imread_uint16_big_endian():
+    expected = np.load(testing.fetch('data/chessboard_GRAY_U8.npy'))
+    img = imread(testing.fetch('data/chessboard_GRAY_U16B.tif'), plugin="simpleitk")
+    assert img.dtype.type == np.uint16
+    np.testing.assert_array_almost_equal(img, expected)
+
+
+@pytest.mark.parametrize("shape", [(10, 10), (10, 10, 3), (10, 10, 4)])
+@pytest.mark.parametrize("dtype", [np.uint8, np.uint16, np.float32, np.float64])
+# Neither NumPy's linspace nor called functions in our color module can
+# really deal with the max and min value supported by float64. As we might
+# deprecate this plugin system soon, just ignore it.
+@pytest.mark.filterwarnings("default")
+def test_imsave_roundtrip(shape, dtype, tmp_path):
+    if np.issubdtype(dtype, np.floating):
+        info_func = np.finfo
+    else:
+        info_func = np.iinfo
+    expected = np.linspace(
+        info_func(dtype).min,
+        info_func(dtype).max,
+        endpoint=True,
+        num=np.prod(shape),
+        dtype=dtype,
+    )
+    expected = expected.reshape(shape)
+    file_path = tmp_path / "roundtrip.mha"
+    imsave(file_path, expected)
+    actual = imread(file_path)
+    np.testing.assert_array_almost_equal(actual, expected)

.CondaPkg/env/Lib/site-packages/skimage/io/tests/test_tifffile.py

@@ -0,0 +1,83 @@
+import pathlib
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_almost_equal, assert_array_equal
+from skimage._shared.testing import fetch
+from skimage.io import imread, imsave, reset_plugins, use_plugin
+
+
+@pytest.fixture(autouse=True)
+def _use_tifffile_plugin():
+    """Ensure that PIL plugin is used in tests here."""
+    use_plugin('tifffile')
+    np.random.seed(0)
+    yield
+    reset_plugins()
+
+
+def test_imread_uint16():
+    expected = np.load(fetch('data/chessboard_GRAY_U8.npy'))
+    img = imread(fetch('data/chessboard_GRAY_U16.tif'))
+    assert img.dtype == np.uint16
+    assert_array_almost_equal(img, expected)
+
+
+def test_imread_uint16_big_endian():
+    expected = np.load(fetch('data/chessboard_GRAY_U8.npy'))
+    img = imread(fetch('data/chessboard_GRAY_U16B.tif'))
+    assert img.dtype.type == np.uint16
+    assert_array_almost_equal(img, expected)
+
+
+def test_imread_multipage_rgb_tif():
+    img = imread(fetch('data/multipage_rgb.tif'))
+    assert img.shape == (2, 10, 10, 3), img.shape
+
+
+def test_tifffile_kwarg_passthrough():
+    img = imread(fetch('data/multipage.tif'), key=[1], is_ome=True)
+    assert img.shape == (15, 10), img.shape
+
+
+def test_imread_handle():
+    expected = np.load(fetch('data/chessboard_GRAY_U8.npy'))
+    with open(fetch('data/chessboard_GRAY_U16.tif'), 'rb') as fh:
+        img = imread(fh)
+    assert img.dtype == np.uint16
+    assert_array_almost_equal(img, expected)
+
+
+class TestSave:
+    def roundtrip(self, dtype, x, use_pathlib=False, **kwargs):
+        with NamedTemporaryFile(suffix='.tif') as f:
+            fname = f.name
+
+        if use_pathlib:
+            fname = pathlib.Path(fname)
+        imsave(fname, x, check_contrast=False, **kwargs)
+        y = imread(fname)
+        assert_array_equal(x, y)
+
+    shapes = ((10, 10), (10, 10, 3), (10, 10, 4))
+    dtypes = (np.uint8, np.uint16, np.float32, np.int16, np.float64)
+
+    @pytest.mark.parametrize("shape", shapes)
+    @pytest.mark.parametrize("dtype", dtypes)
+    @pytest.mark.parametrize("use_pathlib", [False, True])
+    @pytest.mark.parametrize('explicit_photometric_kwarg', [False, True])
+    def test_imsave_roundtrip(
+        self, shape, dtype, use_pathlib, explicit_photometric_kwarg
+    ):
+        x = np.random.rand(*shape)
+
+        if not np.issubdtype(dtype, np.floating):
+            x = (x * np.iinfo(dtype).max).astype(dtype)
+        else:
+            x = x.astype(dtype)
+        if explicit_photometric_kwarg and x.shape[-1] in [3, 4]:
+            kwargs = {'photometric': 'rgb'}
+        else:
+            kwargs = {}
+        self.roundtrip(dtype, x, use_pathlib, **kwargs)

.CondaPkg/env/Lib/site-packages/skimage/io/util.py

@@ -0,0 +1,41 @@
+import urllib.parse
+import urllib.request
+from urllib.error import URLError, HTTPError
+
+import os
+import re
+import tempfile
+from contextlib import contextmanager
+
+
+URL_REGEX = re.compile(r'http://|https://|ftp://|file://|file:\\')
+
+
+def is_url(filename):
+    """Return True if string is an http or ftp path."""
+    return isinstance(filename, str) and URL_REGEX.match(filename) is not None
+
+
+@contextmanager
+def file_or_url_context(resource_name):
+    """Yield name of file from the given resource (i.e. file or url)."""
+    if is_url(resource_name):
+        url_components = urllib.parse.urlparse(resource_name)
+        _, ext = os.path.splitext(url_components.path)
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=ext) as f:
+                with urllib.request.urlopen(resource_name) as u:
+                    f.write(u.read())
+            # f must be closed before yielding
+            yield f.name
+        except (URLError, HTTPError):
+            # could not open URL
+            os.remove(f.name)
+            raise
+        except (FileNotFoundError, FileExistsError, PermissionError, BaseException):
+            # could not create temporary file
+            raise
+        else:
+            os.remove(f.name)
+    else:
+        yield resource_name