Add files using upload-large-folder tool

README.md

@@ -0,0 +1,20 @@
+---
+license: other
+license_name: nvidia-proprietary-software-license
+license_link: https://docs.nvidia.com/cuda/eula/index.html
+pretty_name: Simulation runtime (the third-party half of the AVSim data generation package)
+---
+
+# Simulation runtime: the third-party half of the AVSim data generation package
+
+This repository holds the third-party runtime of the Simulation data generation package, version 3: the pieces the pipeline needs that were not written by the authors. It contains no code and no data of the authors. It is not usable on its own: the private half of the package, AVSim/simulation, downloads this repository into the same directory at a pinned revision with its `fetch_runtime.sh` script and verifies it against `MANIFEST.runtime.sha256`.
+
+Contents:
+- `sifs/isaac.sif`: the render container, NVIDIA Isaac Sim 5.1 with its Omniverse Kit runtime and the python packages of the kit process.
+- `toolchain/`: the NVIDIA CUDA 12.6.3 toolkit installer, a rootless Apptainer installation, a standalone CPython 3.11, CMake 3.27.9.
+- `omniverse_mirror/` and `materials/`: mirrors of NVIDIA Omniverse content (Isaac Sim environments and SimReady props) and the MDL materials they reference; every mirror carries its `mirror_manifest.json` with the upstream source.
+- `code/third_party/omniverse_assets/` and `code/third_party/vMaterials_2/`: NVIDIA Omniverse assets and the NVIDIA vMaterials 2 library, at the paths the code tree expects.
+- `code/src/simulation/assets/sources/<id>/source/` and `store_v2/<id>/source/`: the object source meshes extracted from the mirrored NVIDIA assets and from the YCB object set.
+- `envs/`: the python packages injected into the kit process, static builds of ffmpeg and ffprobe, a cmake wrapper, the pip freeze of the host-side environment; `wheels/`: the host-side python packages; `vendor/`: Eigen and libigl for the offline solver build.
+
+License: the components keep the licenses of their upstreams (NVIDIA Software License Agreement and NVIDIA CUDA End User License Agreement for the container, the toolkit and the vMaterials library; the NVIDIA Omniverse asset terms for the mirrored content; CC BY 4.0 for the YCB objects; BSD, MIT, PSF, MPL 2.0, LGPL and GPL for the open-source tools and packages). The most restrictive of them, the NVIDIA proprietary software license, governs this repository as a whole.

envs/kitoverlay/lazy_loader/__init__.py

@@ -0,0 +1,342 @@
+"""
+lazy_loader
+===========
+
+Makes it easy to load subpackages and functions on demand.
+"""
+
+import ast
+import importlib
+import importlib.util
+import os
+import sys
+import threading
+import types
+import warnings
+
+__version__ = "0.5"
+__all__ = ["attach", "attach_stub", "load"]
+
+
+threadlock = threading.Lock()
+
+
+def attach(package_name, submodules=None, submod_attrs=None):
+    """Attach lazily loaded submodules, functions, or other attributes.
+
+    Typically, modules import submodules and attributes as follows::
+
+      import mysubmodule
+      import anothersubmodule
+
+      from .foo import someattr
+
+    The idea is to replace a package's `__getattr__`, `__dir__`, and
+    `__all__`, such that all imports work exactly the way they would
+    with normal imports, except that the import occurs upon first use.
+
+    The typical way to call this function, replacing the above imports, is::
+
+      __getattr__, __dir__, __all__ = lazy.attach(
+          __name__, ["mysubmodule", "anothersubmodule"], {"foo": ["someattr"]}
+      )
+
+    Parameters
+    ----------
+    package_name : str
+        Typically use ``__name__``.
+    submodules : set
+        List of submodules to attach.
+    submod_attrs : dict
+        Dictionary of submodule -> list of attributes / functions.
+        These attributes are imported as they are used.
+
+    Returns
+    -------
+    __getattr__, __dir__, __all__
+
+    """
+    if submod_attrs is None:
+        submod_attrs = {}
+
+    if submodules is None:
+        submodules = set()
+    else:
+        submodules = set(submodules)
+
+    attr_to_modules = {
+        attr: mod for mod, attrs in submod_attrs.items() for attr in attrs
+    }
+
+    __all__ = sorted(submodules | attr_to_modules.keys())
+
+    def __getattr__(name):
+        if name in submodules:
+            return importlib.import_module(f"{package_name}.{name}")
+        elif name in attr_to_modules:
+            submod_path = f"{package_name}.{attr_to_modules[name]}"
+            submod = importlib.import_module(submod_path)
+            attr = getattr(submod, name)
+
+            # If the attribute lives in a file (module) with the same
+            # name as the attribute, ensure that the attribute and *not*
+            # the module is accessible on the package.
+            if name == attr_to_modules[name]:
+                pkg = sys.modules[package_name]
+                pkg.__dict__[name] = attr
+
+            return attr
+        else:
+            raise AttributeError(f"No {package_name} attribute {name}")
+
+    def __dir__():
+        return __all__.copy()
+
+    eager_import = os.environ.get("EAGER_IMPORT", "") not in ("0", "")
+    if eager_import:
+        for attr in set(attr_to_modules.keys()) | submodules:
+            __getattr__(attr)
+
+    return __getattr__, __dir__, __all__.copy()
+
+
+class DelayedImportErrorModule(types.ModuleType):
+    def __init__(self, frame_data, *args, message, **kwargs):
+        self.__frame_data = frame_data
+        self.__message = message
+        super().__init__(*args, **kwargs)
+
+    def __getattr__(self, x):
+        fd = self.__frame_data
+        raise ModuleNotFoundError(
+            f"{self.__message}\n\n"
+            "This error is lazily reported, having originally occurred in\n"
+            f"  File {fd['filename']}, line {fd['lineno']}, in {fd['function']}\n\n"
+            f"----> {''.join(fd['code_context'] or '').strip()}"
+        )
+
+
+def load(fullname, *, require=None, error_on_import=False, suppress_warning=False):
+    """Return a lazily imported proxy for a module.
+
+    We often see the following pattern::
+
+      def myfunc():
+          import numpy as np
+          np.norm(...)
+          ....
+
+    Putting the import inside the function prevents, in this case,
+    `numpy`, from being imported at function definition time.
+    That saves time if `myfunc` ends up not being called.
+
+    This `load` function returns a proxy module that, upon access, imports
+    the actual module.  So the idiom equivalent to the above example is::
+
+      np = lazy.load("numpy")
+
+      def myfunc():
+          np.norm(...)
+          ....
+
+    The initial import time is fast because the actual import is delayed
+    until the first attribute is requested. The overall import time may
+    decrease as well for users that don't make use of large portions
+    of your library.
+
+    Warning
+    -------
+    While lazily loading *sub*packages technically works, it causes the
+    package (that contains the subpackage) to be eagerly loaded even
+    if the package is already lazily loaded.
+    So, you probably shouldn't use subpackages with this `load` feature.
+    Instead you should encourage the package maintainers to use the
+    `lazy_loader.attach` to make their subpackages load lazily.
+
+    Parameters
+    ----------
+    fullname : str
+        The full name of the module or submodule to import.  For example::
+
+          sp = lazy.load("scipy")  # import scipy as sp
+
+    require : str
+        A dependency requirement as defined in PEP-508.  For example::
+
+          "numpy >=1.24"
+
+        If defined, the proxy module will raise an error if the installed
+        version does not satisfy the requirement.
+
+    error_on_import : bool
+        Whether to postpone raising import errors until the module is accessed.
+        If set to `True`, import errors are raised as soon as `load` is called.
+
+    suppress_warning : bool
+        Whether to prevent emitting a warning when loading subpackages.
+        If set to `True`, no warning will occur.
+
+    Returns
+    -------
+    pm : importlib.util._LazyModule
+        Proxy module.  Can be used like any regularly imported module.
+        Actual loading of the module occurs upon first attribute request.
+
+    """
+    with threadlock:
+        module = sys.modules.get(fullname)
+        have_module = module is not None
+
+        # Most common, short-circuit
+        if have_module and require is None:
+            return module
+
+        if not suppress_warning and "." in fullname:
+            msg = (
+                "subpackages can technically be lazily loaded, but it causes the "
+                "package to be eagerly loaded even if it is already lazily loaded. "
+                "So, you probably shouldn't use subpackages with this lazy feature."
+            )
+            warnings.warn(msg, RuntimeWarning)
+
+        spec = None
+
+        if not have_module:
+            spec = importlib.util.find_spec(fullname)
+            have_module = spec is not None
+
+        if not have_module:
+            not_found_message = f"No module named '{fullname}'"
+        elif require is not None:
+            try:
+                have_module = _check_requirement(require)
+            except ModuleNotFoundError as e:
+                raise ValueError(
+                    f"Found module '{fullname}' but cannot test "
+                    "requirement '{require}'. "
+                    "Requirements must match distribution name, not module name."
+                ) from e
+
+            not_found_message = f"No distribution can be found matching '{require}'"
+
+        if not have_module:
+            if error_on_import:
+                raise ModuleNotFoundError(not_found_message)
+            import inspect
+
+            parent = inspect.stack()[1]
+            frame_data = {
+                "filename": parent.filename,
+                "lineno": parent.lineno,
+                "function": parent.function,
+                "code_context": parent.code_context,
+            }
+            del parent
+            return DelayedImportErrorModule(
+                frame_data,
+                "DelayedImportErrorModule",
+                message=not_found_message,
+            )
+
+        if spec is not None:
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[fullname] = module
+
+            loader = importlib.util.LazyLoader(spec.loader)
+            loader.exec_module(module)
+
+    return module
+
+
+def _check_requirement(require: str) -> bool:
+    """Verify that a package requirement is satisfied
+
+    If the package is required, a ``ModuleNotFoundError`` is raised
+    by ``importlib.metadata``.
+
+    Parameters
+    ----------
+    require : str
+        A dependency requirement as defined in PEP-508
+
+    Returns
+    -------
+    satisfied : bool
+        True if the installed version of the dependency matches
+        the specified version, False otherwise.
+    """
+    import importlib.metadata
+
+    import packaging.requirements
+
+    req = packaging.requirements.Requirement(require)
+    return req.specifier.contains(
+        importlib.metadata.version(req.name),
+        prereleases=True,
+    )
+
+
+class _StubVisitor(ast.NodeVisitor):
+    """AST visitor to parse a stub file for submodules and submod_attrs."""
+
+    def __init__(self):
+        self._submodules = set()
+        self._submod_attrs = {}
+
+    def visit_ImportFrom(self, node: ast.ImportFrom):
+        if node.level != 1:
+            raise ValueError(
+                "Only within-module imports are supported (`from .* import`)"
+            )
+        if node.module:
+            attrs: list = self._submod_attrs.setdefault(node.module, [])
+            aliases = [alias.name for alias in node.names]
+            if "*" in aliases:
+                raise ValueError(
+                    "lazy stub loader does not support star import "
+                    f"`from {node.module} import *`"
+                )
+            attrs.extend(aliases)
+        else:
+            self._submodules.update(alias.name for alias in node.names)
+
+
+def attach_stub(package_name: str, filename: str):
+    """Attach lazily loaded submodules, functions from a type stub.
+
+    This is a variant on ``attach`` that will parse a `.pyi` stub file to
+    infer ``submodules`` and ``submod_attrs``. This allows static type checkers
+    to find imports, while still providing lazy loading at runtime.
+
+    Parameters
+    ----------
+    package_name : str
+        Typically use ``__name__``.
+    filename : str
+        Path to `.py` file which has an adjacent `.pyi` file.
+        Typically use ``__file__``.
+
+    Returns
+    -------
+    __getattr__, __dir__, __all__
+        The same output as ``attach``.
+
+    Raises
+    ------
+    ValueError
+        If a stub file is not found for `filename`, or if the stubfile is formmated
+        incorrectly (e.g. if it contains an relative import from outside of the module)
+    """
+    stubfile = (
+        filename if filename.endswith("i") else f"{os.path.splitext(filename)[0]}.pyi"
+    )
+
+    if not os.path.exists(stubfile):
+        raise ValueError(f"Cannot load imports from non-existent stub {stubfile!r}")
+
+    with open(stubfile) as f:
+        stub_node = ast.parse(f.read())
+
+    visitor = _StubVisitor()
+    visitor.visit(stub_node)
+    return attach(package_name, visitor._submodules, visitor._submod_attrs)

envs/kitoverlay/scikit_image-0.26.0.dist-info/INSTALLER

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

envs/kitoverlay/scikit_image-0.26.0.dist-info/LICENSE.txt

@@ -0,0 +1,152 @@
+Files: *
+Copyright: 2009-2022 the scikit-image team
+License: BSD-3-Clause
+
+Files: doc/source/themes/scikit-image/layout.html
+Copyright: 2007-2010 the Sphinx team
+License: BSD-3-Clause
+
+Files: skimage/feature/_canny.py
+       skimage/filters/edges.py
+       skimage/filters/_rank_order.py
+       skimage/morphology/_skeletonize.py
+       skimage/morphology/tests/test_watershed.py
+       skimage/morphology/watershed.py
+       skimage/segmentation/heap_general.pxi
+       skimage/segmentation/heap_watershed.pxi
+       skimage/segmentation/_watershed.py
+       skimage/segmentation/_watershed_cy.pyx
+Copyright: 2003-2009 Massachusetts Institute of Technology
+           2009-2011 Broad Institute
+           2003 Lee Kamentsky
+           2003-2005 Peter J. Verveer
+License: BSD-3-Clause
+
+Files: skimage/filters/thresholding.py
+       skimage/graph/_mcp.pyx
+       skimage/graph/heap.pyx
+Copyright: 2009-2015 Board of Regents of the University of
+           Wisconsin-Madison, Broad Institute of MIT and Harvard,
+           and Max Planck Institute of Molecular Cell Biology and
+           Genetics
+           2009 Zachary Pincus
+           2009 Almar Klein
+License: BSD-2-Clause
+
+File: skimage/morphology/grayreconstruct.py
+      skimage/morphology/tests/test_reconstruction.py
+Copyright: 2003-2009 Massachusetts Institute of Technology
+           2009-2011 Broad Institute
+           2003 Lee Kamentsky
+License: BSD-3-Clause
+
+File: skimage/morphology/_grayreconstruct.pyx
+Copyright: 2003-2009 Massachusetts Institute of Technology
+           2009-2011 Broad Institute
+           2003 Lee Kamentsky
+           2022 Gregory Lee (added a 64-bit integer variant for large images)
+License: BSD-3-Clause
+
+File: skimage/segmentation/_expand_labels.py
+Copyright: 2020 Broad Institute
+           2020 CellProfiler team
+License: BSD-3-Clause
+
+File: skimage/exposure/_adapthist.py
+Copyright: 1994 Karel Zuiderveld
+License: BSD-3-Clause
+
+Function: skimage/morphology/_skeletonize_various_cy.pyx:_skeletonize_loop
+Copyright: 2003-2009 Massachusetts Institute of Technology
+           2009-2011 Broad Institute
+           2003 Lee Kamentsky
+License: BSD-3-Clause
+
+Function: skimage/_shared/version_requirements.py:_check_version
+Copyright: 2013 The IPython Development Team
+License: BSD-3-Clause
+
+Function: skimage/_shared/version_requirements.py:is_installed
+Copyright: 2009-2011 Pierre Raybaut
+License: MIT
+
+File: skimage/feature/_fisher_vector.py
+Copyright: 2014 2014 Dan Oneata
+License: MIT
+
+File: skimage/_vendored/numpy_lookfor.py
+Copyright: 2005-2023, NumPy Developers
+License: BSD-3-Clause
+
+File: skimage/transform/_thin_plate_splines.py
+Copyright: 2007 Zachary Pincus
+License: BSD-3-Clause
+
+License: BSD-2-Clause
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE HOLDERS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+License: BSD-3-Clause
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the University nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE HOLDERS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+License: MIT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

envs/kitoverlay/scikit_image-0.26.0.dist-info/METADATA

@@ -0,0 +1,286 @@
+Metadata-Version: 2.1
+Name: scikit-image
+Version: 0.26.0
+Summary: Image processing in Python
+Maintainer-Email: scikit-image developers <skimage-core@discuss.scientific-python.org>
+License: Files: *
+         Copyright: 2009-2022 the scikit-image team
+         License: BSD-3-Clause
+         
+         Files: doc/source/themes/scikit-image/layout.html
+         Copyright: 2007-2010 the Sphinx team
+         License: BSD-3-Clause
+         
+         Files: skimage/feature/_canny.py
+                skimage/filters/edges.py
+                skimage/filters/_rank_order.py
+                skimage/morphology/_skeletonize.py
+                skimage/morphology/tests/test_watershed.py
+                skimage/morphology/watershed.py
+                skimage/segmentation/heap_general.pxi
+                skimage/segmentation/heap_watershed.pxi
+                skimage/segmentation/_watershed.py
+                skimage/segmentation/_watershed_cy.pyx
+         Copyright: 2003-2009 Massachusetts Institute of Technology
+                    2009-2011 Broad Institute
+                    2003 Lee Kamentsky
+                    2003-2005 Peter J. Verveer
+         License: BSD-3-Clause
+         
+         Files: skimage/filters/thresholding.py
+                skimage/graph/_mcp.pyx
+                skimage/graph/heap.pyx
+         Copyright: 2009-2015 Board of Regents of the University of
+                    Wisconsin-Madison, Broad Institute of MIT and Harvard,
+                    and Max Planck Institute of Molecular Cell Biology and
+                    Genetics
+                    2009 Zachary Pincus
+                    2009 Almar Klein
+         License: BSD-2-Clause
+         
+         File: skimage/morphology/grayreconstruct.py
+               skimage/morphology/tests/test_reconstruction.py
+         Copyright: 2003-2009 Massachusetts Institute of Technology
+                    2009-2011 Broad Institute
+                    2003 Lee Kamentsky
+         License: BSD-3-Clause
+         
+         File: skimage/morphology/_grayreconstruct.pyx
+         Copyright: 2003-2009 Massachusetts Institute of Technology
+                    2009-2011 Broad Institute
+                    2003 Lee Kamentsky
+                    2022 Gregory Lee (added a 64-bit integer variant for large images)
+         License: BSD-3-Clause
+         
+         File: skimage/segmentation/_expand_labels.py
+         Copyright: 2020 Broad Institute
+                    2020 CellProfiler team
+         License: BSD-3-Clause
+         
+         File: skimage/exposure/_adapthist.py
+         Copyright: 1994 Karel Zuiderveld
+         License: BSD-3-Clause
+         
+         Function: skimage/morphology/_skeletonize_various_cy.pyx:_skeletonize_loop
+         Copyright: 2003-2009 Massachusetts Institute of Technology
+                    2009-2011 Broad Institute
+                    2003 Lee Kamentsky
+         License: BSD-3-Clause
+         
+         Function: skimage/_shared/version_requirements.py:_check_version
+         Copyright: 2013 The IPython Development Team
+         License: BSD-3-Clause
+         
+         Function: skimage/_shared/version_requirements.py:is_installed
+         Copyright: 2009-2011 Pierre Raybaut
+         License: MIT
+         
+         File: skimage/feature/_fisher_vector.py
+         Copyright: 2014 2014 Dan Oneata
+         License: MIT
+         
+         File: skimage/_vendored/numpy_lookfor.py
+         Copyright: 2005-2023, NumPy Developers
+         License: BSD-3-Clause
+         
+         File: skimage/transform/_thin_plate_splines.py
+         Copyright: 2007 Zachary Pincus
+         License: BSD-3-Clause
+         
+         License: BSD-2-Clause
+         
+         Redistribution and use in source and binary forms, with or without
+         modification, are permitted provided that the following conditions
+         are met:
+         1. Redistributions of source code must retain the above copyright
+            notice, this list of conditions and the following disclaimer.
+         2. Redistributions in binary form must reproduce the above copyright
+            notice, this list of conditions and the following disclaimer in the
+            documentation and/or other materials provided with the distribution.
+         .
+         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+         ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE HOLDERS OR
+         CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+         EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+         PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+         PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+         LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+         NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+         SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         
+         License: BSD-3-Clause
+         
+         Redistribution and use in source and binary forms, with or without
+         modification, are permitted provided that the following conditions
+         are met:
+         1. Redistributions of source code must retain the above copyright
+            notice, this list of conditions and the following disclaimer.
+         2. Redistributions in binary form must reproduce the above copyright
+            notice, this list of conditions and the following disclaimer in the
+            documentation and/or other materials provided with the distribution.
+         3. Neither the name of the University nor the names of its contributors
+            may be used to endorse or promote products derived from this software
+            without specific prior written permission.
+         .
+         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+         ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE HOLDERS OR
+         CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+         EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+         PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+         PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+         LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+         NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+         SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         
+         License: MIT
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+         
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Project-URL: homepage, https://scikit-image.org
+Project-URL: documentation, https://scikit-image.org/docs/stable
+Project-URL: source, https://github.com/scikit-image/scikit-image
+Project-URL: download, https://pypi.org/project/scikit-image/#files
+Project-URL: tracker, https://github.com/scikit-image/scikit-image/issues
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.11.4
+Requires-Dist: networkx>=3.0
+Requires-Dist: pillow>=10.1
+Requires-Dist: imageio!=2.35.0,>=2.33
+Requires-Dist: tifffile>=2022.8.12
+Requires-Dist: packaging>=21
+Requires-Dist: lazy-loader>=0.4
+Provides-Extra: build
+Requires-Dist: meson-python>=0.16; extra == "build"
+Requires-Dist: ninja>=1.11.1.1; extra == "build"
+Requires-Dist: Cython!=3.2.0b1,>=3.0.8; extra == "build"
+Requires-Dist: pythran>=0.16; extra == "build"
+Requires-Dist: numpy>=2.0; extra == "build"
+Requires-Dist: spin==0.13; extra == "build"
+Requires-Dist: build>=1.2.1; extra == "build"
+Provides-Extra: data
+Requires-Dist: pooch>=1.6.0; extra == "data"
+Provides-Extra: developer
+Requires-Dist: pre-commit; extra == "developer"
+Requires-Dist: ipython; extra == "developer"
+Requires-Dist: docstub==0.3.0.post0; extra == "developer"
+Requires-Dist: scikit-image[asv]; extra == "developer"
+Provides-Extra: asv
+Requires-Dist: asv; sys_platform != "emscripten" and extra == "asv"
+Provides-Extra: docs
+Requires-Dist: sphinx>=8.0; extra == "docs"
+Requires-Dist: sphinx-gallery[parallel]>=0.18; extra == "docs"
+Requires-Dist: numpydoc>=1.7; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: matplotlib>=3.7; extra == "docs"
+Requires-Dist: dask[array]>=2023.2.0; extra == "docs"
+Requires-Dist: pandas>=2.0; extra == "docs"
+Requires-Dist: seaborn>=0.11; extra == "docs"
+Requires-Dist: pooch>=1.6; extra == "docs"
+Requires-Dist: tifffile>=2022.8.12; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: intersphinx-registry>=0.2411.14; extra == "docs"
+Requires-Dist: ipywidgets; extra == "docs"
+Requires-Dist: ipykernel; extra == "docs"
+Requires-Dist: plotly>=5.20; extra == "docs"
+Requires-Dist: kaleido==0.2.1; extra == "docs"
+Requires-Dist: scikit-learn>=1.2; extra == "docs"
+Requires-Dist: sphinx_design>=0.5; extra == "docs"
+Requires-Dist: pydata-sphinx-theme>=0.16; extra == "docs"
+Requires-Dist: PyWavelets>=1.6; extra == "docs"
+Requires-Dist: pytest-doctestplus>=1.6.0; extra == "docs"
+Provides-Extra: optional
+Requires-Dist: SimpleITK; sys_platform != "emscripten" and extra == "optional"
+Requires-Dist: scikit-learn>=1.2; extra == "optional"
+Requires-Dist: pyamg>=5.2; sys_platform != "emscripten" and python_version < "3.14" and extra == "optional"
+Requires-Dist: scikit-image[optional_free_threaded]; extra == "optional"
+Provides-Extra: optional-free-threaded
+Requires-Dist: astropy>=6.0; extra == "optional-free-threaded"
+Requires-Dist: dask[array]>=2023.2.0; extra == "optional-free-threaded"
+Requires-Dist: matplotlib>=3.7; extra == "optional-free-threaded"
+Requires-Dist: pooch>=1.6.0; sys_platform != "emscripten" and extra == "optional-free-threaded"
+Requires-Dist: PyWavelets>=1.6; extra == "optional-free-threaded"
+Provides-Extra: test
+Requires-Dist: numpydoc>=1.7; extra == "test"
+Requires-Dist: pooch>=1.6.0; sys_platform != "emscripten" and extra == "test"
+Requires-Dist: pytest>=8.3; extra == "test"
+Requires-Dist: pytest-cov>=2.11.0; extra == "test"
+Requires-Dist: pytest-pretty; extra == "test"
+Requires-Dist: pytest-localserver; extra == "test"
+Requires-Dist: pytest-faulthandler; extra == "test"
+Requires-Dist: pytest-doctestplus>=1.6.0; extra == "test"
+Description-Content-Type: text/markdown
+
+# scikit-image: Image processing in Python
+
+[![Image.sc forum](https://img.shields.io/badge/dynamic/json.svg?label=forum&url=https%3A%2F%2Fforum.image.sc%2Ftags%2Fscikit-image.json&query=%24.topic_list.tags.0.topic_count&colorB=brightgreen&suffix=%20topics&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAABPklEQVR42m3SyyqFURTA8Y2BER0TDyExZ+aSPIKUlPIITFzKeQWXwhBlQrmFgUzMMFLKZeguBu5y+//17dP3nc5vuPdee6299gohUYYaDGOyyACq4JmQVoFujOMR77hNfOAGM+hBOQqB9TjHD36xhAa04RCuuXeKOvwHVWIKL9jCK2bRiV284QgL8MwEjAneeo9VNOEaBhzALGtoRy02cIcWhE34jj5YxgW+E5Z4iTPkMYpPLCNY3hdOYEfNbKYdmNngZ1jyEzw7h7AIb3fRTQ95OAZ6yQpGYHMMtOTgouktYwxuXsHgWLLl+4x++Kx1FJrjLTagA77bTPvYgw1rRqY56e+w7GNYsqX6JfPwi7aR+Y5SA+BXtKIRfkfJAYgj14tpOF6+I46c4/cAM3UhM3JxyKsxiOIhH0IO6SH/A1Kb1WBeUjbkAAAAAElFTkSuQmCC)](https://forum.image.sc/tags/scikit-image)
+[![Stackoverflow](https://img.shields.io/badge/stackoverflow-Ask%20questions-blue.svg)](https://stackoverflow.com/questions/tagged/scikit-image)
+[![project chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://skimage.zulipchat.com)
+[![Scientific Python Ecosystem Coordination](https://img.shields.io/badge/SPEC-0,1,4,6,7,8-green?labelColor=%23004811&color=%235CA038)](https://scientific-python.org/specs/)
+[![LFX Health Score](https://insights.linuxfoundation.org/api/badge/health-score?project=scikit-image-scikit-image)](https://insights.linuxfoundation.org/project/scikit-image-scikit-image)
+
+- **Website (including documentation):** [https://scikit-image.org/](https://scikit-image.org)
+- **Documentation:** [https://scikit-image.org/docs/stable/](https://scikit-image.org/docs/stable/)
+- **User forum:** [https://forum.image.sc/tag/scikit-image](https://forum.image.sc/tag/scikit-image)
+- **Developer forum:** [https://discuss.scientific-python.org/c/contributor/skimage](https://discuss.scientific-python.org/c/contributor/skimage)
+- **Source:** [https://github.com/scikit-image/scikit-image](https://github.com/scikit-image/scikit-image)
+
+## Installation
+
+- **pip:** `pip install scikit-image`
+- **conda:** `conda install -c conda-forge scikit-image`
+
+Also see [installing `scikit-image`](https://github.com/scikit-image/scikit-image/blob/main/INSTALL.rst).
+
+## License
+
+See [LICENSE.txt](https://github.com/scikit-image/scikit-image/blob/main/LICENSE.txt).
+
+## Citation
+
+If you find this project useful, please cite:
+
+> Stéfan van der Walt, Johannes L. Schönberger, Juan Nunez-Iglesias,
+> François Boulogne, Joshua D. Warner, Neil Yager, Emmanuelle
+> Gouillart, Tony Yu, and the scikit-image contributors.
+> _scikit-image: Image processing in Python_. PeerJ 2:e453 (2014)
+> https://doi.org/10.7717/peerj.453

envs/kitoverlay/scikit_image-0.26.0.dist-info/RECORD

@@ -0,0 +1,501 @@
+scikit_image-0.26.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+scikit_image-0.26.0.dist-info/LICENSE.txt,sha256=YR0yB1BNy0qAjfIJ0ufJtPLon-aQ-Ec1wNVIFglmtSc,6435
+scikit_image-0.26.0.dist-info/METADATA,sha256=z13LPluagVtDJ8AiJa_Nhe3Va5D7vd3lvpRDUqWYZXE,15171
+scikit_image-0.26.0.dist-info/RECORD,,
+scikit_image-0.26.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scikit_image-0.26.0.dist-info/WHEEL,sha256=-PRFuKV2Mmc9_5cjuD-UNN7YLg4OyntAAjaeo6DTU3w,138
+skimage/__init__.py,sha256=5iDb9BuSunCc-mM8YBtjFtXwIlX-gO6QCgZjbquJ0HE,4107
+skimage/__init__.pyi,sha256=-q2FUJzv9v_H7mN2vSJuwDSZedVPCpVDUQQb4-sz5i0,848
+skimage/__pycache__/__init__.cpython-311.pyc,,
+skimage/__pycache__/conftest.cpython-311.pyc,,
+skimage/_shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skimage/_shared/__pycache__/__init__.cpython-311.pyc,,
+skimage/_shared/__pycache__/_dependency_checks.cpython-311.pyc,,
+skimage/_shared/__pycache__/_geometry.cpython-311.pyc,,
+skimage/_shared/__pycache__/_tempfile.cpython-311.pyc,,
+skimage/_shared/__pycache__/_warnings.cpython-311.pyc,,
+skimage/_shared/__pycache__/compat.cpython-311.pyc,,
+skimage/_shared/__pycache__/coord.cpython-311.pyc,,
+skimage/_shared/__pycache__/dtype.cpython-311.pyc,,
+skimage/_shared/__pycache__/filters.cpython-311.pyc,,
+skimage/_shared/__pycache__/tester.cpython-311.pyc,,
+skimage/_shared/__pycache__/testing.cpython-311.pyc,,
+skimage/_shared/__pycache__/utils.cpython-311.pyc,,
+skimage/_shared/__pycache__/version_requirements.cpython-311.pyc,,
+skimage/_shared/_dependency_checks.py,sha256=6ZaHZf0d65U5cGMtSEegDUYQ_gJL1wSkC-w9zZkcA18,211
+skimage/_shared/_geometry.py,sha256=vagNwhLEcKvM0k19agDXvhnZDjwjTL9au5O-CSuDCQY,1343
+skimage/_shared/_tempfile.py,sha256=Fw7g_KlpsXakwa9qDFBgf5dcuyyhqAdEMW8L-8rnqsI,760
+skimage/_shared/_warnings.py,sha256=ELNhragQM-se-tmyUvcdKVcm-s4cpRiHkNTTMbZCJnM,5222
+skimage/_shared/compat.py,sha256=rBKgLOm2OS3MQ1gafvbF6GsfvYnE82Y4cyjfTQq__MI,1046
+skimage/_shared/coord.py,sha256=KGgOj1qps451UMaMVy2SlgO7rXFSi91WSbegQjqBOs0,4330
+skimage/_shared/dtype.py,sha256=-6l3DaRdHqFRB9EnvMU5xqHxwN7c519Svv47qy1R-Sk,2397
+skimage/_shared/fast_exp.cpython-311-x86_64-linux-gnu.so,sha256=0UTaBvIz7AcpaGpbGuEm56eBRVYWDQS3lSpHHcRFpYU,69880
+skimage/_shared/fast_exp.h,sha256=HtIZ7X68IvcNN47SM5E1SxBgvVYziJKvzvawzO94vi8,1246
+skimage/_shared/filters.py,sha256=yQZFHt97P8XyQuZ5qEkVxBT1KRSXoWBbBQf2NimST0I,4877
+skimage/_shared/geometry.cpython-311-x86_64-linux-gnu.so,sha256=HjydEFIc_JQYQbsDp345O13waRa3AFIHp6KKUGv_cng,180400
+skimage/_shared/interpolation.cpython-311-x86_64-linux-gnu.so,sha256=JCxzD5xIcirUL51NqlhOi-eM_UbNqmNqoymR9nYKvHs,53784
+skimage/_shared/tester.py,sha256=bA-Foz30kjF7LLpnUsOcllI5HS38f7e7hogP0uxG0vo,3589
+skimage/_shared/testing.py,sha256=0yYZ8j4DCYSp34cNdY4_yiiityI3TtEMw2-biNO3q7I,9923
+skimage/_shared/transform.cpython-311-x86_64-linux-gnu.so,sha256=5o6JLSztgcVmDykvcSXX2GDvcbAcuSWDAvxg_jsvuls,180544
+skimage/_shared/utils.py,sha256=sKIyVwyOmQq3bNb-b1SmcWGmkSFNv2xSllbhOnmesfE,36621
+skimage/_shared/version_requirements.py,sha256=ogsM5Qn6Zb6AAU_f6M4N7r3Vo2-NLUxT1RG0VSqZK2w,4347
+skimage/_vendored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skimage/_vendored/__pycache__/__init__.cpython-311.pyc,,
+skimage/_vendored/__pycache__/numpy_lookfor.cpython-311.pyc,,
+skimage/_vendored/numpy_lookfor.py,sha256=KxljgNIZ2mDoyEwFndef7imiFFblxC8FWs3gRn3xUio,9776
+skimage/color/__init__.py,sha256=QDtz_aFnz27WW9iaRg8rXNS9_8EQpNKFLB8Zzi7m-qw,130
+skimage/color/__init__.pyi,sha256=03z6CYNjJon-6DHGJF1xHPRr0ZhCcXOzkn1owqORxXY,2382
+skimage/color/__pycache__/__init__.cpython-311.pyc,,
+skimage/color/__pycache__/adapt_rgb.cpython-311.pyc,,
+skimage/color/__pycache__/colorconv.cpython-311.pyc,,
+skimage/color/__pycache__/colorlabel.cpython-311.pyc,,
+skimage/color/__pycache__/delta_e.cpython-311.pyc,,
+skimage/color/__pycache__/rgb_colors.cpython-311.pyc,,
+skimage/color/adapt_rgb.py,sha256=eWZhGvWQ3nucRZkrDP6sgnF6Ka0rL6BB7jxeXL4pcp8,2489
+skimage/color/colorconv.py,sha256=_F9JrBlMIpMl8h3b5MSfffQwe5Yn37tfzSglEzFE_f4,67508
+skimage/color/colorlabel.py,sha256=v0VVZjMBf5_Dzq38w9txqJSzwjAQfA84ZL1_fnVE8JA,10506
+skimage/color/delta_e.py,sha256=2oXAdGwfScy2Db_XZVaxzHnYVQJjgs8eLgSIt_Nit7Y,12715
+skimage/color/rgb_colors.py,sha256=Nj-fsrXpuCtLFIjKMgzpvb6HkrpZiuvgDc5imTMGs9w,4493
+skimage/conftest.py,sha256=JwlJva5dtmu5OUIgF8I-Lif3oXF4A3taoZOS8D2h114,321
+skimage/data/README.txt,sha256=Wra5WN0KyiF-Pp3FNWCMJDKkdIKRCdEGTwPSSUYACyc,280
+skimage/data/__init__.py,sha256=8Y4bk3tEAfBWnB-xKf7pXopkkP-AczTaXFxAQewZxS0,388
+skimage/data/__init__.pyi,sha256=varbukgcATJEhBB6ICnSPDI7SgNyIu1d8WQYZgXHJIE,1411
+skimage/data/__pycache__/__init__.cpython-311.pyc,,
+skimage/data/__pycache__/_binary_blobs.cpython-311.pyc,,
+skimage/data/__pycache__/_fetchers.cpython-311.pyc,,
+skimage/data/__pycache__/_registry.cpython-311.pyc,,
+skimage/data/_binary_blobs.py,sha256=AH2C58vUwwi-wPof4CUQ2PxoXIdKcQlhUqHhlI_cFs4,4121
+skimage/data/_fetchers.py,sha256=UOYjT6IXCCDq-ND49CtRkFgir8NoCk8JET-hHUNff7Q,39503
+skimage/data/_registry.py,sha256=KcHtNPa6OuHg_nSPO404IxU4opJG9TgmaG9ZNBXHmH8,20990
+skimage/data/astronaut.png,sha256=iEMc2WU8zVOXQbVV-wpGthVYswHUEQQStbwotePqbLU,791555
+skimage/data/brick.png,sha256=eWbK8yT2uoQxGNmPegd0bSL2o0NDCt0CM-yl9uqqj88,106634
+skimage/data/camera.png,sha256=sHk9Kt2g-mromcA5iUgr_5pC09VpD8fjZI8nldcwwjo,139512
+skimage/data/cell.png,sha256=jSOn-4H3zId80J8zA1f8f1lWUTBuhOFyUvbgobP2FRU,74183
+skimage/data/chelsea.png,sha256=WWqh58uHXrefQ34xA4HSazOKgcLaI0OXBKc8RlHoxLs,240512
+skimage/data/chessboard_GRAY.png,sha256=PlGHB3RRWvTQfYIL2IJzZMcIOb-bVzx0bkhQleiT35A,418
+skimage/data/chessboard_RGB.png,sha256=GsAe_y1OUPTtpVot3s3CimV2YjpY16fvhFE8XMGaAzE,1127
+skimage/data/clock_motion.png,sha256=8Ckiayi2QugBE9hmIumyFe4Geglm_q9eYGBKHgVzOVU,58784
+skimage/data/coffee.png,sha256=zAL4yhiLFnx3WnEBtddn0ecXks92LDPW-hWkWZtajec,466706
+skimage/data/coins.png,sha256=-Ndz_Jz6b02OWULcNNCgeI_K7SpP77vtCu9TmNfvTLo,75825
+skimage/data/color.png,sha256=fS35k94rT6KnjgTl34BQ9JqcURqnXlmrO9VqycmK734,85584
+skimage/data/grass.png,sha256=trYCJCaziTbEOkrAljXNeK8HTpD0L_qCJ6yLdFLTn4k,217893
+skimage/data/gravel.png,sha256=xIYVtFG_HmBvvXLAqp-MwPBoq3ER732Tu5sPJYZEDBI,194247
+skimage/data/horse.png,sha256=x_tgeJ_jlMSF-EIpHqOyHlDRQPOdbctfuZF8wXgiVFU,16633
+skimage/data/hubble_deep_field.jpg,sha256=OhnF3YqSepM0uxIpptY3EbHAx2f7J-IobnyEo-LC9fQ,527940
+skimage/data/ihc.png,sha256=-N0ao4fd0fSditE7UJIbI3346bJiYG0lh3Boew75PO8,477916
+skimage/data/lbpcascade_frontalface_opencv.xml,sha256=Awl3iaPcuw5A0gue-CU328O2cLan8iaNc1Rw8i4AOpE,51858
+skimage/data/lfw_subset.npy,sha256=lWDsL17frAGXP2OoqZ0ABT_s0R4hh34YA4--UA-Ohyw,1000080
+skimage/data/logo.png,sha256=8sV_6K8Inwi1ulI9lVc8JuYpBKxZZ_TIhRsn0DNpAWg,179723
+skimage/data/microaneurysms.png,sha256=oeG-WapEf4zggvf6gJmXqzaaKxN8tsQgKrxkfHzPZFY,4950
+skimage/data/moon.png,sha256=eHOWGdEffrnBZbtdLv1Hcs7lV4EuyEdTLbsdku9x9Xc,50177
+skimage/data/motorcycle_disp.npz,sha256=LknIzr_z-iA1mgzGiAyC4cA7uxBtqBoXchgoG8LxE9c,1146173
+skimage/data/motorcycle_left.png,sha256=2xjpxBV2F0A8NTemujVd_q_pp-q7a5uUyzP2Ul3UkXk,644701
+skimage/data/motorcycle_right.png,sha256=X8kTrocOQqS2YjFLyQTReGvK2OLwubZ9uloilAY1d5c,640373
+skimage/data/multipage.tif,sha256=TaCtDT30gHqYRyR9G15WW1DUZIH2Q6-1w3wUgCx4Ew8,940
+skimage/data/multipage_rgb.tif,sha256=HSO4RP043ODi0G8wQygXzbheUgcNj1RgorpYrr80oN4,5278
+skimage/data/no_time_for_that_tiny.gif,sha256=IKvpS6nkXxjeQWxfvvjR9XpJlgC-QPmiAPriRgEO784,4438
+skimage/data/page.png,sha256=NBpvCmFVdmKwJzSptuVuwzqRWyxBiGuXUJ3t8qQ7R6M,47679
+skimage/data/phantom.png,sha256=VS_2mBZ6pALM6xeYETBgeiKKCgqnxRkpnqpNXzAbo2w,3386
+skimage/data/retina.jpg,sha256=OKB_NvJ_CV6Biup7ltNCAsBRdtMCU8ZnM_LgA3np4OY,269564
+skimage/data/rocket.jpg,sha256=wt0N58U4340RHkeWGbEpRk0CadCuX9GMqR0zp_3-qVw,112525
+skimage/data/text.png,sha256=vYSqOm48mIeFDUXWBslrLllDP771AzhXC2PDGeZo5tE,42704
+skimage/draw/__init__.py,sha256=TjMI6gosMA2CafWXFmuObiMxykg9yCGlUAkc_j-A0UA,161
+skimage/draw/__init__.pyi,sha256=dzGdH8dVkLPbpDxkcA9v7wQdAEbxHyhq1MqnWPWYLcM,963
+skimage/draw/__pycache__/__init__.cpython-311.pyc,,
+skimage/draw/__pycache__/_polygon2mask.cpython-311.pyc,,
+skimage/draw/__pycache__/_random_shapes.cpython-311.pyc,,
+skimage/draw/__pycache__/draw.cpython-311.pyc,,
+skimage/draw/__pycache__/draw3d.cpython-311.pyc,,
+skimage/draw/__pycache__/draw_nd.cpython-311.pyc,,
+skimage/draw/_draw.cpython-311-x86_64-linux-gnu.so,sha256=Mmc_7JeSNuL4NUOtKJqBKAWbluZWKp6jARTE5zwXE5s,372280
+skimage/draw/_polygon2mask.py,sha256=Y1dShd48WRbxpRqvPEvURPPxwFKaR0g-RY11_epKoyU,2472
+skimage/draw/_random_shapes.py,sha256=tkB2pDoNYxoW_9VP2qUtnKeplNewLSpS6_x9J1kuBdI,16010
+skimage/draw/draw.py,sha256=_C5fPVF0dwpmdAXww7r2_fX_30fv7IVobTr4vRrmj0k,33590
+skimage/draw/draw3d.py,sha256=eMmpG3VNigylno7M11-pRY3BKlKSMPVChY1O5q5sV8o,3287
+skimage/draw/draw_nd.py,sha256=RKG1GHjsTyXN8J2nWJGVDeoqG3srqPuqmTReZsJst_4,3692
+skimage/exposure/__init__.py,sha256=8MMNgHdza2XatOj7Zf9h5xpl3O2gHeMn8N1gpIHKMJo,169
+skimage/exposure/__init__.pyi,sha256=HKwoewNTdeXl1yHaCJqErXZbxT4tLpBtfjYz53PnPQk,682
+skimage/exposure/__pycache__/__init__.cpython-311.pyc,,
+skimage/exposure/__pycache__/_adapthist.cpython-311.pyc,,
+skimage/exposure/__pycache__/exposure.cpython-311.pyc,,
+skimage/exposure/__pycache__/histogram_matching.cpython-311.pyc,,
+skimage/exposure/_adapthist.py,sha256=uxRzK1pMT0Gbp1dFS2W-22I8en155yqHDXwE8NodWsQ,10971
+skimage/exposure/exposure.py,sha256=7GgJd3evD0xP73kD7r4PT5b44kcHBX-XJSWEMAj2ehE,27919
+skimage/exposure/histogram_matching.py,sha256=Q7_OwedrtvDcPO4KTRfqq-gxD6SQXqm2NfhPmUZhZA0,3194
+skimage/feature/__init__.py,sha256=paLASf66MmyJ8A1Ha8HE0WOn1GDnSioXhHIvA49gJ4g,178
+skimage/feature/__init__.pyi,sha256=weDA8amsNEfeKiXUnHbRiuDCOKXt-saPei6aTkdhIw8,2148
+skimage/feature/__pycache__/__init__.cpython-311.pyc,,
+skimage/feature/__pycache__/_basic_features.cpython-311.pyc,,
+skimage/feature/__pycache__/_canny.cpython-311.pyc,,
+skimage/feature/__pycache__/_daisy.cpython-311.pyc,,
+skimage/feature/__pycache__/_fisher_vector.cpython-311.pyc,,
+skimage/feature/__pycache__/_hog.cpython-311.pyc,,
+skimage/feature/__pycache__/_orb_descriptor_positions.cpython-311.pyc,,
+skimage/feature/__pycache__/blob.cpython-311.pyc,,
+skimage/feature/__pycache__/brief.cpython-311.pyc,,
+skimage/feature/__pycache__/censure.cpython-311.pyc,,
+skimage/feature/__pycache__/corner.cpython-311.pyc,,
+skimage/feature/__pycache__/haar.cpython-311.pyc,,
+skimage/feature/__pycache__/match.cpython-311.pyc,,
+skimage/feature/__pycache__/orb.cpython-311.pyc,,
+skimage/feature/__pycache__/peak.cpython-311.pyc,,
+skimage/feature/__pycache__/sift.cpython-311.pyc,,
+skimage/feature/__pycache__/template.cpython-311.pyc,,
+skimage/feature/__pycache__/texture.cpython-311.pyc,,
+skimage/feature/__pycache__/util.cpython-311.pyc,,
+skimage/feature/_basic_features.py,sha256=_SnrTNvqqO8gSyeddlLsdLZQqJEslItmLP-3XoKVwbk,6750
+skimage/feature/_canny.py,sha256=g4aAemdO553jRF04M7oSXWQDvaE9b_29eewQWbIX9GM,9466
+skimage/feature/_canny_cy.cpython-311-x86_64-linux-gnu.so,sha256=pTjQvAltrhhT_89G_dtJ35Ybdrnft6MfnA7pQB7aR5w,250472
+skimage/feature/_cascade.cpython-311-x86_64-linux-gnu.so,sha256=bbdlDzjAcCYiD3TRxdI9ybN0nbaPgjkD2QSYsqEuywg,330832
+skimage/feature/_daisy.py,sha256=BC42Hao8q2P5MHE0syRThFRfmBa5JeGNzDG1g3Ee9MA,10064
+skimage/feature/_fisher_vector.py,sha256=mNkiNAn_Dufd4p4RK4H6gBZVkTyQOg7nQsjedgE_O1E,10418
+skimage/feature/_haar.cpython-311-x86_64-linux-gnu.so,sha256=2G7nd27Q5Xcp-JjOKNR6JD19pSj6rGs19JVE0Je1FsI,530984
+skimage/feature/_hessian_det_appx.cpython-311-x86_64-linux-gnu.so,sha256=A0tqGMmDUCak7GZKf5qCbJDkxYn6PnQ-WUX2-4VpWjI,65424
+skimage/feature/_hog.py,sha256=APuWjYzXNJId9FKAz3PXpn-g4pJfw2KDOO-rp99fqBI,13208
+skimage/feature/_hoghistogram.cpython-311-x86_64-linux-gnu.so,sha256=lkogqlCAuHQhRC1BxX4RTLk6iPwvOSzArl4tAjFdaAA,258640
+skimage/feature/_orb_descriptor_positions.py,sha256=zM1l5vjzmuH9QhABX2ZkgS19VoIb_7k08OzYL467anM,450
+skimage/feature/_sift.cpython-311-x86_64-linux-gnu.so,sha256=48SNj_k4NSCBdXPkjB_CXVsnafJ3c9s3OW2FEFnPRk8,298600
+skimage/feature/_texture.cpython-311-x86_64-linux-gnu.so,sha256=m6pDf_4RyCA-CDD1MnoLJoSbYUfEhV8s_OAzumYi_Rk,352240
+skimage/feature/blob.py,sha256=mC-l17fqRJwppHkrJw8cGGEIi5pjMb5IBWrtamjsdbY,28370
+skimage/feature/brief.py,sha256=sOAu-qx44Np32s0lzzAzkIt6CRpFf8h4RKdvivLYG1Y,8115
+skimage/feature/brief_cy.cpython-311-x86_64-linux-gnu.so,sha256=D8W_2Cg3p7lGn4IrZ-bJJTyJLpwKQG3gIWJUR4hg5oI,223600
+skimage/feature/censure.py,sha256=MVa0xj53iyr3JWPEjfDYrXaAy2ILUHV6QQm08igXrc0,12097
+skimage/feature/censure_cy.cpython-311-x86_64-linux-gnu.so,sha256=RZ2CecdW5-wNpXMoU9Aa67CrTeL0lZO9vfktEAYT4yg,217736
+skimage/feature/corner.py,sha256=Gnld0Kc6tuKPXSGQ-jJpRyyDkQJeiyI-d6ZVj9EEnVM,45566
+skimage/feature/corner_cy.cpython-311-x86_64-linux-gnu.so,sha256=2LmtY6IzFaJ1-ULEXasflIUVpSOPmQQX8MRCin4HAhE,311592
+skimage/feature/haar.py,sha256=sGtUnmD8-KGGvsK-6risY-lTH-CYL4tBrbFTGFjhPRA,12921
+skimage/feature/match.py,sha256=WayyFreFmSp02NEayvsjQt4HYwUoJPftHvTj9jVZBDs,4023
+skimage/feature/orb.py,sha256=Bi41N8GYP6DtYlu5vjagmD0HTy_GqdEy5mdCwj2fCq8,13148
+skimage/feature/orb_cy.cpython-311-x86_64-linux-gnu.so,sha256=KKp8WgAzfJ9ojNcXTRcA00BXrL9K7dOcCGjYnZYxdWo,246712
+skimage/feature/orb_descriptor_positions.txt,sha256=5lNSwCXegQMV0huO4FszyWGoPy1291cKt7Vpvddg8BE,2840
+skimage/feature/peak.py,sha256=hb-0LUKtcVDz7saNV3je11VqNtOGz3lT4yaw0JdnzcM,14478
+skimage/feature/sift.py,sha256=Rh7oRFE0XaA6w1emFjAxcal1Kd49AVkaXYvOi9Ktwkw,29407
+skimage/feature/template.py,sha256=P8w0Wxx4voJQxMMbWGPIhled4NO9VSulT3Mf5qxEvfQ,6571
+skimage/feature/texture.py,sha256=pOt1rEzszGSlvXbA4L30NgEl7r-Paw86ZjTVV9aZmWo,20544
+skimage/feature/util.py,sha256=v-9dcDXtQWLO6fuH_jhr-QBdIzCk7TJbBJUI2iAdYbA,7049
+skimage/filters/__init__.py,sha256=1ehkljJM7R29gbYqXS75AZ6fNba7FMttFo67IFJSpD4,165
+skimage/filters/__init__.pyi,sha256=KonQ6JGwzrRlNcoG5wOUmU7ujdNQkW2G5A7Ub52DGq8,2158
+skimage/filters/__pycache__/__init__.cpython-311.pyc,,
+skimage/filters/__pycache__/_fft_based.cpython-311.pyc,,
+skimage/filters/__pycache__/_gabor.cpython-311.pyc,,
+skimage/filters/__pycache__/_gaussian.cpython-311.pyc,,
+skimage/filters/__pycache__/_median.cpython-311.pyc,,
+skimage/filters/__pycache__/_rank_order.cpython-311.pyc,,
+skimage/filters/__pycache__/_sparse.cpython-311.pyc,,
+skimage/filters/__pycache__/_unsharp_mask.cpython-311.pyc,,
+skimage/filters/__pycache__/_window.cpython-311.pyc,,
+skimage/filters/__pycache__/edges.cpython-311.pyc,,
+skimage/filters/__pycache__/lpi_filter.cpython-311.pyc,,
+skimage/filters/__pycache__/ridges.cpython-311.pyc,,
+skimage/filters/__pycache__/thresholding.cpython-311.pyc,,
+skimage/filters/_fft_based.py,sha256=LUwb9JlvarVhLlSP5nPacsI6C5doVlJWufTh95QqOOg,6709
+skimage/filters/_gabor.py,sha256=Ag--tND24VcErppMMsTMUsIRhyCxLDUv79lT8Jyg-As,7720
+skimage/filters/_gaussian.py,sha256=fyHfkvJuEptkhm9USYrZMZ6dytWK39V2HqXYi7lxDvU,6037
+skimage/filters/_median.py,sha256=JdC35YKPcJxgq2k-LqYD1ghka3jh1mCD11WS5FyLYtY,2965
+skimage/filters/_multiotsu.cpython-311-x86_64-linux-gnu.so,sha256=OnnaEhOPimyrU8RilZpjUlKQuPSX0uFze8Z0Ccelf_w,261840
+skimage/filters/_rank_order.py,sha256=NUbi5sPtKTW-Xm6VZcwn0F5pV45yfaYDeHMEJtGy4nk,2057
+skimage/filters/_sparse.py,sha256=KpvOH4LGITQdj-obrM-t-Ax0Z4LbJXNxEdCHG27XBmM,4709
+skimage/filters/_unsharp_mask.py,sha256=EoJ5JHrndcgrliDsef_WcQM6O3HGnswRUUW3tLBlUYs,5511
+skimage/filters/_window.py,sha256=xO_yx7DSEXTBIWwPhXlsKNirmfH6Koc7k5Us_6A1wfY,4351
+skimage/filters/edges.py,sha256=MVKDqHMhfa2-mIb844A56Z1T3BCYI8GDzvEvbyS4QJE,25635
+skimage/filters/lpi_filter.py,sha256=Z6SWW7EAM2Hj3sVOzQtUs9R_d7ZHwqIYAqNAdqpSOY8,7937
+skimage/filters/rank/__init__.py,sha256=SFt54WGOb_evjktH87sKTcKk3i-4C2mqNN3c6nv46fw,1548
+skimage/filters/rank/__pycache__/__init__.cpython-311.pyc,,
+skimage/filters/rank/__pycache__/_percentile.cpython-311.pyc,,
+skimage/filters/rank/__pycache__/bilateral.cpython-311.pyc,,
+skimage/filters/rank/__pycache__/generic.cpython-311.pyc,,
+skimage/filters/rank/_percentile.py,sha256=acsKcQl7JqFGoKwScUL_kefYiTkcAD-6s-jbU2hPuDY,14102
+skimage/filters/rank/bilateral.py,sha256=Db8jn8hQEAiBH7Jlgq4NzjcpMDivLAdn7iy2NErsxUE,7846
+skimage/filters/rank/bilateral_cy.cpython-311-x86_64-linux-gnu.so,sha256=aqs2fUCJgXPMFl8iuPPeKr4NCaW7WneqFKWXrmTlL9U,456248
+skimage/filters/rank/core_cy.cpython-311-x86_64-linux-gnu.so,sha256=-kSeUojzcQCGn-jlqhNCsIBjCU2DmS5PNzPNBIshQDA,573416
+skimage/filters/rank/core_cy_3d.cpython-311-x86_64-linux-gnu.so,sha256=WrlyMUBqb-06YAgAGgAm8AHbWB5OElzcuLmT007PNVM,348504
+skimage/filters/rank/generic.py,sha256=6vZ33Gvl8JmUzms13nzeuvCdD7Q26bbNt3UE4uJ191A,55905
+skimage/filters/rank/generic_cy.cpython-311-x86_64-linux-gnu.so,sha256=2_6C7hTsQDrwhQKw1M_1kJ52FoG_PCTQXc00FUBGlEs,3381624
+skimage/filters/rank/percentile_cy.cpython-311-x86_64-linux-gnu.so,sha256=PdsyIDplMBoV9HwUr05SoTwtPmL9r4114zXBKaeRNig,935912
+skimage/filters/ridges.py,sha256=ogeXfIZzRDVVGgqZuLn4xnveKUO5RBqzrzLVI7TPpqw,14609
+skimage/filters/thresholding.py,sha256=KDaH3EDtutx9SzfZhfxOlIfoXkcsqjwOAgPCnk-2GbQ,47885
+skimage/future/__init__.py,sha256=YX1ggMLn08L_Cy-UzcKlEJd1JbFjGAtWGGht705VXZE,506
+skimage/future/__init__.pyi,sha256=q-RbSvWEFevrbvLiFJ44XiFL6jPKvSV-NqwVQ0FZMAk,493
+skimage/future/__pycache__/__init__.cpython-311.pyc,,
+skimage/future/__pycache__/manual_segmentation.cpython-311.pyc,,
+skimage/future/__pycache__/trainable_segmentation.cpython-311.pyc,,
+skimage/future/manual_segmentation.py,sha256=EQ-atSKTONFrnVjuGAia5XZdoKQ-Z_PtoHRGsDJY4r4,7610
+skimage/future/trainable_segmentation.py,sha256=ziB_HovaKyLENPGUaCPABXoIxBh7wkOW0894qTWWFIQ,5604
+skimage/graph/__init__.py,sha256=fXO5xY04KgnleV0BeITsL522zKGo4LaC7Bi6V4rh-c4,338
+skimage/graph/__init__.pyi,sha256=-fh5gug7Wi0FFVl0BDxTla37aXRDOsNfmHtHC_r7HJk,782
+skimage/graph/__pycache__/__init__.cpython-311.pyc,,
+skimage/graph/__pycache__/_graph.cpython-311.pyc,,
+skimage/graph/__pycache__/_graph_cut.cpython-311.pyc,,
+skimage/graph/__pycache__/_graph_merge.cpython-311.pyc,,
+skimage/graph/__pycache__/_ncut.cpython-311.pyc,,
+skimage/graph/__pycache__/_rag.cpython-311.pyc,,
+skimage/graph/__pycache__/mcp.cpython-311.pyc,,
+skimage/graph/__pycache__/spath.cpython-311.pyc,,
+skimage/graph/_graph.py,sha256=cyfQ1zvBVb2_5zW_c00yiYY4rOEzkwFBVWjor0a0uCA,9223
+skimage/graph/_graph_cut.py,sha256=Y7eVSa26SKHU2hd-qcDhj7r1MPaGFuGbqzt3LAZ8vZE,10397
+skimage/graph/_graph_merge.py,sha256=lrgunWZGrplz42xIDIz3IJoR4AfhzNLc_MdD5O-3tkQ,4304
+skimage/graph/_mcp.cpython-311-x86_64-linux-gnu.so,sha256=Rt_elxqTZ5d4aKcLtaMhY6aImxAO9O-6mpumFQRevAo,496704
+skimage/graph/_ncut.py,sha256=EmchgBgVFKaveAKMElDIcOGFOVGlrQWqb_bt-2lcy8M,1825
+skimage/graph/_ncut_cy.cpython-311-x86_64-linux-gnu.so,sha256=h0zArE5Ips3JHOHZWaE6nz1R5m22eqR0K_44lPbyEnk,271888
+skimage/graph/_rag.py,sha256=94INQw2RCMyhhhmkN7o2na0MEOFlbzfGx4xvqmrlgcg,20598
+skimage/graph/_spath.cpython-311-x86_64-linux-gnu.so,sha256=nw6efkZxnnVbHpObI40QoZ-iGPu3PSU4C1QPT2PnJhM,242208
+skimage/graph/heap.cpython-311-x86_64-linux-gnu.so,sha256=nD0ki1O-b_gyW0ffr2eBtuH7DW1J-NCwpurFJn8Edq4,122960
+skimage/graph/mcp.py,sha256=1gRa1f2QhCiup4WFaaCr9YcnNHZVc8H1DoIA0oS-vVM,3182
+skimage/graph/spath.py,sha256=uav6ZRcaw3O93NyLiq-EVQouZUtxK16VIYUYoWGuJNM,3399
+skimage/io/__init__.py,sha256=wHwMf7uBa0rcB4BcF76XIWhbCeLYW-CyCz6_4UnDUeE,1009
+skimage/io/__pycache__/__init__.cpython-311.pyc,,
+skimage/io/__pycache__/_image_stack.cpython-311.pyc,,
+skimage/io/__pycache__/_io.cpython-311.pyc,,
+skimage/io/__pycache__/collection.cpython-311.pyc,,
+skimage/io/__pycache__/manage_plugins.cpython-311.pyc,,
+skimage/io/__pycache__/sift.cpython-311.pyc,,
+skimage/io/__pycache__/util.cpython-311.pyc,,
+skimage/io/_image_stack.py,sha256=A75v07PK6yd-5Qi60JfoaKG2esjJI5bMtlou8dNjUSc,570
+skimage/io/_io.py,sha256=Lej6xNB9SmpH9bbw0P5-gFt0n3upeQ0yEGqaoM6qXqQ,8901
+skimage/io/_plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skimage/io/_plugins/__pycache__/__init__.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/fits_plugin.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/gdal_plugin.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/imageio_plugin.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/imread_plugin.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/matplotlib_plugin.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/pil_plugin.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/simpleitk_plugin.cpython-311.pyc,,
+skimage/io/_plugins/__pycache__/tifffile_plugin.cpython-311.pyc,,
+skimage/io/_plugins/fits_plugin.ini,sha256=60y6Ey9etFQTf3oRxr4hAgptiBxkmNG_PpJaP5LdhR8,88
+skimage/io/_plugins/fits_plugin.py,sha256=hE0QRLBX6AcTtodB9VVopw5O7U62ektN251opWSu6MQ,4407
+skimage/io/_plugins/gdal_plugin.ini,sha256=Yx6iK4NqTllzpc726aXZXOlktuhm8IR28i4hfB7Qkn8,89
+skimage/io/_plugins/gdal_plugin.py,sha256=oNQjajA4GUxb3swAQMf19X_XJhyY3pRdaFde145K4J4,349
+skimage/io/_plugins/imageio_plugin.ini,sha256=Gi4D65yDOFzg7gRCwXYGxlJoHsvlFSEwyt1wJkedqWc,88
+skimage/io/_plugins/imageio_plugin.py,sha256=d9MQzuDOWadJlfDhNptaNQJEI8sPsXWgzmwJuDxldLk,330
+skimage/io/_plugins/imread_plugin.ini,sha256=yNvmnjjif85MJpwIfSheQ0IMQ86rPZuuTDjuaZZH6Pk,86
+skimage/io/_plugins/imread_plugin.py,sha256=dM_Z_GsqUIbZQatLUPKJEiOC6nYQP7k3nscDyTLjJvs,956
+skimage/io/_plugins/matplotlib_plugin.ini,sha256=re_KwCXXwedUEqJ749d7q6YqPDde5_RxH72M7y3PYY0,123
+skimage/io/_plugins/matplotlib_plugin.py,sha256=podbloMpRsQOxGFSHzu_ySwJokRYzLkZMrG3HNjaWHQ,6463
+skimage/io/_plugins/pil_plugin.ini,sha256=ZSFIMpRtr2-tUPvK_cG0xLOrPSWgw1ObRWVe8TMIJF0,91
+skimage/io/_plugins/pil_plugin.py,sha256=ihMQ9IVPPTATOPATRm8L9-ro0bw-fNNlTdnIj2n48eY,7780
+skimage/io/_plugins/simpleitk_plugin.ini,sha256=Zu1mh1RaPIu6vw2cSPev_T2or0DTMYZeLxyc1u7Hcig,92
+skimage/io/_plugins/simpleitk_plugin.py,sha256=N2Ja-_0TpfrixNl0iEWJydrIrHgOYlzuxHkF10KrYOE,531
+skimage/io/_plugins/tifffile_plugin.ini,sha256=vQpbXXPSQN242crgASKbsxqn1aDUfHwftslt9vvuSkQ,110
+skimage/io/_plugins/tifffile_plugin.py,sha256=mAT73YEKXXefD2DtMqZyUioqljO4FmKRi7D5b-gHeps,2071
+skimage/io/collection.py,sha256=GoXoj5LNTEIiFVA44ZIVmOug4M2eS_p2yF3q_RfoDNg,15956
+skimage/io/manage_plugins.py,sha256=y7VgUqC7PHSrlnd8yeDTj_LSaNRB2mJzqlzJtPBHHz4,12327
+skimage/io/sift.py,sha256=mfUV7SJhTqmxpwHXwyPMYhQT_1d6y5JloNfHgH40qnc,2561
+skimage/io/util.py,sha256=7gQdn6BD2HX-R5yAI6A8GCjG3HMWzUFjzjPJD1Qa3HE,1283
+skimage/measure/__init__.py,sha256=QV04vcq3E_ez4cLSw_3xjbS1ptDAzmVTeJrZ3IpdA4I,174
+skimage/measure/__init__.pyi,sha256=fmXK7lqxd9G1-lCXgXKmKLO6LsmUNQ2Ydf46Zm19-FE,1906
+skimage/measure/__pycache__/__init__.cpython-311.pyc,,
+skimage/measure/__pycache__/_blur_effect.cpython-311.pyc,,
+skimage/measure/__pycache__/_colocalization.cpython-311.pyc,,
+skimage/measure/__pycache__/_find_contours.cpython-311.pyc,,
+skimage/measure/__pycache__/_label.cpython-311.pyc,,
+skimage/measure/__pycache__/_marching_cubes_lewiner.cpython-311.pyc,,
+skimage/measure/__pycache__/_marching_cubes_lewiner_luts.cpython-311.pyc,,
+skimage/measure/__pycache__/_moments.cpython-311.pyc,,
+skimage/measure/__pycache__/_moments_analytical.cpython-311.pyc,,
+skimage/measure/__pycache__/_polygon.cpython-311.pyc,,
+skimage/measure/__pycache__/_regionprops.cpython-311.pyc,,
+skimage/measure/__pycache__/_regionprops_utils.cpython-311.pyc,,
+skimage/measure/__pycache__/block.cpython-311.pyc,,
+skimage/measure/__pycache__/entropy.cpython-311.pyc,,
+skimage/measure/__pycache__/fit.cpython-311.pyc,,
+skimage/measure/__pycache__/pnpoly.cpython-311.pyc,,
+skimage/measure/__pycache__/profile.cpython-311.pyc,,
+skimage/measure/_blur_effect.py,sha256=mhgvLVugOfQo3iI_ZkU2_zcRVVmHEh28MxEhfVjc8oA,3324
+skimage/measure/_ccomp.cpython-311-x86_64-linux-gnu.so,sha256=0QajeLAx_3yfwi_cDdzMaahJJfsdLieL6kSrGV-dSws,130304
+skimage/measure/_colocalization.py,sha256=bP4bblGicAX_tH5Zd0TLmAuGXB8TnO30frBUPuUxaAU,12328
+skimage/measure/_find_contours.py,sha256=9XR2aSiN9vl0WpaA0s19HzP0cbiKxd1zvg7Qaht-I6M,9585
+skimage/measure/_find_contours_cy.cpython-311-x86_64-linux-gnu.so,sha256=Fbg17JFHPDnKA9QuZhvkEjbHmaJH_ctCDZF938dVWAI,226096
+skimage/measure/_label.py,sha256=WoRzje_lZLblB0BSpGsb4rHifWg9ZO9u19Fudq_HmPU,3960
+skimage/measure/_marching_cubes_lewiner.py,sha256=9ILNtcmZbBpGWh_IT_6p-I7sASIAthymforH6rlk9_o,12872
+skimage/measure/_marching_cubes_lewiner_cy.cpython-311-x86_64-linux-gnu.so,sha256=OCAXUcXhAFADzkyHiTUhiCzQrE8cU0HeCEY1VAd_qmc,341384
+skimage/measure/_marching_cubes_lewiner_luts.py,sha256=puYUThcl9gATqqmerwTqAdpqooOeMoR0oV6J_gvP5wE,27802
+skimage/measure/_moments.py,sha256=XK_-ngSYMquH4cKKY3mGOfSBRvIZ0Tz5H0Oovqzp8lc,18470
+skimage/measure/_moments_analytical.py,sha256=1OzL8mhKfqxfKT6Q4t4WwpFyM_1cgKlquMM7jr5LJ-Q,6563
+skimage/measure/_moments_cy.cpython-311-x86_64-linux-gnu.so,sha256=4FMuoHku14wPS9y_3BycJC1rxOBiHwGVOSG5VgSW6tY,246176
+skimage/measure/_pnpoly.cpython-311-x86_64-linux-gnu.so,sha256=ee2Il2KxEffDgaFPZs1Xj7SqGi_JLwraPWoixrBud8k,241240
+skimage/measure/_polygon.py,sha256=JqJ9iVRdFY9rVChXKXmVY5slHtOvBCjIyGpWyEkoqr4,5268
+skimage/measure/_regionprops.py,sha256=2_TpjeyR4xnay9OTc5V9QwAGoe5D88uyQh8gKDQ8MAc,54319
+skimage/measure/_regionprops_utils.py,sha256=tln2t9hLjKXfdyQq0z-h2JPX4QPhgslXzXyzAWzRTyE,15999
+skimage/measure/block.py,sha256=b4dhXeeaiBerPmFpNjtm52KvwRmIByPI1U-Y0S5gws4,3261
+skimage/measure/entropy.py,sha256=aNypYauao_uvywjL1DewtbCDB01jrwX6BnUIAo_CbhM,1144
+skimage/measure/fit.py,sha256=SEk-aMZhkfAjlUJHT8eTARKeRzSd1MUvJFeXHMMtJLk,51310
+skimage/measure/pnpoly.py,sha256=jj_kpvxr3liphmBqh5GCstBW3qrfqbywxUHR_UnUgWI,2024
+skimage/measure/profile.py,sha256=-r9sI9iSsu57zaFKtGc0rE5-x1W5ZgP_XleR_bAS0d0,6781
+skimage/metrics/__init__.py,sha256=TWewBmmkeJ32pddMk6TfIIGK8-kWALIor7GMHx5gMJg,180
+skimage/metrics/__init__.pyi,sha256=1t3MLs46xdqirO2XUiVV__auPvFJY0rAM-S1PDVoHKQ,886
+skimage/metrics/__pycache__/__init__.cpython-311.pyc,,
+skimage/metrics/__pycache__/_adapted_rand_error.cpython-311.pyc,,
+skimage/metrics/__pycache__/_contingency_table.cpython-311.pyc,,
+skimage/metrics/__pycache__/_structural_similarity.cpython-311.pyc,,
+skimage/metrics/__pycache__/_variation_of_information.cpython-311.pyc,,
+skimage/metrics/__pycache__/set_metrics.cpython-311.pyc,,
+skimage/metrics/__pycache__/simple_metrics.cpython-311.pyc,,
+skimage/metrics/_adapted_rand_error.py,sha256=zbCyRSiOGz3QCzYVLdnCDpHtvh2ZoHyCEKKQe-uHJkA,3571
+skimage/metrics/_contingency_table.py,sha256=4zT07BasPCvZ-wxTPoykVAKckUyGSdUyK28Mxa29v2I,1734
+skimage/metrics/_structural_similarity.py,sha256=l4HTTumNP0vDABKt06R0Dq-7ZpUtupxqWz64e9C0sKA,10422
+skimage/metrics/_variation_of_information.py,sha256=Kf02JWuAOTT6N5Y9vksiUHFSuSezrHv7KwWpc8ZVLag,4254
+skimage/metrics/set_metrics.py,sha256=VNcOP2w9oNrrOS0qjPkVuI8IKTG1yYliMWGlzqbVtEk,4896
+skimage/metrics/simple_metrics.py,sha256=1cqqdxiOVJjhMM767wBo3AgXaIwop9p6Z4fwjuGrtJ4,8443
+skimage/morphology/__init__.py,sha256=ucqm6ovsYE3vw3cLpZXHpDodnZaNtHvvtghD0p98WSI,2028
+skimage/morphology/__pycache__/__init__.cpython-311.pyc,,
+skimage/morphology/__pycache__/_flood_fill.cpython-311.pyc,,
+skimage/morphology/__pycache__/_skeletonize.cpython-311.pyc,,
+skimage/morphology/__pycache__/_util.cpython-311.pyc,,
+skimage/morphology/__pycache__/binary.cpython-311.pyc,,
+skimage/morphology/__pycache__/convex_hull.cpython-311.pyc,,
+skimage/morphology/__pycache__/extrema.cpython-311.pyc,,
+skimage/morphology/__pycache__/footprints.cpython-311.pyc,,
+skimage/morphology/__pycache__/gray.cpython-311.pyc,,
+skimage/morphology/__pycache__/grayreconstruct.cpython-311.pyc,,
+skimage/morphology/__pycache__/isotropic.cpython-311.pyc,,
+skimage/morphology/__pycache__/max_tree.cpython-311.pyc,,
+skimage/morphology/__pycache__/misc.cpython-311.pyc,,
+skimage/morphology/_convex_hull.cpython-311-x86_64-linux-gnu.so,sha256=Kt0SNG_AxjhD9ROSotllfwX_FTc3zK_YPNNUKzxqkZY,218208
+skimage/morphology/_extrema_cy.cpython-311-x86_64-linux-gnu.so,sha256=o1LC8COP3lPSKpfnc68T9jbVRcp7AWVYMYgjeHsXkTo,314544
+skimage/morphology/_flood_fill.py,sha256=349jaVevFjmsQHM6ZRRR3Z-Oi0-gelWj6WP5MILXqwk,10733
+skimage/morphology/_flood_fill_cy.cpython-311-x86_64-linux-gnu.so,sha256=cZYlAXIteglJr7IHUCa966aRaRbUrsGN4FWlTfXoFy4,343736
+skimage/morphology/_grayreconstruct.cpython-311-x86_64-linux-gnu.so,sha256=KhxUenvOFjGMaTcAxIMljPZkTC2Rj9Z4ezAfWHjjuZA,263136
+skimage/morphology/_max_tree.cpython-311-x86_64-linux-gnu.so,sha256=eoodwj_N_BN2fsakYLhkuIhSexy8THyreySIoehAfxQ,794352
+skimage/morphology/_misc_cy.cpython-311-x86_64-linux-gnu.so,sha256=rRea68HOToFml1CgFAVoPbn_H5rCk6tIrP5JFpkqXFY,313568
+skimage/morphology/_skeletonize.py,sha256=nDm0COssRlhL8tlV3Z7mZWz1koRycB4-8G9kOT6fYqc,23432
+skimage/morphology/_skeletonize_lee_cy.cpython-311-x86_64-linux-gnu.so,sha256=7J-6FrW6fBj0UbUleX_IoQkuo4_AUFrZjNNwavtCD2g,243512
+skimage/morphology/_skeletonize_various_cy.cpython-311-x86_64-linux-gnu.so,sha256=TPCMIXWol1uo526kHGAjVOOUwgYBahL1N9CFQg2l2FU,240640
+skimage/morphology/_util.py,sha256=TBba9j3tF3srL-q54cNYTRaYy3_8rPuD73v1r1i63vc,12019
+skimage/morphology/ball_decompositions.npy,sha256=T561HzYf19fSLTQt7Hu5gXiiGqnJRFB_JYmLjKIT5U0,431
+skimage/morphology/binary.py,sha256=UEIGKxQcX1JobLXN0cj3_SerUBSEY037QNOIpGSMSxM,13525
+skimage/morphology/convex_hull.py,sha256=KiZHUk4S3NEsQQQSYaY-AKP_gcWmEW4AQzVIAEjw6R4,8420
+skimage/morphology/disk_decompositions.npy,sha256=dpc557PYxwYZk2gs30WgwEiUCVL7eOMbFy2DD3545-4,881
+skimage/morphology/extrema.py,sha256=9LS6UvpGSmGW2gzxPpVtEU00beb_mh8C4Y1_ua47mlE,20816
+skimage/morphology/footprints.py,sha256=flz3lvtq1RJ2z_IxHDCudEriaSbiatTN6du6Z9RLB9M,42729
+skimage/morphology/gray.py,sha256=GagiZCdtoH6P94D66LCSVDlltciPNNtNFlNqjR8eMC4,23604
+skimage/morphology/grayreconstruct.py,sha256=-HwSfTlqe29Yp-IQmxhNQdfbJtgCHMoixj3fynFXEU0,9350
+skimage/morphology/isotropic.py,sha256=IOBNfIVPWFOuVVZf2ucVk1ar5GiC4ZcYMM3e2u-LVxc,10552
+skimage/morphology/max_tree.py,sha256=7ZhC3CU-L4_GTq4yd_mwLPWC1xw7-uT_lGi5wS86hnQ,26983
+skimage/morphology/misc.py,sha256=rrhuKDUyURlM1_AFEA4Lodib7lcF1le8TwDUIXmQMyo,18671
+skimage/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skimage/registration/__init__.py,sha256=WGYVol8x2WxB28mx35mdliJgJ_c0JHE7baSQ4Kxqtqo,184
+skimage/registration/__init__.pyi,sha256=FDJiD5iCOBzWws3vx3ON2PhpoujSvUhtcCjdArGrM74,366
+skimage/registration/__pycache__/__init__.cpython-311.pyc,,
+skimage/registration/__pycache__/_masked_phase_cross_correlation.cpython-311.pyc,,
+skimage/registration/__pycache__/_optical_flow.cpython-311.pyc,,
+skimage/registration/__pycache__/_optical_flow_utils.cpython-311.pyc,,
+skimage/registration/__pycache__/_phase_cross_correlation.cpython-311.pyc,,
+skimage/registration/_masked_phase_cross_correlation.py,sha256=BigH4m9EEQL0p-ZrZ9YTirNuJ9u0jbYi5YmOZKGH_30,12412
+skimage/registration/_optical_flow.py,sha256=dVDHwS5GHlT_ir1_OjGieNz56RCpvC6v1pJxzLgG9U4,14547
+skimage/registration/_optical_flow_utils.py,sha256=aWgyZhaeXedlmzgr614oShB_ITs__sgAdnMHpVlL4P8,3680
+skimage/registration/_phase_cross_correlation.py,sha256=w36mgNtAVl4GtHp8xt4v7JPRIwyrMrpd3SgNI-69ZRI,17871
+skimage/restoration/__init__.py,sha256=DgJTx8pODATVzrTsgIy0RpwL4ojH-dl6ym7w312JF-4,178
+skimage/restoration/__init__.pyi,sha256=mw9Cug3REvQ1R0NveVQXbSkT-JRo6uqSp0gx4eyEG8Y,1067
+skimage/restoration/__pycache__/__init__.cpython-311.pyc,,
+skimage/restoration/__pycache__/_cycle_spin.cpython-311.pyc,,
+skimage/restoration/__pycache__/_denoise.cpython-311.pyc,,
+skimage/restoration/__pycache__/_rolling_ball.cpython-311.pyc,,
+skimage/restoration/__pycache__/deconvolution.cpython-311.pyc,,
+skimage/restoration/__pycache__/inpaint.cpython-311.pyc,,
+skimage/restoration/__pycache__/j_invariant.cpython-311.pyc,,
+skimage/restoration/__pycache__/non_local_means.cpython-311.pyc,,
+skimage/restoration/__pycache__/uft.cpython-311.pyc,,
+skimage/restoration/__pycache__/unwrap.cpython-311.pyc,,
+skimage/restoration/_cycle_spin.py,sha256=Y_msmOTUF7eRmrew9-wheML82lJdNMAJcyJo5_zeKBE,6071
+skimage/restoration/_denoise.py,sha256=iEgeCTcvKY6MCPgpft_34X9L1vFoMHB2Q59p9HFXfH8,41314
+skimage/restoration/_denoise_cy.cpython-311-x86_64-linux-gnu.so,sha256=1mLMjdixPvb7aA2Mpx1hJ3qH_KOpD4mUUHyTVpnfzZA,305488
+skimage/restoration/_inpaint.cpython-311-x86_64-linux-gnu.so,sha256=QisRsfD_tSlfvFF0qjBU9dbl-MH1cOCw2k_c09OjGBk,269984
+skimage/restoration/_nl_means_denoising.cpython-311-x86_64-linux-gnu.so,sha256=xmOl5Vo8Szu3PYEk-D589saptOQqAYn17JT7HE6SxiU,590040
+skimage/restoration/_rolling_ball.py,sha256=VXLGVq0qbkhRjucYjEzqlueBdAWpQfv3aTImjd2FQPY,7086
+skimage/restoration/_rolling_ball_cy.cpython-311-x86_64-linux-gnu.so,sha256=L8pF8ljIkK3YxgNAu71l4l_pikLgDWrXWnPl7SAVThI,276168
+skimage/restoration/_unwrap_1d.cpython-311-x86_64-linux-gnu.so,sha256=ePbKr_y8XVQuPxladEK63Z4C4RJMwYyZwmyOP2tdfro,213696
+skimage/restoration/_unwrap_2d.cpython-311-x86_64-linux-gnu.so,sha256=deN4rl24QBkyvKrU8_GftKrWTwGsIeZWzc-flf4agQk,226624
+skimage/restoration/_unwrap_3d.cpython-311-x86_64-linux-gnu.so,sha256=_Wdo3QnNt1EguNvXLjr2r7f18YfZOqGzeGC2gQPJhOc,239000
+skimage/restoration/deconvolution.py,sha256=NxCcZX0xBigV6vH9Gok2v2sWY20hCVArwwo6BLQjHWw,16321
+skimage/restoration/inpaint.py,sha256=pP46yWaUwb0WoSzMIC035vIXMzkRxfRjAVzE0t-vP5A,12654
+skimage/restoration/j_invariant.py,sha256=AJf8m98Ywyy4-XTOtPIISa9-Dd83gFbZVYCMJgzIZ2E,12421
+skimage/restoration/non_local_means.py,sha256=ftcQMALybovCQn-aJCMCsdmUtZh0BYx5dT9wAVIZFLI,7718
+skimage/restoration/uft.py,sha256=MTWrdzr9x5043YYHfTB-R1LOMIdh2V_AlhavCAYMaKY,12607
+skimage/restoration/unwrap.py,sha256=BxeM0cWdKpQSMCEUR2uzlI5kbTryFtk8tkLBV0zXDn0,4830
+skimage/segmentation/__init__.py,sha256=Y1vmf4_ElM52P0S1frKwKTjhJjlfJ4vSKrtT0lMkwRk,174
+skimage/segmentation/__init__.pyi,sha256=kpbk1PyqKdFniP3lUhiF8opduJPzWZahnoI9TbHvOVY,1522
+skimage/segmentation/__pycache__/__init__.cpython-311.pyc,,
+skimage/segmentation/__pycache__/_chan_vese.cpython-311.pyc,,
+skimage/segmentation/__pycache__/_clear_border.cpython-311.pyc,,
+skimage/segmentation/__pycache__/_expand_labels.cpython-311.pyc,,
+skimage/segmentation/__pycache__/_felzenszwalb.cpython-311.pyc,,
+skimage/segmentation/__pycache__/_join.cpython-311.pyc,,
+skimage/segmentation/__pycache__/_quickshift.cpython-311.pyc,,
+skimage/segmentation/__pycache__/_watershed.cpython-311.pyc,,
+skimage/segmentation/__pycache__/active_contour_model.cpython-311.pyc,,
+skimage/segmentation/__pycache__/boundaries.cpython-311.pyc,,
+skimage/segmentation/__pycache__/morphsnakes.cpython-311.pyc,,
+skimage/segmentation/__pycache__/random_walker_segmentation.cpython-311.pyc,,
+skimage/segmentation/__pycache__/slic_superpixels.cpython-311.pyc,,
+skimage/segmentation/_chan_vese.py,sha256=HHgn7gjE8dOqdAt6QM8zyyYZt1SE_EQDtp73c9Gd09I,13774
+skimage/segmentation/_clear_border.py,sha256=d9JzobF-EdVq6rQh3IhcSNPDW9FJCWDyNUHSOu9fIgE,3989
+skimage/segmentation/_expand_labels.py,sha256=Q8NYU2LYQO5tQ2rXKhg0xpKu-RMwI6WwA_LxrskYlUg,4201
+skimage/segmentation/_felzenszwalb.py,sha256=wl6nKzjrWW_fJw-sFeLDq5fhGVtJlZEBD3W4yu8DbFs,2486
+skimage/segmentation/_felzenszwalb_cy.cpython-311-x86_64-linux-gnu.so,sha256=TeUJaWtXcYq_Wo1peKhg96A71XXRipwiBrfC2_s1et4,154656
+skimage/segmentation/_join.py,sha256=jR2hcXvzWBj1cVb4ipTNhKlSf0iv8W1g4lC32ARc2L4,7134
+skimage/segmentation/_quickshift.py,sha256=jPSH6-X45DTnxEA_17EMo0W2fzEoVpc3G2hY_nzlzzs,3469
+skimage/segmentation/_quickshift_cy.cpython-311-x86_64-linux-gnu.so,sha256=V3jpOW6JveqZPFlkSdX_5q1kK0cWITxwy39fegf4dgM,289432
+skimage/segmentation/_slic.cpython-311-x86_64-linux-gnu.so,sha256=Op3WWMbO9vBqXWk0TuImKe6cD2AeX4WywHtm9AfEmu0,310656
+skimage/segmentation/_watershed.py,sha256=ijTkr539lqQM0_5YOjjxlPOklUcdxibLLfcjEfs1wNY,9870
+skimage/segmentation/_watershed_cy.cpython-311-x86_64-linux-gnu.so,sha256=xMyqhclS-TNPLGxOsBwYjKzjVv6M_i2N-02WxJjqur8,305808
+skimage/segmentation/active_contour_model.py,sha256=4q9Wov7zc_pQDQeotzXlVLC2D-3OmPY011Lw6l_Fru4,7836
+skimage/segmentation/boundaries.py,sha256=-9u_NtiBPAnQBYPSNQY6ywkR2ELNlGKNSC1cVoWBgTE,10016
+skimage/segmentation/morphsnakes.py,sha256=cc7Qm7qzkYUjw4q-2hI1p5yjTrdGfXaHXg71sT0gktY,14882
+skimage/segmentation/random_walker_segmentation.py,sha256=eT1p12CM98AVr4HbvWyF9dvNUBI5nN74BdkpLZvi04g,21712
+skimage/segmentation/slic_superpixels.py,sha256=FLukNVkXZIEaXepIzzFJjLoG0jv2xr1lZqHtaOfGXaU,16353
+skimage/transform/__init__.py,sha256=SjgjAu0K4Tya74fEiJSd5yITbVoH7pe4DGmDcgk4Vrk,1493
+skimage/transform/__init__.pyi,sha256=uDxd4AETK9S_MLmnSXoTTAVNUXCy2idNbiWtW4IavPE,1981
+skimage/transform/__pycache__/__init__.cpython-311.pyc,,
+skimage/transform/__pycache__/_geometric.cpython-311.pyc,,
+skimage/transform/__pycache__/_thin_plate_splines.cpython-311.pyc,,
+skimage/transform/__pycache__/_warps.cpython-311.pyc,,
+skimage/transform/__pycache__/finite_radon_transform.cpython-311.pyc,,
+skimage/transform/__pycache__/hough_transform.cpython-311.pyc,,
+skimage/transform/__pycache__/integral.cpython-311.pyc,,
+skimage/transform/__pycache__/pyramids.cpython-311.pyc,,
+skimage/transform/__pycache__/radon_transform.cpython-311.pyc,,
+skimage/transform/_geometric.py,sha256=TcPS8mxT4jWBIKnjj3ASz7SK9nf2Uia4_eBNG_nUOLo,92577
+skimage/transform/_hough_transform.cpython-311-x86_64-linux-gnu.so,sha256=lwxyO6KZwEHpwz5od43bt-1WSPoK13QuERf4-0AaKlQ,326792
+skimage/transform/_radon_transform.cpython-311-x86_64-linux-gnu.so,sha256=K2GbhmZaZ51fAs2ylR0FCBnT9cmw8IyIz8XR7vsn-oU,263296
+skimage/transform/_thin_plate_splines.py,sha256=u4DJDaI4s2k1oTVMmpfw8H8baYDHzNJrYXQX1fESKGQ,8126
+skimage/transform/_warps.py,sha256=N0mm2yYscJEoXa6kVcZVz8IoR43j63vXjE0ORWTi4J4,49125
+skimage/transform/_warps_cy.cpython-311-x86_64-linux-gnu.so,sha256=1VAJaxneGTs2_JuPTs23JolUpsL2N2TiY_9TK7JrR6g,285480
+skimage/transform/finite_radon_transform.py,sha256=Jln0B-406LJcnpSknQui7xD-igI0-SzO57hGmCkBccw,3179
+skimage/transform/hough_transform.py,sha256=pHkPWtFXDhizWm1SgoozkBJP5_Bay5xr0qsFeXwMoZg,15861
+skimage/transform/integral.py,sha256=FmwuLbJWSCr9B7ljlQ2jCgIom5UFGMiQ5WlcEHwqIZU,5307
+skimage/transform/pyramids.py,sha256=s6eEuuaVfT7gm2U7oPY-IfKradesoVwTKcjFoDkEemU,13357
+skimage/transform/radon_transform.py,sha256=eSv6-NWUa3YiWwtrBfufKBVJPz1aK-Exr2MMqgyPZdg,20732
+skimage/util/__init__.py,sha256=UYvFAYSdpnzsL4sggkfFHFIZXV7thKTvW7-N2y_uKjI,1996
+skimage/util/__pycache__/__init__.cpython-311.pyc,,
+skimage/util/__pycache__/_backends.cpython-311.pyc,,
+skimage/util/__pycache__/_invert.cpython-311.pyc,,
+skimage/util/__pycache__/_label.cpython-311.pyc,,
+skimage/util/__pycache__/_map_array.cpython-311.pyc,,
+skimage/util/__pycache__/_montage.cpython-311.pyc,,
+skimage/util/__pycache__/_regular_grid.cpython-311.pyc,,
+skimage/util/__pycache__/_slice_along_axes.cpython-311.pyc,,
+skimage/util/__pycache__/apply_parallel.cpython-311.pyc,,
+skimage/util/__pycache__/arraycrop.cpython-311.pyc,,
+skimage/util/__pycache__/compare.cpython-311.pyc,,
+skimage/util/__pycache__/dtype.cpython-311.pyc,,
+skimage/util/__pycache__/lookfor.cpython-311.pyc,,
+skimage/util/__pycache__/noise.cpython-311.pyc,,
+skimage/util/__pycache__/shape.cpython-311.pyc,,
+skimage/util/__pycache__/unique.cpython-311.pyc,,
+skimage/util/_backends.py,sha256=H96GV0vEcEP5cZ_kMmnw9SIH7hW5FiM6zFJeVuVz9mA,5195
+skimage/util/_invert.py,sha256=Yb-ML5OWLDxkrZ1KezI0SUUToJoiWmMDNiQ2bhMGYbw,2560
+skimage/util/_label.py,sha256=jECbqvNSezRmyNjpc-RIIYK98XLoSGwz2R60aUA3QrI,1570
+skimage/util/_map_array.py,sha256=qso-jsdTq4TXk6OeeqcduZHV053UV8upbRG0q6Hyz-I,6696
+skimage/util/_montage.py,sha256=w4ZWCYbNo7omK-7APR4IvPVe9yGSIwMWgiiedH1Sa2Y,4753
+skimage/util/_regular_grid.py,sha256=ZPzONVbwy_jK_QWlTqNUW2Wxi9yrvuJblTohugaHVYE,3889
+skimage/util/_remap.cpython-311-x86_64-linux-gnu.so,sha256=7ItLp9xrmPniSLKX7xlKriI5bZbRRflBfb4yhYsiiF4,870648
+skimage/util/_slice_along_axes.py,sha256=GnVxeqAjbDULUc27edh4dBHXFRvsLc0zWkdII7K-G6w,2577
+skimage/util/apply_parallel.py,sha256=RmxuSK7XzT3I09W7HNpmxTeFWB6mNNXl4wlMsvZwrM0,7649
+skimage/util/arraycrop.py,sha256=VY355ZEFWG0LDjdKM4Nr1EeRnp5dkfIVhhJ7fK-r-6w,2486
+skimage/util/compare.py,sha256=Cpv6po1pT29hQaci-8IxfARb8nm5DVSnuo1mgdTjBiI,3119
+skimage/util/dtype.py,sha256=1PmfiJZuTQ276Ao8C4rLOJBkTMX7-3B7qbWpDpEZ5ic,17701
+skimage/util/lookfor.py,sha256=tPU7rswTsW6SGsBlkHYTqUlX6ke2IwbTavWWmFOoIoE,845
+skimage/util/noise.py,sha256=lkRr630o8WBoICibA0qVqtGFObkSMJ2Niij__ASnWuY,8663
+skimage/util/shape.py,sha256=_JqxvcCfpGSCi27jzpbmENBGBrkME6PtWPgBOOZch2s,7828
+skimage/util/unique.py,sha256=ctiKRbgA7Zra5-yA58gKup0fksPuPSHYcx_O_HU711E,1516

envs/kitoverlay/scikit_image-0.26.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_24_x86_64
+Tag: cp311-cp311-manylinux_2_28_x86_64
+

envs/kitoverlay/skimage/__init__.py

@@ -0,0 +1,148 @@
+"""Image Processing for Python
+
+scikit-image (a.k.a. ``skimage``) is a collection of algorithms for image
+processing and computer vision.
+
+Attributes
+----------
+__version__ : str
+    The scikit-image version string.
+
+Subpackages
+-----------
+color
+    Color space conversion.
+data
+    Example images and datasets.
+draw
+    Drawing primitives, such as lines, circles, text, etc.
+exposure
+    Image intensity adjustment, e.g., histogram equalization, etc.
+feature
+    Feature detection and extraction, e.g., texture analysis, corners, etc.
+filters
+    Sharpening, edge finding, rank filters, thresholding, etc.
+future
+    Functionality with an experimental API.
+graph
+    Graph-based operations, e.g., shortest paths.
+io
+    Reading and saving of images and videos.
+measure
+    Measurement of image properties, e.g., region properties, contours.
+metrics
+    Metrics corresponding to images, e.g., distance metrics, similarity, etc.
+morphology
+    Morphological algorithms, e.g., closing, opening, skeletonization.
+registration
+    Image registration algorithms, e.g., optical flow or phase cross correlation.
+restoration
+    Restoration algorithms, e.g., deconvolution algorithms, denoising, etc.
+segmentation
+    Algorithms to partition images into meaningful regions or boundaries.
+transform
+    Geometric and other transformations, e.g., rotations, Radon transform.
+util
+    Generic utilities.
+"""
+
+__version__ = '0.26.0'
+
+import lazy_loader as _lazy
+
+__getattr__, *_ = _lazy.attach_stub(__name__, __file__)
+
+
+# Don't use the `__all__` and `__dir__` returned by `attach_stubs` since that
+# one would expose utility functions we don't want to advertise in our
+# top-level module anymore.
+__all__ = [
+    "__version__",
+    "color",
+    "data",
+    "draw",
+    "exposure",
+    "feature",
+    "filters",
+    "future",
+    "graph",
+    "io",
+    "measure",
+    "metrics",
+    "morphology",
+    "registration",
+    "restoration",
+    "segmentation",
+    "transform",
+    "util",
+]
+
+
+def __dir__():
+    return __all__.copy()
+
+
+# Logic for checking for improper install and importing while in the source
+# tree when package has not been installed inplace.
+# Code adapted from scikit-learn's __check_build module.
+_INPLACE_MSG = """
+It appears that you are importing a local scikit-image source tree. For
+this, you need to have an inplace install. Maybe you are in the source
+directory and you need to try from another location."""
+
+_STANDARD_MSG = """
+Your install of scikit-image appears to be broken.
+Try re-installing the package following the instructions at:
+https://scikit-image.org/docs/stable/user_guide/install.html"""
+
+
+def _raise_build_error(e):
+    # Raise a comprehensible error
+    import os.path as osp
+
+    local_dir = osp.split(__file__)[0]
+    msg = _STANDARD_MSG
+    if local_dir == "skimage":
+        # Picking up the local install: this will work only if the
+        # install is an 'inplace build'
+        msg = _INPLACE_MSG
+    raise ImportError(
+        f"{e}\nIt seems that scikit-image has not been built correctly.\n{msg}"
+    )
+
+
+def _try_append_commit_info(version):
+    """Append last commit date and hash to `version`, if available."""
+    import subprocess
+    from pathlib import Path
+
+    try:
+        output = subprocess.check_output(
+            ['git', 'log', '-1', '--format="%h %aI"'],
+            cwd=Path(__file__).parent,
+            text=True,
+        )
+        if output:
+            git_hash, git_date = (
+                output.strip().replace('"', '').split('T')[0].replace('-', '').split()
+            )
+            version = '+'.join(
+                [tag for tag in version.split('+') if not tag.startswith('git')]
+            )
+            version += f'+git{git_date}.{git_hash}'
+
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+    except OSError:
+        pass  # If skimage is built with emscripten which does not support processes
+
+    return version
+
+
+if 'dev' in __version__:
+    __version__ = _try_append_commit_info(__version__)
+
+
+from skimage._shared.tester import PytestTester as _PytestTester
+
+test = _PytestTester(__name__)

envs/kitoverlay/skimage/__init__.pyi

@@ -0,0 +1,55 @@
+_submodules = [
+    'color',
+    'data',
+    'draw',
+    'exposure',
+    'feature',
+    'filters',
+    'future',
+    'graph',
+    'io',
+    'measure',
+    'metrics',
+    'morphology',
+    'registration',
+    'restoration',
+    'segmentation',
+    'transform',
+    'util',
+]
+
+__all__ = _submodules + ['__version__']  # noqa: F822
+
+from . import (
+    color,
+    data,
+    draw,
+    exposure,
+    feature,
+    filters,
+    future,
+    graph,
+    io,
+    measure,
+    metrics,
+    morphology,
+    registration,
+    restoration,
+    segmentation,
+    transform,
+    util,
+)
+
+# Legacy imports, not advertised in __all__
+from .util.dtype import (
+    dtype_limits,
+    img_as_float32,
+    img_as_float64,
+    img_as_float,
+    img_as_int,
+    img_as_uint,
+    img_as_ubyte,
+    img_as_bool,
+)
+from .util.lookfor import lookfor
+from .data import data_dir

envs/kitoverlay/skimage/_shared/_geometry.py

@@ -0,0 +1,54 @@
+__all__ = ['polygon_clip', 'polygon_area']
+
+import numpy as np
+
+from .version_requirements import require
+
+
+@require("matplotlib", ">=3.3")
+def polygon_clip(rp, cp, r0, c0, r1, c1):
+    """Clip a polygon to the given bounding box.
+
+    Parameters
+    ----------
+    rp, cp : (K,) ndarray of double
+        Row and column coordinates of the polygon.
+    (r0, c0), (r1, c1) : double
+        Top-left and bottom-right coordinates of the bounding box.
+
+    Returns
+    -------
+    r_clipped, c_clipped : (L,) ndarray of double
+        Coordinates of clipped polygon.
+
+    Notes
+    -----
+    This makes use of Sutherland-Hodgman clipping as implemented in
+    AGG 2.4 and exposed in Matplotlib.
+
+    """
+    from matplotlib import path, transforms
+
+    poly = path.Path(np.vstack((rp, cp)).T, closed=True)
+    clip_rect = transforms.Bbox([[r0, c0], [r1, c1]])
+    poly_clipped = poly.clip_to_bbox(clip_rect).to_polygons()[0]
+
+    return poly_clipped[:, 0], poly_clipped[:, 1]
+
+
+def polygon_area(pr, pc):
+    """Compute the area of a polygon.
+
+    Parameters
+    ----------
+    pr, pc : (K,) array of float
+        Polygon row and column coordinates.
+
+    Returns
+    -------
+    a : float
+        Area of the polygon.
+    """
+    pr = np.asarray(pr)
+    pc = np.asarray(pc)
+    return 0.5 * np.abs(np.sum((pc[:-1] * pr[1:]) - (pc[1:] * pr[:-1])))

envs/kitoverlay/skimage/_shared/_tempfile.py

@@ -0,0 +1,28 @@
+from tempfile import NamedTemporaryFile
+from contextlib import contextmanager
+import os
+
+
+@contextmanager
+def temporary_file(suffix=''):
+    """Yield a writeable temporary filename that is deleted on context exit.
+
+    Parameters
+    ----------
+    suffix : str, optional
+        The suffix for the file.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage import io
+    >>> with temporary_file('.tif') as tempfile:
+    ...     im = np.arange(25, dtype=np.uint8).reshape((5, 5))
+    ...     io.imsave(tempfile, im)
+    ...     assert np.all(io.imread(tempfile) == im)
+    """
+    with NamedTemporaryFile(suffix=suffix, delete=False) as tempfile_stream:
+        tempfile = tempfile_stream.name
+
+    yield tempfile
+    os.remove(tempfile)

envs/kitoverlay/skimage/_shared/coord.py

@@ -0,0 +1,124 @@
+import numpy as np
+from scipy.spatial import cKDTree, distance
+
+
+def _ensure_spacing(coord, spacing, p_norm, max_out):
+    """Returns a subset of coord where a minimum spacing is guaranteed.
+
+    Parameters
+    ----------
+    coord : ndarray
+        The coordinates of the considered points.
+    spacing : float
+        the maximum allowed spacing between the points.
+    p_norm : float
+        Which Minkowski p-norm to use. Should be in the range [1, inf].
+        A finite large p may cause a ValueError if overflow can occur.
+        ``inf`` corresponds to the Chebyshev distance and 2 to the
+        Euclidean distance.
+    max_out : int
+        If not None, at most the first ``max_out`` candidates are
+        returned.
+
+    Returns
+    -------
+    output : ndarray
+        A subset of coord where a minimum spacing is guaranteed.
+
+    """
+
+    # Use KDtree to find the peaks that are too close to each other
+    tree = cKDTree(coord)
+
+    indices = tree.query_ball_point(coord, r=spacing, p=p_norm)
+    rejected_peaks_indices = set()
+    naccepted = 0
+    for idx, candidates in enumerate(indices):
+        if idx not in rejected_peaks_indices:
+            # keep current point and the points at exactly spacing from it
+            candidates.remove(idx)
+            dist = distance.cdist(
+                [coord[idx]], coord[candidates], "minkowski", p=p_norm
+            ).reshape(-1)
+            candidates = [c for c, d in zip(candidates, dist) if d < spacing]
+
+            # candidates.remove(keep)
+            rejected_peaks_indices.update(candidates)
+            naccepted += 1
+            if max_out is not None and naccepted >= max_out:
+                break
+
+    # Remove the peaks that are too close to each other
+    output = np.delete(coord, tuple(rejected_peaks_indices), axis=0)
+    if max_out is not None:
+        output = output[:max_out]
+
+    return output
+
+
+def ensure_spacing(
+    coords,
+    spacing=1,
+    p_norm=np.inf,
+    min_split_size=50,
+    max_out=None,
+    *,
+    max_split_size=2000,
+):
+    """Returns a subset of coord where a minimum spacing is guaranteed.
+
+    Parameters
+    ----------
+    coords : array_like
+        The coordinates of the considered points.
+    spacing : float
+        the maximum allowed spacing between the points.
+    p_norm : float
+        Which Minkowski p-norm to use. Should be in the range [1, inf].
+        A finite large p may cause a ValueError if overflow can occur.
+        ``inf`` corresponds to the Chebyshev distance and 2 to the
+        Euclidean distance.
+    min_split_size : int
+        Minimum split size used to process ``coords`` by batch to save
+        memory. If None, the memory saving strategy is not applied.
+    max_out : int
+        If not None, only the first ``max_out`` candidates are returned.
+    max_split_size : int
+        Maximum split size used to process ``coords`` by batch to save
+        memory. This number was decided by profiling with a large number
+        of points. Too small a number results in too much looping in
+        Python instead of C, slowing down the process, while too large
+        a number results in large memory allocations, slowdowns, and,
+        potentially, in the process being killed -- see gh-6010. See
+        benchmark results `here
+        <https://github.com/scikit-image/scikit-image/pull/6035#discussion_r751518691>`_.
+
+    Returns
+    -------
+    output : array_like
+        A subset of coord where a minimum spacing is guaranteed.
+
+    """
+    output = coords
+    if len(coords):
+        coords = np.atleast_2d(coords)
+        if min_split_size is None:
+            batch_list = [coords]
+        else:
+            coord_count = len(coords)
+            split_idx = [min_split_size]
+            split_size = min_split_size
+            while coord_count - split_idx[-1] > max_split_size:
+                split_size *= 2
+                split_idx.append(split_idx[-1] + min(split_size, max_split_size))
+            batch_list = np.array_split(coords, split_idx)
+
+        output = np.zeros((0, coords.shape[1]), dtype=coords.dtype)
+        for batch in batch_list:
+            output = _ensure_spacing(
+                np.vstack([output, batch]), spacing, p_norm, max_out
+            )
+            if max_out is not None and len(output) >= max_out:
+                break
+
+    return output

envs/kitoverlay/skimage/_shared/tester.py

@@ -0,0 +1,131 @@
+import os
+import sys
+
+
+def _show_skimage_info():
+    import skimage
+
+    print(f"skimage version {skimage.__version__}")
+
+
+class PytestTester:
+    """
+    Pytest test runner.
+
+    This class is made available in ``skimage._shared.testing``, and a test
+    function is typically added to a package's __init__.py like so::
+
+      from skimage._shared.testing import PytestTester
+      test = PytestTester(__name__)
+      del PytestTester
+
+    Calling this test function finds and runs all tests associated with the
+    module and all its sub-modules.
+
+    Attributes
+    ----------
+    module_name : str
+        Full path to the package to test.
+
+    Parameters
+    ----------
+    module_name : module name
+        The name of the module to test.
+
+    """
+
+    def __init__(self, module_name):
+        self.module_name = module_name
+
+    def __call__(
+        self,
+        label='fast',
+        verbose=1,
+        extra_argv=None,
+        doctests=False,
+        coverage=False,
+        durations=-1,
+        tests=None,
+    ):
+        """
+        Run tests for module using pytest.
+
+        Parameters
+        ----------
+        label : {'fast', 'full'}, optional
+            Identifies the tests to run. When set to 'fast', tests decorated
+            with `pytest.mark.slow` are skipped, when 'full', the slow marker
+            is ignored.
+        verbose : int, optional
+            Verbosity value for test outputs, in the range 1-3. Default is 1.
+        extra_argv : list, optional
+            List with any extra arguments to pass to pytests.
+        doctests : bool, optional
+            .. note:: Not supported
+        coverage : bool, optional
+            If True, report coverage of scikit-image code. Default is False.
+            Requires installation of (pip) pytest-cov.
+        durations : int, optional
+            If < 0, do nothing, If 0, report time of all tests, if > 0,
+            report the time of the slowest `timer` tests. Default is -1.
+        tests : test or list of tests
+            Tests to be executed with pytest '--pyargs'
+
+        Returns
+        -------
+        result : bool
+            Return True on success, false otherwise.
+        """
+        import pytest
+
+        module = sys.modules[self.module_name]
+        module_path = os.path.abspath(module.__path__[0])
+
+        # setup the pytest arguments
+        pytest_args = ["-l"]
+
+        # offset verbosity. The "-q" cancels a "-v".
+        pytest_args += ["-q"]
+
+        # Filter out annoying import messages. Want these in both develop and
+        # release mode.
+        pytest_args += [
+            "-W ignore:Not importing directory",
+            "-W ignore:numpy.dtype size changed",
+            "-W ignore:numpy.ufunc size changed",
+        ]
+
+        if doctests:
+            raise ValueError("Doctests not supported")
+
+        if extra_argv:
+            pytest_args += list(extra_argv)
+
+        if verbose > 1:
+            pytest_args += ["-" + "v" * (verbose - 1)]
+
+        if coverage:
+            pytest_args += ["--cov=" + module_path]
+
+        if label == "fast":
+            pytest_args += ["-m", "not slow"]
+        elif label != "full":
+            pytest_args += ["-m", label]
+
+        if durations >= 0:
+            pytest_args += [f"--durations={durations}"]
+
+        if tests is None:
+            tests = [self.module_name]
+
+        pytest_args += ["--pyargs"] + list(tests)
+
+        # run tests.
+        _show_skimage_info()
+
+        try:
+            code = pytest.main(pytest_args)
+        except SystemExit as exc:
+            code = exc.code
+
+        return code == 0

envs/kitoverlay/skimage/_shared/version_requirements.py

@@ -0,0 +1,138 @@
+import sys
+
+from packaging import version as _version
+
+
+def _check_version(actver, version, cmp_op):
+    """
+    Check version string of an active module against a required version.
+
+    If dev/prerelease tags result in TypeError for string-number comparison,
+    it is assumed that the dependency is satisfied.
+    Users on dev branches are responsible for keeping their own packages up to
+    date.
+    """
+    try:
+        if cmp_op == '>':
+            return _version.parse(actver) > _version.parse(version)
+        elif cmp_op == '>=':
+            return _version.parse(actver) >= _version.parse(version)
+        elif cmp_op == '=':
+            return _version.parse(actver) == _version.parse(version)
+        elif cmp_op == '<':
+            return _version.parse(actver) < _version.parse(version)
+        else:
+            return False
+    except TypeError:
+        return True
+
+
+def get_module_version(module_name):
+    """Return module version or None if version can't be retrieved."""
+    mod = __import__(module_name, fromlist=[module_name.rpartition('.')[-1]])
+    return getattr(mod, '__version__', getattr(mod, 'VERSION', None))
+
+
+def is_installed(name, version=None):
+    """Test if *name* is installed.
+
+    Parameters
+    ----------
+    name : str
+        Name of module or "python"
+    version : str, optional
+        Version string to test against.
+        If version is not None, checking version
+        (must have an attribute named '__version__' or 'VERSION')
+        Version may start with =, >=, > or < to specify the exact requirement
+
+    Returns
+    -------
+    out : bool
+        True if `name` is installed matching the optional version.
+    """
+    if name.lower() == 'python':
+        actver = sys.version[:6]
+    else:
+        try:
+            actver = get_module_version(name)
+        except ImportError:
+            return False
+    if version is None:
+        return True
+    else:
+        # since version_requirements is in the critical import path,
+        # we lazy import re
+        import re
+
+        match = re.search('[0-9]', version)
+        assert match is not None, "Invalid version number"
+        symb = version[: match.start()]
+        if not symb:
+            symb = '='
+        assert symb in ('>=', '>', '=', '<'), f"Invalid version condition '{symb}'"
+        version = version[match.start() :]
+        return _check_version(actver, version, symb)
+
+
+def require(name, version=None):
+    """Return decorator that forces a requirement for a function or class.
+
+    Parameters
+    ----------
+    name : str
+        Name of module or "python".
+    version : str, optional
+        Version string to test against.
+        If version is not None, checking version
+        (must have an attribute named '__version__' or 'VERSION')
+        Version may start with =, >=, > or < to specify the exact requirement
+
+    Returns
+    -------
+    func : function
+        A decorator that raises an ImportError if a function is run
+        in the absence of the input dependency.
+    """
+    # since version_requirements is in the critical import path, we lazy import
+    # functools
+    import functools
+
+    def decorator(obj):
+        @functools.wraps(obj)
+        def func_wrapped(*args, **kwargs):
+            if is_installed(name, version):
+                return obj(*args, **kwargs)
+            else:
+                msg = f'"{obj}" in "{obj.__module__}" requires "{name}'
+                if version is not None:
+                    msg += f" {version}"
+                raise ImportError(msg + '"')
+
+        return func_wrapped
+
+    return decorator
+
+
+def get_module(module_name, version=None):
+    """Return a module object of name *module_name* if installed.
+
+    Parameters
+    ----------
+    module_name : str
+        Name of module.
+    version : str, optional
+        Version string to test against.
+        If version is not None, checking version
+        (must have an attribute named '__version__' or 'VERSION')
+        Version may start with =, >=, > or < to specify the exact requirement
+
+    Returns
+    -------
+    mod : module or None
+        Module if *module_name* is installed matching the optional version
+        or None otherwise.
+    """
+    if not is_installed(module_name, version):
+        return None
+    return __import__(module_name, fromlist=[module_name.rpartition('.')[-1]])

envs/kitoverlay/skimage/conftest.py

@@ -0,0 +1,17 @@
+"""
+This conftest is required to set the numpy print options
+to legacy mode for doctests
+"""
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def handle_np2():
+    # TODO: remove when we require numpy >= 2
+    try:
+        import numpy as np
+
+        np.set_printoptions(legacy="1.21")
+    except ImportError:
+        pass

envs/kitoverlay/skimage/future/__init__.py

@@ -0,0 +1,13 @@
+"""Functionality with an experimental API.
+
+.. warning::
+    Although you can count on the functions in this package being
+    around in the future, the API may change with any version update
+    **and will not follow the skimage two-version deprecation path**.
+    Therefore, use the functions herein with care, and do not use them
+    in production code that will depend on updated skimage versions.
+"""
+
+import lazy_loader as _lazy
+
+__getattr__, __dir__, __all__ = _lazy.attach_stub(__name__, __file__)

envs/kitoverlay/skimage/future/__init__.pyi

@@ -0,0 +1,14 @@
+# Explicitly setting `__all__` is necessary for type inference engines
+# to know which symbols are exported. See
+# https://peps.python.org/pep-0484/#stub-files
+
+__all__ = [
+    "manual_lasso_segmentation",
+    "manual_polygon_segmentation",
+    "fit_segmenter",
+    "predict_segmenter",
+    "TrainableSegmenter",
+]
+
+from .manual_segmentation import manual_lasso_segmentation, manual_polygon_segmentation
+from .trainable_segmentation import TrainableSegmenter, fit_segmenter, predict_segmenter

envs/kitoverlay/skimage/future/manual_segmentation.py

@@ -0,0 +1,235 @@
+from functools import reduce
+import numpy as np
+from ..draw import polygon
+from .._shared.version_requirements import require
+
+
+LEFT_CLICK = 1
+RIGHT_CLICK = 3
+
+
+def _mask_from_vertices(vertices, shape, label):
+    mask = np.zeros(shape, dtype=int)
+    pr = [y for x, y in vertices]
+    pc = [x for x, y in vertices]
+    rr, cc = polygon(pr, pc, shape)
+    mask[rr, cc] = label
+    return mask
+
+
+@require("matplotlib", ">=3.3")
+def _draw_polygon(ax, vertices, alpha=0.4):
+    from matplotlib.patches import Polygon
+    from matplotlib.collections import PatchCollection
+    import matplotlib.pyplot as plt
+
+    polygon = Polygon(vertices, closed=True)
+    p = PatchCollection([polygon], match_original=True, alpha=alpha)
+    polygon_object = ax.add_collection(p)
+    plt.draw()
+    return polygon_object
+
+
+@require("matplotlib", ">=3.3")
+def manual_polygon_segmentation(image, alpha=0.4, return_all=False):
+    """Return a label image based on polygon selections made with the mouse.
+
+    Parameters
+    ----------
+    image : (M, N[, 3]) array
+        Grayscale or RGB image.
+
+    alpha : float, optional
+        Transparency value for polygons drawn over the image.
+
+    return_all : bool, optional
+        If True, an array containing each separate polygon drawn is returned.
+        (The polygons may overlap.) If False (default), latter polygons
+        "overwrite" earlier ones where they overlap.
+
+    Returns
+    -------
+    labels : array of int, shape ([Q, ]M, N)
+        The segmented regions. If mode is `'separate'`, the leading dimension
+        of the array corresponds to the number of regions that the user drew.
+
+    Notes
+    -----
+    Use left click to select the vertices of the polygon
+    and right click to confirm the selection once all vertices are selected.
+
+    Examples
+    --------
+    >>> from skimage import data, future
+    >>> import matplotlib.pyplot as plt  # doctest: +SKIP
+    >>> camera = data.camera()
+    >>> mask = future.manual_polygon_segmentation(camera)  # doctest: +SKIP
+    >>> fig, ax = plt.subplots()  # doctest: +SKIP
+    >>> ax.imshow(mask)           # doctest: +SKIP
+    >>> plt.show()                # doctest: +SKIP
+    """
+    import matplotlib
+    import matplotlib.pyplot as plt
+
+    list_of_vertex_lists = []
+    polygons_drawn = []
+
+    temp_list = []
+    preview_polygon_drawn = []
+
+    if image.ndim not in (2, 3):
+        raise ValueError('Only 2D grayscale or RGB images are supported.')
+
+    fig, ax = plt.subplots()
+    fig.subplots_adjust(bottom=0.2)
+    ax.imshow(image, cmap="gray")
+    ax.set_axis_off()
+
+    def _undo(*args, **kwargs):
+        if list_of_vertex_lists:
+            list_of_vertex_lists.pop()
+            # Remove last polygon from list of polygons...
+            last_poly = polygons_drawn.pop()
+            # ... then from the plot
+            last_poly.remove()
+            fig.canvas.draw_idle()
+
+    undo_pos = fig.add_axes([0.85, 0.05, 0.075, 0.075])
+    undo_button = matplotlib.widgets.Button(undo_pos, '\u27f2')
+    undo_button.on_clicked(_undo)
+
+    def _extend_polygon(event):
+        # Do not record click events outside axis or in undo button
+        if event.inaxes is None or event.inaxes is undo_pos:
+            return
+        # Do not record click events when toolbar is active
+        if ax.get_navigate_mode():
+            return
+
+        if event.button == LEFT_CLICK:  # Select vertex
+            temp_list.append([event.xdata, event.ydata])
+            # Remove previously drawn preview polygon if any.
+            if preview_polygon_drawn:
+                poly = preview_polygon_drawn.pop()
+                poly.remove()
+
+            # Preview polygon with selected vertices.
+            polygon = _draw_polygon(ax, temp_list, alpha=(alpha / 1.4))
+            preview_polygon_drawn.append(polygon)
+
+        elif event.button == RIGHT_CLICK:  # Confirm the selection
+            if not temp_list:
+                return
+
+            # Store the vertices of the polygon as shown in preview.
+            # Redraw polygon and store it in polygons_drawn so that
+            # `_undo` works correctly.
+            list_of_vertex_lists.append(temp_list[:])
+            polygon_object = _draw_polygon(ax, temp_list, alpha=alpha)
+            polygons_drawn.append(polygon_object)
+
+            # Empty the temporary variables.
+            preview_poly = preview_polygon_drawn.pop()
+            preview_poly.remove()
+            del temp_list[:]
+
+            plt.draw()
+
+    fig.canvas.mpl_connect('button_press_event', _extend_polygon)
+
+    plt.show(block=True)
+
+    labels = (
+        _mask_from_vertices(vertices, image.shape[:2], i)
+        for i, vertices in enumerate(list_of_vertex_lists, start=1)
+    )
+    if return_all:
+        return np.stack(labels)
+    else:
+        return reduce(np.maximum, labels, np.broadcast_to(0, image.shape[:2]))
+
+
+@require("matplotlib", ">=3.3")
+def manual_lasso_segmentation(image, alpha=0.4, return_all=False):
+    """Return a label image based on freeform selections made with the mouse.
+
+    Parameters
+    ----------
+    image : (M, N[, 3]) array
+        Grayscale or RGB image.
+
+    alpha : float, optional
+        Transparency value for polygons drawn over the image.
+
+    return_all : bool, optional
+        If True, an array containing each separate polygon drawn is returned.
+        (The polygons may overlap.) If False (default), latter polygons
+        "overwrite" earlier ones where they overlap.
+
+    Returns
+    -------
+    labels : array of int, shape ([Q, ]M, N)
+        The segmented regions. If mode is `'separate'`, the leading dimension
+        of the array corresponds to the number of regions that the user drew.
+
+    Notes
+    -----
+    Press and hold the left mouse button to draw around each object.
+
+    Examples
+    --------
+    >>> from skimage import data, future
+    >>> import matplotlib.pyplot as plt  # doctest: +SKIP
+    >>> camera = data.camera()
+    >>> mask = future.manual_lasso_segmentation(camera)  # doctest: +SKIP
+    >>> fig, ax = plt.subplots()  # doctest: +SKIP
+    >>> ax.imshow(mask)           # doctest: +SKIP
+    >>> plt.show()                # doctest: +SKIP
+    """
+    import matplotlib
+    import matplotlib.pyplot as plt
+
+    list_of_vertex_lists = []
+    polygons_drawn = []
+
+    if image.ndim not in (2, 3):
+        raise ValueError('Only 2D grayscale or RGB images are supported.')
+
+    fig, ax = plt.subplots()
+    fig.subplots_adjust(bottom=0.2)
+    ax.imshow(image, cmap="gray")
+    ax.set_axis_off()
+
+    def _undo(*args, **kwargs):
+        if list_of_vertex_lists:
+            list_of_vertex_lists.pop()
+            # Remove last polygon from list of polygons...
+            last_poly = polygons_drawn.pop()
+            # ... then from the plot
+            last_poly.remove()
+            fig.canvas.draw_idle()
+
+    undo_pos = fig.add_axes([0.85, 0.05, 0.075, 0.075])
+    undo_button = matplotlib.widgets.Button(undo_pos, '\u27f2')
+    undo_button.on_clicked(_undo)
+
+    def _on_lasso_selection(vertices):
+        if len(vertices) < 3:
+            return
+        list_of_vertex_lists.append(vertices)
+        polygon_object = _draw_polygon(ax, vertices, alpha=alpha)
+        polygons_drawn.append(polygon_object)
+        plt.draw()
+
+    matplotlib.widgets.LassoSelector(ax, _on_lasso_selection)
+
+    plt.show(block=True)
+
+    labels = (
+        _mask_from_vertices(vertices, image.shape[:2], i)
+        for i, vertices in enumerate(list_of_vertex_lists, start=1)
+    )
+    if return_all:
+        return np.stack(labels)
+    else:
+        return reduce(np.maximum, labels, np.broadcast_to(0, image.shape[:2]))

envs/kitoverlay/skimage/future/trainable_segmentation.py

@@ -0,0 +1,164 @@
+from skimage.feature import multiscale_basic_features
+
+try:
+    from sklearn.exceptions import NotFittedError
+    from sklearn.ensemble import RandomForestClassifier
+
+    has_sklearn = True
+except ImportError:
+    has_sklearn = False
+
+    class NotFittedError(Exception):
+        pass
+
+
+class TrainableSegmenter:
+    """Estimator for classifying pixels.
+
+    Parameters
+    ----------
+    clf : classifier object, optional
+        classifier object, exposing a ``fit`` and a ``predict`` method as in
+        scikit-learn's API, for example an instance of
+        ``RandomForestClassifier`` or ``LogisticRegression`` classifier.
+    features_func : function, optional
+        function computing features on all pixels of the image, to be passed
+        to the classifier. The output should be of shape
+        ``(m_features, *labels.shape)``. If None,
+        :func:`skimage.feature.multiscale_basic_features` is used.
+
+    Methods
+    -------
+    compute_features
+    fit
+    predict
+    """
+
+    def __init__(self, clf=None, features_func=None):
+        if clf is None:
+            if has_sklearn:
+                self.clf = RandomForestClassifier(n_estimators=100, n_jobs=-1)
+            else:
+                raise ImportError(
+                    "Please install scikit-learn or pass a classifier instance"
+                    "to TrainableSegmenter."
+                )
+        else:
+            self.clf = clf
+        self.features_func = features_func
+
+    def compute_features(self, image):
+        if self.features_func is None:
+            self.features_func = multiscale_basic_features
+        self.features = self.features_func(image)
+
+    def fit(self, image, labels):
+        """Train classifier using partially labeled (annotated) image.
+
+        Parameters
+        ----------
+        image : ndarray
+            Input image, which can be grayscale or multichannel, and must have a
+            number of dimensions compatible with ``self.features_func``.
+        labels : ndarray of ints
+            Labeled array of shape compatible with ``image`` (same shape for a
+            single-channel image). Labels >= 1 correspond to the training set and
+            label 0 to unlabeled pixels to be segmented.
+        """
+        self.compute_features(image)
+        fit_segmenter(labels, self.features, self.clf)
+
+    def predict(self, image):
+        """Segment new image using trained internal classifier.
+
+        Parameters
+        ----------
+        image : ndarray
+            Input image, which can be grayscale or multichannel, and must have a
+            number of dimensions compatible with ``self.features_func``.
+
+        Raises
+        ------
+        NotFittedError if ``self.clf`` has not been fitted yet (use ``self.fit``).
+        """
+        if self.features_func is None:
+            self.features_func = multiscale_basic_features
+        features = self.features_func(image)
+        return predict_segmenter(features, self.clf)
+
+
+def fit_segmenter(labels, features, clf):
+    """Segmentation using labeled parts of the image and a classifier.
+
+    Parameters
+    ----------
+    labels : ndarray of ints
+        Image of labels. Labels >= 1 correspond to the training set and
+        label 0 to unlabeled pixels to be segmented.
+    features : ndarray
+        Array of features, with the first dimension corresponding to the number
+        of features, and the other dimensions correspond to ``labels.shape``.
+    clf : classifier object
+        classifier object, exposing a ``fit`` and a ``predict`` method as in
+        scikit-learn's API, for example an instance of
+        ``RandomForestClassifier`` or ``LogisticRegression`` classifier.
+
+    Returns
+    -------
+    clf : classifier object
+        classifier trained on ``labels``
+
+    Raises
+    ------
+    NotFittedError if ``self.clf`` has not been fitted yet (use ``self.fit``).
+    """
+    mask = labels > 0
+    training_data = features[mask]
+    training_labels = labels[mask].ravel()
+    clf.fit(training_data, training_labels)
+    return clf
+
+
+def predict_segmenter(features, clf):
+    """Segmentation of images using a pretrained classifier.
+
+    Parameters
+    ----------
+    features : ndarray
+        Array of features, with the last dimension corresponding to the number
+        of features, and the other dimensions are compatible with the shape of
+        the image to segment, or a flattened image.
+    clf : classifier object
+        trained classifier object, exposing a ``predict`` method as in
+        scikit-learn's API, for example an instance of
+        ``RandomForestClassifier`` or ``LogisticRegression`` classifier. The
+        classifier must be already trained, for example with
+        :func:`skimage.future.fit_segmenter`.
+
+    Returns
+    -------
+    output : ndarray
+        Labeled array, built from the prediction of the classifier.
+    """
+    sh = features.shape
+    if features.ndim > 2:
+        features = features.reshape((-1, sh[-1]))
+
+    try:
+        predicted_labels = clf.predict(features)
+    except NotFittedError:
+        raise NotFittedError(
+            "You must train the classifier `clf` first"
+            "for example with the `fit_segmenter` function."
+        )
+    except ValueError as err:
+        if err.args and 'x must consist of vectors of length' in err.args[0]:
+            raise ValueError(
+                err.args[0]
+                + '\n'
+                + "Maybe you did not use the same type of features for training the classifier."
+            )
+        else:
+            raise err
+    output = predicted_labels.reshape(sh[:-1])
+    return output

envs/kitoverlay/tifffile/__init__.py

@@ -0,0 +1,9 @@
+# tifffile/__init__.py
+
+from .tifffile import *
+from .tifffile import __all__, __doc__, __version__, main
+
+# constants are repeated for documentation
+
+__version__ = __version__
+"""Tifffile version string."""

envs/kitoverlay/tifffile/__main__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+# tifffile/__main__.py
+
+"""Display image and metadata in TIFF file."""
+
+from __future__ import annotations
+
+import sys
+
+from .tifffile import main
+
+sys.exit(main())

envs/kitoverlay/tifffile/_imagecodecs.py

@@ -0,0 +1,587 @@
+# tifffile/_imagecodecs.py
+
+# Copyright (c) 2008-2026, Christoph Gohlke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""Fallback imagecodecs codecs.
+
+This module provides alternative, pure Python and NumPy implementations of
+some functions of the `imagecodecs`_ package. The functions may raise
+`NotImplementedError`.
+
+.. _imagecodecs: https://github.com/cgohlke/imagecodecs
+
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    'bitorder_decode',
+    'delta_decode',
+    'delta_encode',
+    'float24_decode',
+    'lzma_decode',
+    'lzma_encode',
+    'packbits_decode',
+    'packints_decode',
+    'packints_encode',
+    'zlib_decode',
+    'zlib_encode',
+    'zstd_decode',
+    'zstd_encode',
+]
+
+from typing import TYPE_CHECKING, overload
+
+import numpy
+
+if TYPE_CHECKING:
+    from typing import Any, Literal
+
+    from numpy.typing import ArrayLike, DTypeLike, NDArray
+
+try:
+    import lzma
+
+    def lzma_encode(
+        data: bytes | NDArray[Any],
+        /,
+        level: int | None = None,
+        *,
+        out: Any = None,
+    ) -> bytes:
+        """Compress LZMA.
+
+        Parameters:
+            data: Data to compress.
+            level: Compression level (currently unused).
+            out: Output buffer (currently unused).
+
+        """
+        del level, out  # unused
+        if isinstance(data, numpy.ndarray):
+            data = data.tobytes()
+        return lzma.compress(data)
+
+    def lzma_decode(data: bytes, /, *, out: Any = None) -> bytes:
+        """Decompress LZMA.
+
+        Parameters:
+            data: Compressed data.
+            out: Output buffer (currently unused).
+
+        """
+        del out  # unused
+        return lzma.decompress(data)
+
+except ImportError:
+    # Python was built without lzma
+    def lzma_encode(
+        data: bytes | NDArray[Any],
+        /,
+        level: int | None = None,
+        *,
+        out: Any = None,
+    ) -> bytes:
+        """Raise ImportError."""
+        del data, level, out  # unused
+        import lzma  # noqa: F401
+
+        return b''
+
+    def lzma_decode(data: bytes, /, *, out: Any = None) -> bytes:
+        """Raise ImportError."""
+        del data, out  # unused
+        import lzma  # noqa: F401
+
+        return b''
+
+
+try:
+    import zlib
+
+    def zlib_encode(
+        data: bytes | NDArray[Any],
+        /,
+        level: int | None = None,
+        *,
+        out: Any = None,
+    ) -> bytes:
+        """Compress Zlib DEFLATE.
+
+        Parameters:
+            data: Data to compress.
+            level: Compression level (0-9, default 6).
+            out: Output buffer (currently unused).
+
+        """
+        del out  # unused
+        if isinstance(data, numpy.ndarray):
+            data = data.tobytes()
+        return zlib.compress(data, 6 if level is None else level)
+
+    def zlib_decode(data: bytes, /, *, out: Any = None) -> bytes:
+        """Decompress Zlib DEFLATE.
+
+        Parameters:
+            data: Compressed data.
+            out: Output buffer (currently unused).
+
+        """
+        del out  # unused
+        return zlib.decompress(data)
+
+except ImportError:
+    # Python was built without zlib
+
+    def zlib_encode(
+        data: bytes | NDArray[Any],
+        /,
+        level: int | None = None,
+        *,
+        out: Any = None,
+    ) -> bytes:
+        """Raise ImportError."""
+        del data, level, out  # unused
+        import zlib  # noqa: F401
+
+        return b''
+
+    def zlib_decode(data: bytes, /, *, out: Any = None) -> bytes:
+        """Raise ImportError."""
+        del data, out  # unused
+        import zlib  # noqa: F401
+
+        return b''
+
+
+try:
+    from compression import zstd
+
+    def zstd_encode(
+        data: bytes | NDArray[Any],
+        /,
+        level: int | None = None,
+        *,
+        out: Any = None,
+    ) -> bytes:
+        """Compress ZSTD.
+
+        Parameters:
+            data: Data to compress.
+            level: Compression level.
+            out: Output buffer (currently unused).
+
+        """
+        del out  # unused
+        if isinstance(data, numpy.ndarray):
+            data = data.tobytes()
+        return zstd.compress(data, level=level)
+
+    def zstd_decode(data: bytes, /, *, out: Any = None) -> bytes:
+        """Decompress ZSTD.
+
+        Parameters:
+            data: Compressed data.
+            out: Output buffer (currently unused).
+
+        """
+        del out  # unused
+        return zstd.decompress(data)
+
+except ImportError:
+    # Python was built without zstd
+    def zstd_encode(
+        data: bytes | NDArray[Any],
+        /,
+        level: int | None = None,
+        *,
+        out: Any = None,
+    ) -> bytes:
+        """Raise ImportError."""
+        del data, level, out  # unused
+        from compression import zstd  # noqa: F401
+
+        return b''
+
+    def zstd_decode(data: bytes, /, *, out: Any = None) -> bytes:
+        """Raise ImportError."""
+        del data, out  # unused
+        from compression import zstd  # noqa: F401
+
+        return b''
+
+
+def packbits_decode(encoded: bytes, /, *, out: Any = None) -> bytes:
+    r"""Decompress PackBits encoded byte string.
+
+    Parameters:
+        encoded: PackBits encoded byte string.
+        out: Output buffer (currently unused).
+
+    Returns:
+        Decompressed byte string.
+
+    Examples:
+        >>> packbits_decode(b'\x80\x80')  # NOP
+        b''
+        >>> packbits_decode(b'\x02123')
+        b'123'
+        >>> packbits_decode(
+        ...     b'\xfe\xaa\x02\x80\x00\x2a\xfd\xaa\x03\x80\x00\x2a\x22\xf7\xaa'
+        ... )[:-5]
+        b'\xaa\xaa\xaa\x80\x00*\xaa\xaa\xaa\xaa\x80\x00*"\xaa\xaa\xaa\xaa\xaa'
+
+    """
+    del out  # unused
+    out = []
+    out_extend = out.extend
+    i = 0
+    try:
+        while True:
+            n = ord(encoded[i : i + 1]) + 1
+            i += 1
+            if n > 129:
+                # replicate
+                out_extend(encoded[i : i + 1] * (258 - n))
+                i += 1
+            elif n < 129:
+                # literal
+                out_extend(encoded[i : i + n])
+                i += n
+    except TypeError:
+        pass
+    return bytes(out)
+
+
+@overload
+def delta_encode(
+    data: bytes | bytearray,
+    /,
+    axis: int = -1,
+    dist: int = 1,
+    *,
+    out: Any = None,
+) -> bytes: ...
+
+
+@overload
+def delta_encode(
+    data: NDArray[Any], /, axis: int = -1, dist: int = 1, *, out: Any = None
+) -> NDArray[Any]: ...
+
+
+def delta_encode(
+    data: bytes | bytearray | NDArray[Any],
+    /,
+    axis: int = -1,
+    dist: int = 1,
+    *,
+    out: Any = None,
+) -> bytes | NDArray[Any]:
+    """Encode Delta.
+
+    Encode differences between consecutive samples along axis.
+
+    Parameters:
+        data: Data to encode.
+        axis: Axis along which to compute differences (default -1).
+        dist: Distance between samples (only dist=1 is supported).
+        out: Output buffer (currently unused).
+
+    Returns:
+        Encoded data.
+        Returns bytes for bytes/bytearray input, numpy array otherwise.
+
+    """
+    del out  # unused
+    if dist != 1:
+        msg = f"delta_encode with {dist=} requires the 'imagecodecs' package"
+        raise NotImplementedError(msg)
+    if isinstance(data, (bytes, bytearray)):
+        data = numpy.frombuffer(data, dtype=numpy.uint8)
+        diff = numpy.diff(data, axis=0)
+        return numpy.insert(diff, 0, data[0]).tobytes()
+
+    dtype = data.dtype
+    if dtype.kind == 'f':
+        data = data.view(f'{dtype.byteorder}u{dtype.itemsize}')
+    diff = numpy.diff(data, axis=axis)
+    key: list[int | slice] = [slice(None)] * data.ndim
+    key[axis] = 0
+    diff = numpy.insert(diff, 0, data[tuple(key)], axis=axis)
+    if not data.dtype.isnative:
+        diff = diff.byteswap(inplace=True)
+        diff = diff.view(diff.dtype.newbyteorder())
+    if dtype.kind == 'f':
+        return diff.view(dtype)
+    return diff
+
+
+@overload
+def delta_decode(
+    data: bytes | bytearray, /, axis: int, dist: int, *, out: Any
+) -> bytes: ...
+
+
+@overload
+def delta_decode(
+    data: NDArray[Any], /, axis: int, dist: int, *, out: Any
+) -> NDArray[Any]: ...
+
+
+def delta_decode(
+    data: bytes | bytearray | NDArray[Any],
+    /,
+    axis: int = -1,
+    dist: int = 1,
+    *,
+    out: Any = None,
+) -> bytes | NDArray[Any]:
+    """Decode Delta.
+
+    Decode delta-encoded data by computing cumulative sum along axis.
+
+    Parameters:
+        data: Encoded data.
+        axis: Axis along which to compute cumulative sum (default -1).
+        dist: Distance between samples (only dist=1 is supported).
+        out: Output buffer for results.
+
+    Returns:
+        Decoded data.
+        Returns bytes for bytes/bytearray input, numpy array otherwise.
+
+    """
+    if dist != 1:
+        msg = f"delta_decode with {dist=} requires the 'imagecodecs' package"
+        raise NotImplementedError(msg)
+    if out is not None and not out.flags.writeable:
+        out = None
+    if isinstance(data, (bytes, bytearray)):
+        data = numpy.frombuffer(data, dtype=numpy.uint8)
+        return numpy.cumsum(  # type: ignore[no-any-return]
+            data, axis=0, dtype=numpy.uint8, out=out
+        ).tobytes()
+    if data.dtype.kind == 'f':
+        if not data.dtype.isnative:
+            msg = (
+                f'delta_decode with {data.dtype!r} '
+                "requires the 'imagecodecs' package"
+            )
+            raise NotImplementedError(msg)
+        view = data.view(f'{data.dtype.byteorder}u{data.dtype.itemsize}')
+        view = numpy.cumsum(view, axis=axis, dtype=view.dtype)
+        return view.view(data.dtype)
+    return numpy.cumsum(  # type: ignore[no-any-return]
+        data, axis=axis, dtype=data.dtype, out=out
+    )
+
+
+@overload
+def bitorder_decode(
+    data: bytearray,
+    /,
+    *,
+    out: Any = None,
+    _bitorder: list[Any] = [],  # noqa: B006
+) -> bytearray: ...
+
+
+@overload
+def bitorder_decode(
+    data: bytes,
+    /,
+    *,
+    out: Any = None,
+    _bitorder: list[Any] = [],  # noqa: B006
+) -> bytes: ...
+
+
+@overload
+def bitorder_decode(
+    data: NDArray[Any],
+    /,
+    *,
+    out: Any = None,
+    _bitorder: list[Any] = [],  # noqa: B006
+) -> NDArray[Any]: ...
+
+
+def bitorder_decode(
+    data: bytes | bytearray | NDArray[Any],
+    /,
+    *,
+    out: Any = None,
+    _bitorder: list[Any] = [],  # noqa: B006
+) -> bytes | bytearray | NDArray[Any]:
+    r"""Reverse bits in each byte of bytes or numpy array.
+
+    Decode data where pixels with lower column values are stored in the
+    lower-order bits of the bytes (TIFF FillOrder is LSB2MSB).
+
+    Parameters:
+        data:
+            Data to be bit-reversed.
+            If bytes type, a new bit-reversed bytes is returned.
+            NumPy arrays are bit-reversed in-place.
+        out:
+            Output buffer (currently unused).
+        _bitorder:
+            Internal caching parameter (not for public use).
+
+    Examples:
+        >>> bitorder_decode(b'\x01\x64')
+        b'\x80&'
+        >>> data = numpy.array([1, 666], dtype='uint16')
+        >>> _ = bitorder_decode(data)
+        >>> data
+        array([  128, 16473], dtype=uint16)
+
+    """
+    del out  # unused
+    if not _bitorder:
+        _bitorder.append(
+            b'\x00\x80@\xc0 \xa0`\xe0\x10\x90P\xd00\xb0p\xf0\x08\x88H'
+            b'\xc8(\xa8h\xe8\x18\x98X\xd88\xb8x\xf8\x04\x84D\xc4$\xa4d'
+            b'\xe4\x14\x94T\xd44\xb4t\xf4\x0c\x8cL\xcc,\xacl\xec\x1c\x9c'
+            b'\\\xdc<\xbc|\xfc\x02\x82B\xc2"\xa2b\xe2\x12\x92R\xd22'
+            b'\xb2r\xf2\n\x8aJ\xca*\xaaj\xea\x1a\x9aZ\xda:\xbaz\xfa'
+            b'\x06\x86F\xc6&\xa6f\xe6\x16\x96V\xd66\xb6v\xf6\x0e\x8eN'
+            b'\xce.\xaen\xee\x1e\x9e^\xde>\xbe~\xfe\x01\x81A\xc1!\xa1a'
+            b'\xe1\x11\x91Q\xd11\xb1q\xf1\t\x89I\xc9)\xa9i\xe9\x19'
+            b'\x99Y\xd99\xb9y\xf9\x05\x85E\xc5%\xa5e\xe5\x15\x95U\xd55'
+            b'\xb5u\xf5\r\x8dM\xcd-\xadm\xed\x1d\x9d]\xdd=\xbd}\xfd'
+            b'\x03\x83C\xc3#\xa3c\xe3\x13\x93S\xd33\xb3s\xf3\x0b\x8bK'
+            b"\xcb+\xabk\xeb\x1b\x9b[\xdb;\xbb{\xfb\x07\x87G\xc7'\xa7g"
+            b'\xe7\x17\x97W\xd77\xb7w\xf7\x0f\x8fO\xcf/\xafo\xef\x1f\x9f_'
+            b'\xdf?\xbf\x7f\xff'
+        )
+        _bitorder.append(numpy.frombuffer(_bitorder[0], dtype=numpy.uint8))
+    if isinstance(data, (bytes, bytearray)):
+        return data.translate(_bitorder[0])
+    try:
+        view = data.view('uint8')
+        numpy.take(_bitorder[1], view, out=view)
+    except ValueError as exc:
+        msg = "bitorder_decode of slices requires the 'imagecodecs' package"
+        raise NotImplementedError(msg) from exc
+    return data
+
+
+def packints_decode(
+    data: bytes,
+    /,
+    dtype: DTypeLike | None,
+    bitspersample: int,
+    runlen: int = 0,
+    *,
+    out: Any = None,
+) -> NDArray[Any]:
+    """Decompress bytes to array of integers.
+
+    This implementation only handles itemsizes 1, 8, 16, 32, and 64 bits.
+    Install the Imagecodecs package for decoding other integer sizes.
+
+    Parameters:
+        data:
+            Data to decompress.
+        dtype:
+            Numpy boolean or integer type.
+        bitspersample:
+            Number of bits per integer.
+        runlen:
+            Number of consecutive integers after which to start at next byte.
+        out:
+            Output buffer (currently unused).
+
+    Returns:
+        Array of unpacked integers.
+
+    Examples:
+        >>> packints_decode(b'a', 'B', 1)
+        array([0, 1, 1, 0, 0, 0, 0, 1], dtype=uint8)
+
+    """
+    del out  # unused
+    if bitspersample == 1:  # bitarray
+        data_array = numpy.frombuffer(data, '|B')
+        data_array = numpy.unpackbits(data_array)
+        if runlen > 0 and runlen % 8:
+            data_array = data_array.reshape((-1, runlen + (8 - runlen % 8)))
+            data_array = data_array[:, :runlen].reshape(-1)
+        return data_array.astype(dtype)
+    if bitspersample in (8, 16, 32, 64):
+        return numpy.frombuffer(data, dtype)
+    msg = (
+        f'packints_decode of {bitspersample}-bit integers '
+        "requires the 'imagecodecs' package"
+    )
+    raise NotImplementedError(msg)
+
+
+def packints_encode(
+    data: ArrayLike,
+    bitspersample: int,
+    /,
+    *,
+    axis: int = -1,
+    out: Any = None,
+) -> bytes | bytearray:
+    """Tightly pack integers.
+
+    Parameters:
+        data: Array of integers to pack.
+        bitspersample: Number of bits per integer.
+        axis: Axis along which to pack.
+        out: Output buffer.
+
+    Returns:
+        Packed byte string.
+
+    """
+    msg = "packints_encode requires the 'imagecodecs' package"
+    raise NotImplementedError(msg)
+
+
+def float24_decode(
+    data: bytes, /, byteorder: Literal['>', '<']
+) -> NDArray[Any]:
+    """Return float32 array from float24.
+
+    Parameters:
+        data: Bytes containing float24 values.
+        byteorder: Byte order, either '>' (big-endian) or '<' (little-endian).
+
+    Returns:
+        Array of float32 values.
+
+    """
+    msg = "float24_decode requires the 'imagecodecs' package"
+    raise NotImplementedError(msg)

envs/kitoverlay/tifffile/geodb.py

@@ -0,0 +1,2080 @@
+# tifffile/geodb.py
+
+"""GeoTIFF GeoKey Database.
+
+Adapted from http://gis.ess.washington.edu/data/raster/drg/docs/geotiff.txt
+
+"""
+
+from __future__ import annotations
+
+import enum
+
+
+class GeoKeys(enum.IntEnum):
+    """Geo keys."""
+
+    GTModelTypeGeoKey = 1024
+    GTRasterTypeGeoKey = 1025
+    GTCitationGeoKey = 1026
+    GeographicTypeGeoKey = 2048
+    GeogCitationGeoKey = 2049
+    GeogGeodeticDatumGeoKey = 2050
+    GeogPrimeMeridianGeoKey = 2051
+    GeogLinearUnitsGeoKey = 2052
+    GeogLinearUnitSizeGeoKey = 2053
+    GeogAngularUnitsGeoKey = 2054
+    GeogAngularUnitsSizeGeoKey = 2055
+    GeogEllipsoidGeoKey = 2056
+    GeogSemiMajorAxisGeoKey = 2057
+    GeogSemiMinorAxisGeoKey = 2058
+    GeogInvFlatteningGeoKey = 2059
+    GeogAzimuthUnitsGeoKey = 2060
+    GeogPrimeMeridianLongGeoKey = 2061
+    GeogTOWGS84GeoKey = 2062
+    ProjLinearUnitsInterpCorrectGeoKey = 3059  # GDAL
+    ProjectedCSTypeGeoKey = 3072
+    PCSCitationGeoKey = 3073
+    ProjectionGeoKey = 3074
+    ProjCoordTransGeoKey = 3075
+    ProjLinearUnitsGeoKey = 3076
+    ProjLinearUnitSizeGeoKey = 3077
+    ProjStdParallel1GeoKey = 3078
+    ProjStdParallel2GeoKey = 3079
+    ProjNatOriginLongGeoKey = 3080
+    ProjNatOriginLatGeoKey = 3081
+    ProjFalseEastingGeoKey = 3082
+    ProjFalseNorthingGeoKey = 3083
+    ProjFalseOriginLongGeoKey = 3084
+    ProjFalseOriginLatGeoKey = 3085
+    ProjFalseOriginEastingGeoKey = 3086
+    ProjFalseOriginNorthingGeoKey = 3087
+    ProjCenterLongGeoKey = 3088
+    ProjCenterLatGeoKey = 3089
+    ProjCenterEastingGeoKey = 3090
+    ProjCenterNorthingGeoKey = 3091
+    ProjScaleAtNatOriginGeoKey = 3092
+    ProjScaleAtCenterGeoKey = 3093
+    ProjAzimuthAngleGeoKey = 3094
+    ProjStraightVertPoleLongGeoKey = 3095
+    ProjRectifiedGridAngleGeoKey = 3096
+    VerticalCSTypeGeoKey = 4096
+    VerticalCitationGeoKey = 4097
+    VerticalDatumGeoKey = 4098
+    VerticalUnitsGeoKey = 4099
+
+
+class Proj(enum.IntEnum):
+    """Projection Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Alabama_CS27_East = 10101
+    Alabama_CS27_West = 10102
+    Alabama_CS83_East = 10131
+    Alabama_CS83_West = 10132
+    Arizona_Coordinate_System_east = 10201
+    Arizona_Coordinate_System_Central = 10202
+    Arizona_Coordinate_System_west = 10203
+    Arizona_CS83_east = 10231
+    Arizona_CS83_Central = 10232
+    Arizona_CS83_west = 10233
+    Arkansas_CS27_North = 10301
+    Arkansas_CS27_South = 10302
+    Arkansas_CS83_North = 10331
+    Arkansas_CS83_South = 10332
+    California_CS27_I = 10401
+    California_CS27_II = 10402
+    California_CS27_III = 10403
+    California_CS27_IV = 10404
+    California_CS27_V = 10405
+    California_CS27_VI = 10406
+    California_CS27_VII = 10407
+    California_CS83_1 = 10431
+    California_CS83_2 = 10432
+    California_CS83_3 = 10433
+    California_CS83_4 = 10434
+    California_CS83_5 = 10435
+    California_CS83_6 = 10436
+    Colorado_CS27_North = 10501
+    Colorado_CS27_Central = 10502
+    Colorado_CS27_South = 10503
+    Colorado_CS83_North = 10531
+    Colorado_CS83_Central = 10532
+    Colorado_CS83_South = 10533
+    Connecticut_CS27 = 10600
+    Connecticut_CS83 = 10630
+    Delaware_CS27 = 10700
+    Delaware_CS83 = 10730
+    Florida_CS27_East = 10901
+    Florida_CS27_West = 10902
+    Florida_CS27_North = 10903
+    Florida_CS83_East = 10931
+    Florida_CS83_West = 10932
+    Florida_CS83_North = 10933
+    Georgia_CS27_East = 11001
+    Georgia_CS27_West = 11002
+    Georgia_CS83_East = 11031
+    Georgia_CS83_West = 11032
+    Idaho_CS27_East = 11101
+    Idaho_CS27_Central = 11102
+    Idaho_CS27_West = 11103
+    Idaho_CS83_East = 11131
+    Idaho_CS83_Central = 11132
+    Idaho_CS83_West = 11133
+    Illinois_CS27_East = 11201
+    Illinois_CS27_West = 11202
+    Illinois_CS83_East = 11231
+    Illinois_CS83_West = 11232
+    Indiana_CS27_East = 11301
+    Indiana_CS27_West = 11302
+    Indiana_CS83_East = 11331
+    Indiana_CS83_West = 11332
+    Iowa_CS27_North = 11401
+    Iowa_CS27_South = 11402
+    Iowa_CS83_North = 11431
+    Iowa_CS83_South = 11432
+    Kansas_CS27_North = 11501
+    Kansas_CS27_South = 11502
+    Kansas_CS83_North = 11531
+    Kansas_CS83_South = 11532
+    Kentucky_CS27_North = 11601
+    Kentucky_CS27_South = 11602
+    Kentucky_CS83_North = 15303
+    Kentucky_CS83_South = 11632
+    Louisiana_CS27_North = 11701
+    Louisiana_CS27_South = 11702
+    Louisiana_CS83_North = 11731
+    Louisiana_CS83_South = 11732
+    Maine_CS27_East = 11801
+    Maine_CS27_West = 11802
+    Maine_CS83_East = 11831
+    Maine_CS83_West = 11832
+    Maryland_CS27 = 11900
+    Maryland_CS83 = 11930
+    Massachusetts_CS27_Mainland = 12001
+    Massachusetts_CS27_Island = 12002
+    Massachusetts_CS83_Mainland = 12031
+    Massachusetts_CS83_Island = 12032
+    Michigan_State_Plane_East = 12101
+    Michigan_State_Plane_Old_Central = 12102
+    Michigan_State_Plane_West = 12103
+    Michigan_CS27_North = 12111
+    Michigan_CS27_Central = 12112
+    Michigan_CS27_South = 12113
+    Michigan_CS83_North = 12141
+    Michigan_CS83_Central = 12142
+    Michigan_CS83_South = 12143
+    Minnesota_CS27_North = 12201
+    Minnesota_CS27_Central = 12202
+    Minnesota_CS27_South = 12203
+    Minnesota_CS83_North = 12231
+    Minnesota_CS83_Central = 12232
+    Minnesota_CS83_South = 12233
+    Mississippi_CS27_East = 12301
+    Mississippi_CS27_West = 12302
+    Mississippi_CS83_East = 12331
+    Mississippi_CS83_West = 12332
+    Missouri_CS27_East = 12401
+    Missouri_CS27_Central = 12402
+    Missouri_CS27_West = 12403
+    Missouri_CS83_East = 12431
+    Missouri_CS83_Central = 12432
+    Missouri_CS83_West = 12433
+    Montana_CS27_North = 12501
+    Montana_CS27_Central = 12502
+    Montana_CS27_South = 12503
+    Montana_CS83 = 12530
+    Nebraska_CS27_North = 12601
+    Nebraska_CS27_South = 12602
+    Nebraska_CS83 = 12630
+    Nevada_CS27_East = 12701
+    Nevada_CS27_Central = 12702
+    Nevada_CS27_West = 12703
+    Nevada_CS83_East = 12731
+    Nevada_CS83_Central = 12732
+    Nevada_CS83_West = 12733
+    New_Hampshire_CS27 = 12800
+    New_Hampshire_CS83 = 12830
+    New_Jersey_CS27 = 12900
+    New_Jersey_CS83 = 12930
+    New_Mexico_CS27_East = 13001
+    New_Mexico_CS27_Central = 13002
+    New_Mexico_CS27_West = 13003
+    New_Mexico_CS83_East = 13031
+    New_Mexico_CS83_Central = 13032
+    New_Mexico_CS83_West = 13033
+    New_York_CS27_East = 13101
+    New_York_CS27_Central = 13102
+    New_York_CS27_West = 13103
+    New_York_CS27_Long_Island = 13104
+    New_York_CS83_East = 13131
+    New_York_CS83_Central = 13132
+    New_York_CS83_West = 13133
+    New_York_CS83_Long_Island = 13134
+    North_Carolina_CS27 = 13200
+    North_Carolina_CS83 = 13230
+    North_Dakota_CS27_North = 13301
+    North_Dakota_CS27_South = 13302
+    North_Dakota_CS83_North = 13331
+    North_Dakota_CS83_South = 13332
+    Ohio_CS27_North = 13401
+    Ohio_CS27_South = 13402
+    Ohio_CS83_North = 13431
+    Ohio_CS83_South = 13432
+    Oklahoma_CS27_North = 13501
+    Oklahoma_CS27_South = 13502
+    Oklahoma_CS83_North = 13531
+    Oklahoma_CS83_South = 13532
+    Oregon_CS27_North = 13601
+    Oregon_CS27_South = 13602
+    Oregon_CS83_North = 13631
+    Oregon_CS83_South = 13632
+    Pennsylvania_CS27_North = 13701
+    Pennsylvania_CS27_South = 13702
+    Pennsylvania_CS83_North = 13731
+    Pennsylvania_CS83_South = 13732
+    Rhode_Island_CS27 = 13800
+    Rhode_Island_CS83 = 13830
+    South_Carolina_CS27_North = 13901
+    South_Carolina_CS27_South = 13902
+    South_Carolina_CS83 = 13930
+    South_Dakota_CS27_North = 14001
+    South_Dakota_CS27_South = 14002
+    South_Dakota_CS83_North = 14031
+    South_Dakota_CS83_South = 14032
+    Tennessee_CS27 = 15302
+    Tennessee_CS83 = 14130
+    Texas_CS27_North = 14201
+    Texas_CS27_North_Central = 14202
+    Texas_CS27_Central = 14203
+    Texas_CS27_South_Central = 14204
+    Texas_CS27_South = 14205
+    Texas_CS83_North = 14231
+    Texas_CS83_North_Central = 14232
+    Texas_CS83_Central = 14233
+    Texas_CS83_South_Central = 14234
+    Texas_CS83_South = 14235
+    Utah_CS27_North = 14301
+    Utah_CS27_Central = 14302
+    Utah_CS27_South = 14303
+    Utah_CS83_North = 14331
+    Utah_CS83_Central = 14332
+    Utah_CS83_South = 14333
+    Vermont_CS27 = 14400
+    Vermont_CS83 = 14430
+    Virginia_CS27_North = 14501
+    Virginia_CS27_South = 14502
+    Virginia_CS83_North = 14531
+    Virginia_CS83_South = 14532
+    Washington_CS27_North = 14601
+    Washington_CS27_South = 14602
+    Washington_CS83_North = 14631
+    Washington_CS83_South = 14632
+    West_Virginia_CS27_North = 14701
+    West_Virginia_CS27_South = 14702
+    West_Virginia_CS83_North = 14731
+    West_Virginia_CS83_South = 14732
+    Wisconsin_CS27_North = 14801
+    Wisconsin_CS27_Central = 14802
+    Wisconsin_CS27_South = 14803
+    Wisconsin_CS83_North = 14831
+    Wisconsin_CS83_Central = 14832
+    Wisconsin_CS83_South = 14833
+    Wyoming_CS27_East = 14901
+    Wyoming_CS27_East_Central = 14902
+    Wyoming_CS27_West_Central = 14903
+    Wyoming_CS27_West = 14904
+    Wyoming_CS83_East = 14931
+    Wyoming_CS83_East_Central = 14932
+    Wyoming_CS83_West_Central = 14933
+    Wyoming_CS83_West = 14934
+    Alaska_CS27_1 = 15001
+    Alaska_CS27_2 = 15002
+    Alaska_CS27_3 = 15003
+    Alaska_CS27_4 = 15004
+    Alaska_CS27_5 = 15005
+    Alaska_CS27_6 = 15006
+    Alaska_CS27_7 = 15007
+    Alaska_CS27_8 = 15008
+    Alaska_CS27_9 = 15009
+    Alaska_CS27_10 = 15010
+    Alaska_CS83_1 = 15031
+    Alaska_CS83_2 = 15032
+    Alaska_CS83_3 = 15033
+    Alaska_CS83_4 = 15034
+    Alaska_CS83_5 = 15035
+    Alaska_CS83_6 = 15036
+    Alaska_CS83_7 = 15037
+    Alaska_CS83_8 = 15038
+    Alaska_CS83_9 = 15039
+    Alaska_CS83_10 = 15040
+    Hawaii_CS27_1 = 15101
+    Hawaii_CS27_2 = 15102
+    Hawaii_CS27_3 = 15103
+    Hawaii_CS27_4 = 15104
+    Hawaii_CS27_5 = 15105
+    Hawaii_CS83_1 = 15131
+    Hawaii_CS83_2 = 15132
+    Hawaii_CS83_3 = 15133
+    Hawaii_CS83_4 = 15134
+    Hawaii_CS83_5 = 15135
+    Puerto_Rico_CS27 = 15201
+    St_Croix = 15202
+    Puerto_Rico_Virgin_Is = 15230
+    BLM_14N_feet = 15914
+    BLM_15N_feet = 15915
+    BLM_16N_feet = 15916
+    BLM_17N_feet = 15917
+    UTM_zone_1N = 16001
+    UTM_zone_2N = 16002
+    UTM_zone_3N = 16003
+    UTM_zone_4N = 16004
+    UTM_zone_5N = 16005
+    UTM_zone_6N = 16006
+    UTM_zone_7N = 16007
+    UTM_zone_8N = 16008
+    UTM_zone_9N = 16009
+    UTM_zone_10N = 16010
+    UTM_zone_11N = 16011
+    UTM_zone_12N = 16012
+    UTM_zone_13N = 16013
+    UTM_zone_14N = 16014
+    UTM_zone_15N = 16015
+    UTM_zone_16N = 16016
+    UTM_zone_17N = 16017
+    UTM_zone_18N = 16018
+    UTM_zone_19N = 16019
+    UTM_zone_20N = 16020
+    UTM_zone_21N = 16021
+    UTM_zone_22N = 16022
+    UTM_zone_23N = 16023
+    UTM_zone_24N = 16024
+    UTM_zone_25N = 16025
+    UTM_zone_26N = 16026
+    UTM_zone_27N = 16027
+    UTM_zone_28N = 16028
+    UTM_zone_29N = 16029
+    UTM_zone_30N = 16030
+    UTM_zone_31N = 16031
+    UTM_zone_32N = 16032
+    UTM_zone_33N = 16033
+    UTM_zone_34N = 16034
+    UTM_zone_35N = 16035
+    UTM_zone_36N = 16036
+    UTM_zone_37N = 16037
+    UTM_zone_38N = 16038
+    UTM_zone_39N = 16039
+    UTM_zone_40N = 16040
+    UTM_zone_41N = 16041
+    UTM_zone_42N = 16042
+    UTM_zone_43N = 16043
+    UTM_zone_44N = 16044
+    UTM_zone_45N = 16045
+    UTM_zone_46N = 16046
+    UTM_zone_47N = 16047
+    UTM_zone_48N = 16048
+    UTM_zone_49N = 16049
+    UTM_zone_50N = 16050
+    UTM_zone_51N = 16051
+    UTM_zone_52N = 16052
+    UTM_zone_53N = 16053
+    UTM_zone_54N = 16054
+    UTM_zone_55N = 16055
+    UTM_zone_56N = 16056
+    UTM_zone_57N = 16057
+    UTM_zone_58N = 16058
+    UTM_zone_59N = 16059
+    UTM_zone_60N = 16060
+    UTM_zone_1S = 16101
+    UTM_zone_2S = 16102
+    UTM_zone_3S = 16103
+    UTM_zone_4S = 16104
+    UTM_zone_5S = 16105
+    UTM_zone_6S = 16106
+    UTM_zone_7S = 16107
+    UTM_zone_8S = 16108
+    UTM_zone_9S = 16109
+    UTM_zone_10S = 16110
+    UTM_zone_11S = 16111
+    UTM_zone_12S = 16112
+    UTM_zone_13S = 16113
+    UTM_zone_14S = 16114
+    UTM_zone_15S = 16115
+    UTM_zone_16S = 16116
+    UTM_zone_17S = 16117
+    UTM_zone_18S = 16118
+    UTM_zone_19S = 16119
+    UTM_zone_20S = 16120
+    UTM_zone_21S = 16121
+    UTM_zone_22S = 16122
+    UTM_zone_23S = 16123
+    UTM_zone_24S = 16124
+    UTM_zone_25S = 16125
+    UTM_zone_26S = 16126
+    UTM_zone_27S = 16127
+    UTM_zone_28S = 16128
+    UTM_zone_29S = 16129
+    UTM_zone_30S = 16130
+    UTM_zone_31S = 16131
+    UTM_zone_32S = 16132
+    UTM_zone_33S = 16133
+    UTM_zone_34S = 16134
+    UTM_zone_35S = 16135
+    UTM_zone_36S = 16136
+    UTM_zone_37S = 16137
+    UTM_zone_38S = 16138
+    UTM_zone_39S = 16139
+    UTM_zone_40S = 16140
+    UTM_zone_41S = 16141
+    UTM_zone_42S = 16142
+    UTM_zone_43S = 16143
+    UTM_zone_44S = 16144
+    UTM_zone_45S = 16145
+    UTM_zone_46S = 16146
+    UTM_zone_47S = 16147
+    UTM_zone_48S = 16148
+    UTM_zone_49S = 16149
+    UTM_zone_50S = 16150
+    UTM_zone_51S = 16151
+    UTM_zone_52S = 16152
+    UTM_zone_53S = 16153
+    UTM_zone_54S = 16154
+    UTM_zone_55S = 16155
+    UTM_zone_56S = 16156
+    UTM_zone_57S = 16157
+    UTM_zone_58S = 16158
+    UTM_zone_59S = 16159
+    UTM_zone_60S = 16160
+    Gauss_Kruger_zone_0 = 16200
+    Gauss_Kruger_zone_1 = 16201
+    Gauss_Kruger_zone_2 = 16202
+    Gauss_Kruger_zone_3 = 16203
+    Gauss_Kruger_zone_4 = 16204
+    Gauss_Kruger_zone_5 = 16205
+    Map_Grid_of_Australia_48 = 17348
+    Map_Grid_of_Australia_49 = 17349
+    Map_Grid_of_Australia_50 = 17350
+    Map_Grid_of_Australia_51 = 17351
+    Map_Grid_of_Australia_52 = 17352
+    Map_Grid_of_Australia_53 = 17353
+    Map_Grid_of_Australia_54 = 17354
+    Map_Grid_of_Australia_55 = 17355
+    Map_Grid_of_Australia_56 = 17356
+    Map_Grid_of_Australia_57 = 17357
+    Map_Grid_of_Australia_58 = 17358
+    Australian_Map_Grid_48 = 17448
+    Australian_Map_Grid_49 = 17449
+    Australian_Map_Grid_50 = 17450
+    Australian_Map_Grid_51 = 17451
+    Australian_Map_Grid_52 = 17452
+    Australian_Map_Grid_53 = 17453
+    Australian_Map_Grid_54 = 17454
+    Australian_Map_Grid_55 = 17455
+    Australian_Map_Grid_56 = 17456
+    Australian_Map_Grid_57 = 17457
+    Australian_Map_Grid_58 = 17458
+    Argentina_1 = 18031
+    Argentina_2 = 18032
+    Argentina_3 = 18033
+    Argentina_4 = 18034
+    Argentina_5 = 18035
+    Argentina_6 = 18036
+    Argentina_7 = 18037
+    Colombia_3W = 18051
+    Colombia_Bogota = 18052
+    Colombia_3E = 18053
+    Colombia_6E = 18054
+    Egypt_Red_Belt = 18072
+    Egypt_Purple_Belt = 18073
+    Extended_Purple_Belt = 18074
+    New_Zealand_North_Island_Nat_Grid = 18141
+    New_Zealand_South_Island_Nat_Grid = 18142
+    Bahrain_Grid = 19900
+    Netherlands_E_Indies_Equatorial = 19905
+    RSO_Borneo = 19912
+    Stereo_70 = 19926
+
+
+class PCS(enum.IntEnum):
+    """Projected CS Type Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Adindan_UTM_zone_37N = 20137
+    Adindan_UTM_zone_38N = 20138
+    AGD66_AMG_zone_48 = 20248
+    AGD66_AMG_zone_49 = 20249
+    AGD66_AMG_zone_50 = 20250
+    AGD66_AMG_zone_51 = 20251
+    AGD66_AMG_zone_52 = 20252
+    AGD66_AMG_zone_53 = 20253
+    AGD66_AMG_zone_54 = 20254
+    AGD66_AMG_zone_55 = 20255
+    AGD66_AMG_zone_56 = 20256
+    AGD66_AMG_zone_57 = 20257
+    AGD66_AMG_zone_58 = 20258
+    AGD84_AMG_zone_48 = 20348
+    AGD84_AMG_zone_49 = 20349
+    AGD84_AMG_zone_50 = 20350
+    AGD84_AMG_zone_51 = 20351
+    AGD84_AMG_zone_52 = 20352
+    AGD84_AMG_zone_53 = 20353
+    AGD84_AMG_zone_54 = 20354
+    AGD84_AMG_zone_55 = 20355
+    AGD84_AMG_zone_56 = 20356
+    AGD84_AMG_zone_57 = 20357
+    AGD84_AMG_zone_58 = 20358
+    Ain_el_Abd_UTM_zone_37N = 20437
+    Ain_el_Abd_UTM_zone_38N = 20438
+    Ain_el_Abd_UTM_zone_39N = 20439
+    Ain_el_Abd_Bahrain_Grid = 20499
+    Afgooye_UTM_zone_38N = 20538
+    Afgooye_UTM_zone_39N = 20539
+    Lisbon_Portugese_Grid = 20700
+    Aratu_UTM_zone_22S = 20822
+    Aratu_UTM_zone_23S = 20823
+    Aratu_UTM_zone_24S = 20824
+    Arc_1950_Lo13 = 20973
+    Arc_1950_Lo15 = 20975
+    Arc_1950_Lo17 = 20977
+    Arc_1950_Lo19 = 20979
+    Arc_1950_Lo21 = 20981
+    Arc_1950_Lo23 = 20983
+    Arc_1950_Lo25 = 20985
+    Arc_1950_Lo27 = 20987
+    Arc_1950_Lo29 = 20989
+    Arc_1950_Lo31 = 20991
+    Arc_1950_Lo33 = 20993
+    Arc_1950_Lo35 = 20995
+    Batavia_NEIEZ = 21100
+    Batavia_UTM_zone_48S = 21148
+    Batavia_UTM_zone_49S = 21149
+    Batavia_UTM_zone_50S = 21150
+    Beijing_Gauss_zone_13 = 21413
+    Beijing_Gauss_zone_14 = 21414
+    Beijing_Gauss_zone_15 = 21415
+    Beijing_Gauss_zone_16 = 21416
+    Beijing_Gauss_zone_17 = 21417
+    Beijing_Gauss_zone_18 = 21418
+    Beijing_Gauss_zone_19 = 21419
+    Beijing_Gauss_zone_20 = 21420
+    Beijing_Gauss_zone_21 = 21421
+    Beijing_Gauss_zone_22 = 21422
+    Beijing_Gauss_zone_23 = 21423
+    Beijing_Gauss_13N = 21473
+    Beijing_Gauss_14N = 21474
+    Beijing_Gauss_15N = 21475
+    Beijing_Gauss_16N = 21476
+    Beijing_Gauss_17N = 21477
+    Beijing_Gauss_18N = 21478
+    Beijing_Gauss_19N = 21479
+    Beijing_Gauss_20N = 21480
+    Beijing_Gauss_21N = 21481
+    Beijing_Gauss_22N = 21482
+    Beijing_Gauss_23N = 21483
+    Belge_Lambert_50 = 21500
+    Bern_1898_Swiss_Old = 21790
+    Bogota_UTM_zone_17N = 21817
+    Bogota_UTM_zone_18N = 21818
+    Bogota_Colombia_3W = 21891
+    Bogota_Colombia_Bogota = 21892
+    Bogota_Colombia_3E = 21893
+    Bogota_Colombia_6E = 21894
+    Camacupa_UTM_32S = 22032
+    Camacupa_UTM_33S = 22033
+    C_Inchauspe_Argentina_1 = 22191
+    C_Inchauspe_Argentina_2 = 22192
+    C_Inchauspe_Argentina_3 = 22193
+    C_Inchauspe_Argentina_4 = 22194
+    C_Inchauspe_Argentina_5 = 22195
+    C_Inchauspe_Argentina_6 = 22196
+    C_Inchauspe_Argentina_7 = 22197
+    Carthage_UTM_zone_32N = 22332
+    Carthage_Nord_Tunisie = 22391
+    Carthage_Sud_Tunisie = 22392
+    Corrego_Alegre_UTM_23S = 22523
+    Corrego_Alegre_UTM_24S = 22524
+    Douala_UTM_zone_32N = 22832
+    Egypt_1907_Red_Belt = 22992
+    Egypt_1907_Purple_Belt = 22993
+    Egypt_1907_Ext_Purple = 22994
+    ED50_UTM_zone_28N = 23028
+    ED50_UTM_zone_29N = 23029
+    ED50_UTM_zone_30N = 23030
+    ED50_UTM_zone_31N = 23031
+    ED50_UTM_zone_32N = 23032
+    ED50_UTM_zone_33N = 23033
+    ED50_UTM_zone_34N = 23034
+    ED50_UTM_zone_35N = 23035
+    ED50_UTM_zone_36N = 23036
+    ED50_UTM_zone_37N = 23037
+    ED50_UTM_zone_38N = 23038
+    Fahud_UTM_zone_39N = 23239
+    Fahud_UTM_zone_40N = 23240
+    Garoua_UTM_zone_33N = 23433
+    ID74_UTM_zone_46N = 23846
+    ID74_UTM_zone_47N = 23847
+    ID74_UTM_zone_48N = 23848
+    ID74_UTM_zone_49N = 23849
+    ID74_UTM_zone_50N = 23850
+    ID74_UTM_zone_51N = 23851
+    ID74_UTM_zone_52N = 23852
+    ID74_UTM_zone_53N = 23853
+    ID74_UTM_zone_46S = 23886
+    ID74_UTM_zone_47S = 23887
+    ID74_UTM_zone_48S = 23888
+    ID74_UTM_zone_49S = 23889
+    ID74_UTM_zone_50S = 23890
+    ID74_UTM_zone_51S = 23891
+    ID74_UTM_zone_52S = 23892
+    ID74_UTM_zone_53S = 23893
+    ID74_UTM_zone_54S = 23894
+    Indian_1954_UTM_47N = 23947
+    Indian_1954_UTM_48N = 23948
+    Indian_1975_UTM_47N = 24047
+    Indian_1975_UTM_48N = 24048
+    Jamaica_1875_Old_Grid = 24100
+    JAD69_Jamaica_Grid = 24200
+    Kalianpur_India_0 = 24370
+    Kalianpur_India_I = 24371
+    Kalianpur_India_IIa = 24372
+    Kalianpur_India_IIIa = 24373
+    Kalianpur_India_IVa = 24374
+    Kalianpur_India_IIb = 24382
+    Kalianpur_India_IIIb = 24383
+    Kalianpur_India_IVb = 24384
+    Kertau_Singapore_Grid = 24500
+    Kertau_UTM_zone_47N = 24547
+    Kertau_UTM_zone_48N = 24548
+    La_Canoa_UTM_zone_20N = 24720
+    La_Canoa_UTM_zone_21N = 24721
+    PSAD56_UTM_zone_18N = 24818
+    PSAD56_UTM_zone_19N = 24819
+    PSAD56_UTM_zone_20N = 24820
+    PSAD56_UTM_zone_21N = 24821
+    PSAD56_UTM_zone_17S = 24877
+    PSAD56_UTM_zone_18S = 24878
+    PSAD56_UTM_zone_19S = 24879
+    PSAD56_UTM_zone_20S = 24880
+    PSAD56_Peru_west_zone = 24891
+    PSAD56_Peru_central = 24892
+    PSAD56_Peru_east_zone = 24893
+    Leigon_Ghana_Grid = 25000
+    Lome_UTM_zone_31N = 25231
+    Luzon_Philippines_I = 25391
+    Luzon_Philippines_II = 25392
+    Luzon_Philippines_III = 25393
+    Luzon_Philippines_IV = 25394
+    Luzon_Philippines_V = 25395
+    Makassar_NEIEZ = 25700
+    Malongo_1987_UTM_32S = 25932
+    Merchich_Nord_Maroc = 26191
+    Merchich_Sud_Maroc = 26192
+    Merchich_Sahara = 26193
+    Massawa_UTM_zone_37N = 26237
+    Minna_UTM_zone_31N = 26331
+    Minna_UTM_zone_32N = 26332
+    Minna_Nigeria_West = 26391
+    Minna_Nigeria_Mid_Belt = 26392
+    Minna_Nigeria_East = 26393
+    Mhast_UTM_zone_32S = 26432
+    Monte_Mario_Italy_1 = 26591
+    Monte_Mario_Italy_2 = 26592
+    M_poraloko_UTM_32N = 26632
+    M_poraloko_UTM_32S = 26692
+    NAD27_UTM_zone_3N = 26703
+    NAD27_UTM_zone_4N = 26704
+    NAD27_UTM_zone_5N = 26705
+    NAD27_UTM_zone_6N = 26706
+    NAD27_UTM_zone_7N = 26707
+    NAD27_UTM_zone_8N = 26708
+    NAD27_UTM_zone_9N = 26709
+    NAD27_UTM_zone_10N = 26710
+    NAD27_UTM_zone_11N = 26711
+    NAD27_UTM_zone_12N = 26712
+    NAD27_UTM_zone_13N = 26713
+    NAD27_UTM_zone_14N = 26714
+    NAD27_UTM_zone_15N = 26715
+    NAD27_UTM_zone_16N = 26716
+    NAD27_UTM_zone_17N = 26717
+    NAD27_UTM_zone_18N = 26718
+    NAD27_UTM_zone_19N = 26719
+    NAD27_UTM_zone_20N = 26720
+    NAD27_UTM_zone_21N = 26721
+    NAD27_UTM_zone_22N = 26722
+    NAD27_Alabama_East = 26729
+    NAD27_Alabama_West = 26730
+    NAD27_Alaska_zone_1 = 26731
+    NAD27_Alaska_zone_2 = 26732
+    NAD27_Alaska_zone_3 = 26733
+    NAD27_Alaska_zone_4 = 26734
+    NAD27_Alaska_zone_5 = 26735
+    NAD27_Alaska_zone_6 = 26736
+    NAD27_Alaska_zone_7 = 26737
+    NAD27_Alaska_zone_8 = 26738
+    NAD27_Alaska_zone_9 = 26739
+    NAD27_Alaska_zone_10 = 26740
+    NAD27_California_I = 26741
+    NAD27_California_II = 26742
+    NAD27_California_III = 26743
+    NAD27_California_IV = 26744
+    NAD27_California_V = 26745
+    NAD27_California_VI = 26746
+    NAD27_California_VII = 26747
+    NAD27_Arizona_East = 26748
+    NAD27_Arizona_Central = 26749
+    NAD27_Arizona_West = 26750
+    NAD27_Arkansas_North = 26751
+    NAD27_Arkansas_South = 26752
+    NAD27_Colorado_North = 26753
+    NAD27_Colorado_Central = 26754
+    NAD27_Colorado_South = 26755
+    NAD27_Connecticut = 26756
+    NAD27_Delaware = 26757
+    NAD27_Florida_East = 26758
+    NAD27_Florida_West = 26759
+    NAD27_Florida_North = 26760
+    NAD27_Hawaii_zone_1 = 26761
+    NAD27_Hawaii_zone_2 = 26762
+    NAD27_Hawaii_zone_3 = 26763
+    NAD27_Hawaii_zone_4 = 26764
+    NAD27_Hawaii_zone_5 = 26765
+    NAD27_Georgia_East = 26766
+    NAD27_Georgia_West = 26767
+    NAD27_Idaho_East = 26768
+    NAD27_Idaho_Central = 26769
+    NAD27_Idaho_West = 26770
+    NAD27_Illinois_East = 26771
+    NAD27_Illinois_West = 26772
+    NAD27_Indiana_East = 26773
+    NAD27_BLM_14N_feet = 26774
+    NAD27_Indiana_West = 26774
+    NAD27_BLM_15N_feet = 26775
+    NAD27_Iowa_North = 26775
+    NAD27_BLM_16N_feet = 26776
+    NAD27_Iowa_South = 26776
+    NAD27_BLM_17N_feet = 26777
+    NAD27_Kansas_North = 26777
+    NAD27_Kansas_South = 26778
+    NAD27_Kentucky_North = 26779
+    NAD27_Kentucky_South = 26780
+    NAD27_Louisiana_North = 26781
+    NAD27_Louisiana_South = 26782
+    NAD27_Maine_East = 26783
+    NAD27_Maine_West = 26784
+    NAD27_Maryland = 26785
+    NAD27_Massachusetts = 26786
+    NAD27_Massachusetts_Is = 26787
+    NAD27_Michigan_North = 26788
+    NAD27_Michigan_Central = 26789
+    NAD27_Michigan_South = 26790
+    NAD27_Minnesota_North = 26791
+    NAD27_Minnesota_Cent = 26792
+    NAD27_Minnesota_South = 26793
+    NAD27_Mississippi_East = 26794
+    NAD27_Mississippi_West = 26795
+    NAD27_Missouri_East = 26796
+    NAD27_Missouri_Central = 26797
+    NAD27_Missouri_West = 26798
+    NAD_Michigan_Michigan_East = 26801
+    NAD_Michigan_Michigan_Old_Central = 26802
+    NAD_Michigan_Michigan_West = 26803
+    NAD83_UTM_zone_3N = 26903
+    NAD83_UTM_zone_4N = 26904
+    NAD83_UTM_zone_5N = 26905
+    NAD83_UTM_zone_6N = 26906
+    NAD83_UTM_zone_7N = 26907
+    NAD83_UTM_zone_8N = 26908
+    NAD83_UTM_zone_9N = 26909
+    NAD83_UTM_zone_10N = 26910
+    NAD83_UTM_zone_11N = 26911
+    NAD83_UTM_zone_12N = 26912
+    NAD83_UTM_zone_13N = 26913
+    NAD83_UTM_zone_14N = 26914
+    NAD83_UTM_zone_15N = 26915
+    NAD83_UTM_zone_16N = 26916
+    NAD83_UTM_zone_17N = 26917
+    NAD83_UTM_zone_18N = 26918
+    NAD83_UTM_zone_19N = 26919
+    NAD83_UTM_zone_20N = 26920
+    NAD83_UTM_zone_21N = 26921
+    NAD83_UTM_zone_22N = 26922
+    NAD83_UTM_zone_23N = 26923
+    NAD83_Alabama_East = 26929
+    NAD83_Alabama_West = 26930
+    NAD83_Alaska_zone_1 = 26931
+    NAD83_Alaska_zone_2 = 26932
+    NAD83_Alaska_zone_3 = 26933
+    NAD83_Alaska_zone_4 = 26934
+    NAD83_Alaska_zone_5 = 26935
+    NAD83_Alaska_zone_6 = 26936
+    NAD83_Alaska_zone_7 = 26937
+    NAD83_Alaska_zone_8 = 26938
+    NAD83_Alaska_zone_9 = 26939
+    NAD83_Alaska_zone_10 = 26940
+    NAD83_California_1 = 26941
+    NAD83_California_2 = 26942
+    NAD83_California_3 = 26943
+    NAD83_California_4 = 26944
+    NAD83_California_5 = 26945
+    NAD83_California_6 = 26946
+    NAD83_Arizona_East = 26948
+    NAD83_Arizona_Central = 26949
+    NAD83_Arizona_West = 26950
+    NAD83_Arkansas_North = 26951
+    NAD83_Arkansas_South = 26952
+    NAD83_Colorado_North = 26953
+    NAD83_Colorado_Central = 26954
+    NAD83_Colorado_South = 26955
+    NAD83_Connecticut = 26956
+    NAD83_Delaware = 26957
+    NAD83_Florida_East = 26958
+    NAD83_Florida_West = 26959
+    NAD83_Florida_North = 26960
+    NAD83_Hawaii_zone_1 = 26961
+    NAD83_Hawaii_zone_2 = 26962
+    NAD83_Hawaii_zone_3 = 26963
+    NAD83_Hawaii_zone_4 = 26964
+    NAD83_Hawaii_zone_5 = 26965
+    NAD83_Georgia_East = 26966
+    NAD83_Georgia_West = 26967
+    NAD83_Idaho_East = 26968
+    NAD83_Idaho_Central = 26969
+    NAD83_Idaho_West = 26970
+    NAD83_Illinois_East = 26971
+    NAD83_Illinois_West = 26972
+    NAD83_Indiana_East = 26973
+    NAD83_Indiana_West = 26974
+    NAD83_Iowa_North = 26975
+    NAD83_Iowa_South = 26976
+    NAD83_Kansas_North = 26977
+    NAD83_Kansas_South = 26978
+    NAD83_Kentucky_North = 2205
+    NAD83_Kentucky_South = 26980
+    NAD83_Louisiana_North = 26981
+    NAD83_Louisiana_South = 26982
+    NAD83_Maine_East = 26983
+    NAD83_Maine_West = 26984
+    NAD83_Maryland = 26985
+    NAD83_Massachusetts = 26986
+    NAD83_Massachusetts_Is = 26987
+    NAD83_Michigan_North = 26988
+    NAD83_Michigan_Central = 26989
+    NAD83_Michigan_South = 26990
+    NAD83_Minnesota_North = 26991
+    NAD83_Minnesota_Cent = 26992
+    NAD83_Minnesota_South = 26993
+    NAD83_Mississippi_East = 26994
+    NAD83_Mississippi_West = 26995
+    NAD83_Missouri_East = 26996
+    NAD83_Missouri_Central = 26997
+    NAD83_Missouri_West = 26998
+    Nahrwan_1967_UTM_38N = 27038
+    Nahrwan_1967_UTM_39N = 27039
+    Nahrwan_1967_UTM_40N = 27040
+    Naparima_UTM_20N = 27120
+    GD49_NZ_Map_Grid = 27200
+    GD49_North_Island_Grid = 27291
+    GD49_South_Island_Grid = 27292
+    Datum_73_UTM_zone_29N = 27429
+    ATF_Nord_de_Guerre = 27500
+    NTF_France_I = 27581
+    NTF_France_II = 27582
+    NTF_France_III = 27583
+    NTF_Nord_France = 27591
+    NTF_Centre_France = 27592
+    NTF_Sud_France = 27593
+    British_National_Grid = 27700
+    Point_Noire_UTM_32S = 28232
+    GDA94_MGA_zone_48 = 28348
+    GDA94_MGA_zone_49 = 28349
+    GDA94_MGA_zone_50 = 28350
+    GDA94_MGA_zone_51 = 28351
+    GDA94_MGA_zone_52 = 28352
+    GDA94_MGA_zone_53 = 28353
+    GDA94_MGA_zone_54 = 28354
+    GDA94_MGA_zone_55 = 28355
+    GDA94_MGA_zone_56 = 28356
+    GDA94_MGA_zone_57 = 28357
+    GDA94_MGA_zone_58 = 28358
+    Pulkovo_Gauss_zone_4 = 28404
+    Pulkovo_Gauss_zone_5 = 28405
+    Pulkovo_Gauss_zone_6 = 28406
+    Pulkovo_Gauss_zone_7 = 28407
+    Pulkovo_Gauss_zone_8 = 28408
+    Pulkovo_Gauss_zone_9 = 28409
+    Pulkovo_Gauss_zone_10 = 28410
+    Pulkovo_Gauss_zone_11 = 28411
+    Pulkovo_Gauss_zone_12 = 28412
+    Pulkovo_Gauss_zone_13 = 28413
+    Pulkovo_Gauss_zone_14 = 28414
+    Pulkovo_Gauss_zone_15 = 28415
+    Pulkovo_Gauss_zone_16 = 28416
+    Pulkovo_Gauss_zone_17 = 28417
+    Pulkovo_Gauss_zone_18 = 28418
+    Pulkovo_Gauss_zone_19 = 28419
+    Pulkovo_Gauss_zone_20 = 28420
+    Pulkovo_Gauss_zone_21 = 28421
+    Pulkovo_Gauss_zone_22 = 28422
+    Pulkovo_Gauss_zone_23 = 28423
+    Pulkovo_Gauss_zone_24 = 28424
+    Pulkovo_Gauss_zone_25 = 28425
+    Pulkovo_Gauss_zone_26 = 28426
+    Pulkovo_Gauss_zone_27 = 28427
+    Pulkovo_Gauss_zone_28 = 28428
+    Pulkovo_Gauss_zone_29 = 28429
+    Pulkovo_Gauss_zone_30 = 28430
+    Pulkovo_Gauss_zone_31 = 28431
+    Pulkovo_Gauss_zone_32 = 28432
+    Pulkovo_Gauss_4N = 28464
+    Pulkovo_Gauss_5N = 28465
+    Pulkovo_Gauss_6N = 28466
+    Pulkovo_Gauss_7N = 28467
+    Pulkovo_Gauss_8N = 28468
+    Pulkovo_Gauss_9N = 28469
+    Pulkovo_Gauss_10N = 28470
+    Pulkovo_Gauss_11N = 28471
+    Pulkovo_Gauss_12N = 28472
+    Pulkovo_Gauss_13N = 28473
+    Pulkovo_Gauss_14N = 28474
+    Pulkovo_Gauss_15N = 28475
+    Pulkovo_Gauss_16N = 28476
+    Pulkovo_Gauss_17N = 28477
+    Pulkovo_Gauss_18N = 28478
+    Pulkovo_Gauss_19N = 28479
+    Pulkovo_Gauss_20N = 28480
+    Pulkovo_Gauss_21N = 28481
+    Pulkovo_Gauss_22N = 28482
+    Pulkovo_Gauss_23N = 28483
+    Pulkovo_Gauss_24N = 28484
+    Pulkovo_Gauss_25N = 28485
+    Pulkovo_Gauss_26N = 28486
+    Pulkovo_Gauss_27N = 28487
+    Pulkovo_Gauss_28N = 28488
+    Pulkovo_Gauss_29N = 28489
+    Pulkovo_Gauss_30N = 28490
+    Pulkovo_Gauss_31N = 28491
+    Pulkovo_Gauss_32N = 28492
+    Qatar_National_Grid = 28600
+    RD_Netherlands_Old = 28991
+    RD_Netherlands_New = 28992
+    SAD69_UTM_zone_18N = 29118
+    SAD69_UTM_zone_19N = 29119
+    SAD69_UTM_zone_20N = 29120
+    SAD69_UTM_zone_21N = 29121
+    SAD69_UTM_zone_22N = 29122
+    SAD69_UTM_zone_17S = 29177
+    SAD69_UTM_zone_18S = 29178
+    SAD69_UTM_zone_19S = 29179
+    SAD69_UTM_zone_20S = 29180
+    SAD69_UTM_zone_21S = 29181
+    SAD69_UTM_zone_22S = 29182
+    SAD69_UTM_zone_23S = 29183
+    SAD69_UTM_zone_24S = 29184
+    SAD69_UTM_zone_25S = 29185
+    Sapper_Hill_UTM_20S = 29220
+    Sapper_Hill_UTM_21S = 29221
+    Schwarzeck_UTM_33S = 29333
+    Sudan_UTM_zone_35N = 29635
+    Sudan_UTM_zone_36N = 29636
+    Tananarive_Laborde = 29700
+    Tananarive_UTM_38S = 29738
+    Tananarive_UTM_39S = 29739
+    Timbalai_1948_Borneo = 29800
+    Timbalai_1948_UTM_49N = 29849
+    Timbalai_1948_UTM_50N = 29850
+    TM65_Irish_Nat_Grid = 29900
+    Trinidad_1903_Trinidad = 30200
+    TC_1948_UTM_zone_39N = 30339
+    TC_1948_UTM_zone_40N = 30340
+    Voirol_N_Algerie_ancien = 30491
+    Voirol_S_Algerie_ancien = 30492
+    Voirol_Unifie_N_Algerie = 30591
+    Voirol_Unifie_S_Algerie = 30592
+    Bern_1938_Swiss_New = 30600
+    Nord_Sahara_UTM_29N = 30729
+    Nord_Sahara_UTM_30N = 30730
+    Nord_Sahara_UTM_31N = 30731
+    Nord_Sahara_UTM_32N = 30732
+    Yoff_UTM_zone_28N = 31028
+    Zanderij_UTM_zone_21N = 31121
+    MGI_Austria_West = 31291
+    MGI_Austria_Central = 31292
+    MGI_Austria_East = 31293
+    Belge_Lambert_72 = 31300
+    DHDN_Germany_zone_1 = 31491
+    DHDN_Germany_zone_2 = 31492
+    DHDN_Germany_zone_3 = 31493
+    DHDN_Germany_zone_4 = 31494
+    DHDN_Germany_zone_5 = 31495
+    NAD27_Montana_North = 32001
+    NAD27_Montana_Central = 32002
+    NAD27_Montana_South = 32003
+    NAD27_Nebraska_North = 32005
+    NAD27_Nebraska_South = 32006
+    NAD27_Nevada_East = 32007
+    NAD27_Nevada_Central = 32008
+    NAD27_Nevada_West = 32009
+    NAD27_New_Hampshire = 32010
+    NAD27_New_Jersey = 32011
+    NAD27_New_Mexico_East = 32012
+    NAD27_New_Mexico_Cent = 32013
+    NAD27_New_Mexico_West = 32014
+    NAD27_New_York_East = 32015
+    NAD27_New_York_Central = 32016
+    NAD27_New_York_West = 32017
+    NAD27_New_York_Long_Is = 32018
+    NAD27_North_Carolina = 32019
+    NAD27_North_Dakota_N = 32020
+    NAD27_North_Dakota_S = 32021
+    NAD27_Ohio_North = 32022
+    NAD27_Ohio_South = 32023
+    NAD27_Oklahoma_North = 32024
+    NAD27_Oklahoma_South = 32025
+    NAD27_Oregon_North = 32026
+    NAD27_Oregon_South = 32027
+    NAD27_Pennsylvania_N = 32028
+    NAD27_Pennsylvania_S = 32029
+    NAD27_Rhode_Island = 32030
+    NAD27_South_Carolina_N = 32031
+    NAD27_South_Carolina_S = 32033
+    NAD27_South_Dakota_N = 32034
+    NAD27_South_Dakota_S = 32035
+    NAD27_Tennessee = 2204
+    NAD27_Texas_North = 32037
+    NAD27_Texas_North_Cen = 32038
+    NAD27_Texas_Central = 32039
+    NAD27_Texas_South_Cen = 32040
+    NAD27_Texas_South = 32041
+    NAD27_Utah_North = 32042
+    NAD27_Utah_Central = 32043
+    NAD27_Utah_South = 32044
+    NAD27_Vermont = 32045
+    NAD27_Virginia_North = 32046
+    NAD27_Virginia_South = 32047
+    NAD27_Washington_North = 32048
+    NAD27_Washington_South = 32049
+    NAD27_West_Virginia_N = 32050
+    NAD27_West_Virginia_S = 32051
+    NAD27_Wisconsin_North = 32052
+    NAD27_Wisconsin_Cen = 32053
+    NAD27_Wisconsin_South = 32054
+    NAD27_Wyoming_East = 32055
+    NAD27_Wyoming_E_Cen = 32056
+    NAD27_Wyoming_W_Cen = 32057
+    NAD27_Wyoming_West = 32058
+    NAD27_Puerto_Rico = 32059
+    NAD27_St_Croix = 32060
+    NAD83_Montana = 32100
+    NAD83_Nebraska = 32104
+    NAD83_Nevada_East = 32107
+    NAD83_Nevada_Central = 32108
+    NAD83_Nevada_West = 32109
+    NAD83_New_Hampshire = 32110
+    NAD83_New_Jersey = 32111
+    NAD83_New_Mexico_East = 32112
+    NAD83_New_Mexico_Cent = 32113
+    NAD83_New_Mexico_West = 32114
+    NAD83_New_York_East = 32115
+    NAD83_New_York_Central = 32116
+    NAD83_New_York_West = 32117
+    NAD83_New_York_Long_Is = 32118
+    NAD83_North_Carolina = 32119
+    NAD83_North_Dakota_N = 32120
+    NAD83_North_Dakota_S = 32121
+    NAD83_Ohio_North = 32122
+    NAD83_Ohio_South = 32123
+    NAD83_Oklahoma_North = 32124
+    NAD83_Oklahoma_South = 32125
+    NAD83_Oregon_North = 32126
+    NAD83_Oregon_South = 32127
+    NAD83_Pennsylvania_N = 32128
+    NAD83_Pennsylvania_S = 32129
+    NAD83_Rhode_Island = 32130
+    NAD83_South_Carolina = 32133
+    NAD83_South_Dakota_N = 32134
+    NAD83_South_Dakota_S = 32135
+    NAD83_Tennessee = 32136
+    NAD83_Texas_North = 32137
+    NAD83_Texas_North_Cen = 32138
+    NAD83_Texas_Central = 32139
+    NAD83_Texas_South_Cen = 32140
+    NAD83_Texas_South = 32141
+    NAD83_Utah_North = 32142
+    NAD83_Utah_Central = 32143
+    NAD83_Utah_South = 32144
+    NAD83_Vermont = 32145
+    NAD83_Virginia_North = 32146
+    NAD83_Virginia_South = 32147
+    NAD83_Washington_North = 32148
+    NAD83_Washington_South = 32149
+    NAD83_West_Virginia_N = 32150
+    NAD83_West_Virginia_S = 32151
+    NAD83_Wisconsin_North = 32152
+    NAD83_Wisconsin_Cen = 32153
+    NAD83_Wisconsin_South = 32154
+    NAD83_Wyoming_East = 32155
+    NAD83_Wyoming_E_Cen = 32156
+    NAD83_Wyoming_W_Cen = 32157
+    NAD83_Wyoming_West = 32158
+    NAD83_Puerto_Rico_Virgin_Is = 32161
+    WGS72_UTM_zone_1N = 32201
+    WGS72_UTM_zone_2N = 32202
+    WGS72_UTM_zone_3N = 32203
+    WGS72_UTM_zone_4N = 32204
+    WGS72_UTM_zone_5N = 32205
+    WGS72_UTM_zone_6N = 32206
+    WGS72_UTM_zone_7N = 32207
+    WGS72_UTM_zone_8N = 32208
+    WGS72_UTM_zone_9N = 32209
+    WGS72_UTM_zone_10N = 32210
+    WGS72_UTM_zone_11N = 32211
+    WGS72_UTM_zone_12N = 32212
+    WGS72_UTM_zone_13N = 32213
+    WGS72_UTM_zone_14N = 32214
+    WGS72_UTM_zone_15N = 32215
+    WGS72_UTM_zone_16N = 32216
+    WGS72_UTM_zone_17N = 32217
+    WGS72_UTM_zone_18N = 32218
+    WGS72_UTM_zone_19N = 32219
+    WGS72_UTM_zone_20N = 32220
+    WGS72_UTM_zone_21N = 32221
+    WGS72_UTM_zone_22N = 32222
+    WGS72_UTM_zone_23N = 32223
+    WGS72_UTM_zone_24N = 32224
+    WGS72_UTM_zone_25N = 32225
+    WGS72_UTM_zone_26N = 32226
+    WGS72_UTM_zone_27N = 32227
+    WGS72_UTM_zone_28N = 32228
+    WGS72_UTM_zone_29N = 32229
+    WGS72_UTM_zone_30N = 32230
+    WGS72_UTM_zone_31N = 32231
+    WGS72_UTM_zone_32N = 32232
+    WGS72_UTM_zone_33N = 32233
+    WGS72_UTM_zone_34N = 32234
+    WGS72_UTM_zone_35N = 32235
+    WGS72_UTM_zone_36N = 32236
+    WGS72_UTM_zone_37N = 32237
+    WGS72_UTM_zone_38N = 32238
+    WGS72_UTM_zone_39N = 32239
+    WGS72_UTM_zone_40N = 32240
+    WGS72_UTM_zone_41N = 32241
+    WGS72_UTM_zone_42N = 32242
+    WGS72_UTM_zone_43N = 32243
+    WGS72_UTM_zone_44N = 32244
+    WGS72_UTM_zone_45N = 32245
+    WGS72_UTM_zone_46N = 32246
+    WGS72_UTM_zone_47N = 32247
+    WGS72_UTM_zone_48N = 32248
+    WGS72_UTM_zone_49N = 32249
+    WGS72_UTM_zone_50N = 32250
+    WGS72_UTM_zone_51N = 32251
+    WGS72_UTM_zone_52N = 32252
+    WGS72_UTM_zone_53N = 32253
+    WGS72_UTM_zone_54N = 32254
+    WGS72_UTM_zone_55N = 32255
+    WGS72_UTM_zone_56N = 32256
+    WGS72_UTM_zone_57N = 32257
+    WGS72_UTM_zone_58N = 32258
+    WGS72_UTM_zone_59N = 32259
+    WGS72_UTM_zone_60N = 32260
+    WGS72_UTM_zone_1S = 32301
+    WGS72_UTM_zone_2S = 32302
+    WGS72_UTM_zone_3S = 32303
+    WGS72_UTM_zone_4S = 32304
+    WGS72_UTM_zone_5S = 32305
+    WGS72_UTM_zone_6S = 32306
+    WGS72_UTM_zone_7S = 32307
+    WGS72_UTM_zone_8S = 32308
+    WGS72_UTM_zone_9S = 32309
+    WGS72_UTM_zone_10S = 32310
+    WGS72_UTM_zone_11S = 32311
+    WGS72_UTM_zone_12S = 32312
+    WGS72_UTM_zone_13S = 32313
+    WGS72_UTM_zone_14S = 32314
+    WGS72_UTM_zone_15S = 32315
+    WGS72_UTM_zone_16S = 32316
+    WGS72_UTM_zone_17S = 32317
+    WGS72_UTM_zone_18S = 32318
+    WGS72_UTM_zone_19S = 32319
+    WGS72_UTM_zone_20S = 32320
+    WGS72_UTM_zone_21S = 32321
+    WGS72_UTM_zone_22S = 32322
+    WGS72_UTM_zone_23S = 32323
+    WGS72_UTM_zone_24S = 32324
+    WGS72_UTM_zone_25S = 32325
+    WGS72_UTM_zone_26S = 32326
+    WGS72_UTM_zone_27S = 32327
+    WGS72_UTM_zone_28S = 32328
+    WGS72_UTM_zone_29S = 32329
+    WGS72_UTM_zone_30S = 32330
+    WGS72_UTM_zone_31S = 32331
+    WGS72_UTM_zone_32S = 32332
+    WGS72_UTM_zone_33S = 32333
+    WGS72_UTM_zone_34S = 32334
+    WGS72_UTM_zone_35S = 32335
+    WGS72_UTM_zone_36S = 32336
+    WGS72_UTM_zone_37S = 32337
+    WGS72_UTM_zone_38S = 32338
+    WGS72_UTM_zone_39S = 32339
+    WGS72_UTM_zone_40S = 32340
+    WGS72_UTM_zone_41S = 32341
+    WGS72_UTM_zone_42S = 32342
+    WGS72_UTM_zone_43S = 32343
+    WGS72_UTM_zone_44S = 32344
+    WGS72_UTM_zone_45S = 32345
+    WGS72_UTM_zone_46S = 32346
+    WGS72_UTM_zone_47S = 32347
+    WGS72_UTM_zone_48S = 32348
+    WGS72_UTM_zone_49S = 32349
+    WGS72_UTM_zone_50S = 32350
+    WGS72_UTM_zone_51S = 32351
+    WGS72_UTM_zone_52S = 32352
+    WGS72_UTM_zone_53S = 32353
+    WGS72_UTM_zone_54S = 32354
+    WGS72_UTM_zone_55S = 32355
+    WGS72_UTM_zone_56S = 32356
+    WGS72_UTM_zone_57S = 32357
+    WGS72_UTM_zone_58S = 32358
+    WGS72_UTM_zone_59S = 32359
+    WGS72_UTM_zone_60S = 32360
+    WGS72BE_UTM_zone_1N = 32401
+    WGS72BE_UTM_zone_2N = 32402
+    WGS72BE_UTM_zone_3N = 32403
+    WGS72BE_UTM_zone_4N = 32404
+    WGS72BE_UTM_zone_5N = 32405
+    WGS72BE_UTM_zone_6N = 32406
+    WGS72BE_UTM_zone_7N = 32407
+    WGS72BE_UTM_zone_8N = 32408
+    WGS72BE_UTM_zone_9N = 32409
+    WGS72BE_UTM_zone_10N = 32410
+    WGS72BE_UTM_zone_11N = 32411
+    WGS72BE_UTM_zone_12N = 32412
+    WGS72BE_UTM_zone_13N = 32413
+    WGS72BE_UTM_zone_14N = 32414
+    WGS72BE_UTM_zone_15N = 32415
+    WGS72BE_UTM_zone_16N = 32416
+    WGS72BE_UTM_zone_17N = 32417
+    WGS72BE_UTM_zone_18N = 32418
+    WGS72BE_UTM_zone_19N = 32419
+    WGS72BE_UTM_zone_20N = 32420
+    WGS72BE_UTM_zone_21N = 32421
+    WGS72BE_UTM_zone_22N = 32422
+    WGS72BE_UTM_zone_23N = 32423
+    WGS72BE_UTM_zone_24N = 32424
+    WGS72BE_UTM_zone_25N = 32425
+    WGS72BE_UTM_zone_26N = 32426
+    WGS72BE_UTM_zone_27N = 32427
+    WGS72BE_UTM_zone_28N = 32428
+    WGS72BE_UTM_zone_29N = 32429
+    WGS72BE_UTM_zone_30N = 32430
+    WGS72BE_UTM_zone_31N = 32431
+    WGS72BE_UTM_zone_32N = 32432
+    WGS72BE_UTM_zone_33N = 32433
+    WGS72BE_UTM_zone_34N = 32434
+    WGS72BE_UTM_zone_35N = 32435
+    WGS72BE_UTM_zone_36N = 32436
+    WGS72BE_UTM_zone_37N = 32437
+    WGS72BE_UTM_zone_38N = 32438
+    WGS72BE_UTM_zone_39N = 32439
+    WGS72BE_UTM_zone_40N = 32440
+    WGS72BE_UTM_zone_41N = 32441
+    WGS72BE_UTM_zone_42N = 32442
+    WGS72BE_UTM_zone_43N = 32443
+    WGS72BE_UTM_zone_44N = 32444
+    WGS72BE_UTM_zone_45N = 32445
+    WGS72BE_UTM_zone_46N = 32446
+    WGS72BE_UTM_zone_47N = 32447
+    WGS72BE_UTM_zone_48N = 32448
+    WGS72BE_UTM_zone_49N = 32449
+    WGS72BE_UTM_zone_50N = 32450
+    WGS72BE_UTM_zone_51N = 32451
+    WGS72BE_UTM_zone_52N = 32452
+    WGS72BE_UTM_zone_53N = 32453
+    WGS72BE_UTM_zone_54N = 32454
+    WGS72BE_UTM_zone_55N = 32455
+    WGS72BE_UTM_zone_56N = 32456
+    WGS72BE_UTM_zone_57N = 32457
+    WGS72BE_UTM_zone_58N = 32458
+    WGS72BE_UTM_zone_59N = 32459
+    WGS72BE_UTM_zone_60N = 32460
+    WGS72BE_UTM_zone_1S = 32501
+    WGS72BE_UTM_zone_2S = 32502
+    WGS72BE_UTM_zone_3S = 32503
+    WGS72BE_UTM_zone_4S = 32504
+    WGS72BE_UTM_zone_5S = 32505
+    WGS72BE_UTM_zone_6S = 32506
+    WGS72BE_UTM_zone_7S = 32507
+    WGS72BE_UTM_zone_8S = 32508
+    WGS72BE_UTM_zone_9S = 32509
+    WGS72BE_UTM_zone_10S = 32510
+    WGS72BE_UTM_zone_11S = 32511
+    WGS72BE_UTM_zone_12S = 32512
+    WGS72BE_UTM_zone_13S = 32513
+    WGS72BE_UTM_zone_14S = 32514
+    WGS72BE_UTM_zone_15S = 32515
+    WGS72BE_UTM_zone_16S = 32516
+    WGS72BE_UTM_zone_17S = 32517
+    WGS72BE_UTM_zone_18S = 32518
+    WGS72BE_UTM_zone_19S = 32519
+    WGS72BE_UTM_zone_20S = 32520
+    WGS72BE_UTM_zone_21S = 32521
+    WGS72BE_UTM_zone_22S = 32522
+    WGS72BE_UTM_zone_23S = 32523
+    WGS72BE_UTM_zone_24S = 32524
+    WGS72BE_UTM_zone_25S = 32525
+    WGS72BE_UTM_zone_26S = 32526
+    WGS72BE_UTM_zone_27S = 32527
+    WGS72BE_UTM_zone_28S = 32528
+    WGS72BE_UTM_zone_29S = 32529
+    WGS72BE_UTM_zone_30S = 32530
+    WGS72BE_UTM_zone_31S = 32531
+    WGS72BE_UTM_zone_32S = 32532
+    WGS72BE_UTM_zone_33S = 32533
+    WGS72BE_UTM_zone_34S = 32534
+    WGS72BE_UTM_zone_35S = 32535
+    WGS72BE_UTM_zone_36S = 32536
+    WGS72BE_UTM_zone_37S = 32537
+    WGS72BE_UTM_zone_38S = 32538
+    WGS72BE_UTM_zone_39S = 32539
+    WGS72BE_UTM_zone_40S = 32540
+    WGS72BE_UTM_zone_41S = 32541
+    WGS72BE_UTM_zone_42S = 32542
+    WGS72BE_UTM_zone_43S = 32543
+    WGS72BE_UTM_zone_44S = 32544
+    WGS72BE_UTM_zone_45S = 32545
+    WGS72BE_UTM_zone_46S = 32546
+    WGS72BE_UTM_zone_47S = 32547
+    WGS72BE_UTM_zone_48S = 32548
+    WGS72BE_UTM_zone_49S = 32549
+    WGS72BE_UTM_zone_50S = 32550
+    WGS72BE_UTM_zone_51S = 32551
+    WGS72BE_UTM_zone_52S = 32552
+    WGS72BE_UTM_zone_53S = 32553
+    WGS72BE_UTM_zone_54S = 32554
+    WGS72BE_UTM_zone_55S = 32555
+    WGS72BE_UTM_zone_56S = 32556
+    WGS72BE_UTM_zone_57S = 32557
+    WGS72BE_UTM_zone_58S = 32558
+    WGS72BE_UTM_zone_59S = 32559
+    WGS72BE_UTM_zone_60S = 32560
+    WGS84_UTM_zone_1N = 32601
+    WGS84_UTM_zone_2N = 32602
+    WGS84_UTM_zone_3N = 32603
+    WGS84_UTM_zone_4N = 32604
+    WGS84_UTM_zone_5N = 32605
+    WGS84_UTM_zone_6N = 32606
+    WGS84_UTM_zone_7N = 32607
+    WGS84_UTM_zone_8N = 32608
+    WGS84_UTM_zone_9N = 32609
+    WGS84_UTM_zone_10N = 32610
+    WGS84_UTM_zone_11N = 32611
+    WGS84_UTM_zone_12N = 32612
+    WGS84_UTM_zone_13N = 32613
+    WGS84_UTM_zone_14N = 32614
+    WGS84_UTM_zone_15N = 32615
+    WGS84_UTM_zone_16N = 32616
+    WGS84_UTM_zone_17N = 32617
+    WGS84_UTM_zone_18N = 32618
+    WGS84_UTM_zone_19N = 32619
+    WGS84_UTM_zone_20N = 32620
+    WGS84_UTM_zone_21N = 32621
+    WGS84_UTM_zone_22N = 32622
+    WGS84_UTM_zone_23N = 32623
+    WGS84_UTM_zone_24N = 32624
+    WGS84_UTM_zone_25N = 32625
+    WGS84_UTM_zone_26N = 32626
+    WGS84_UTM_zone_27N = 32627
+    WGS84_UTM_zone_28N = 32628
+    WGS84_UTM_zone_29N = 32629
+    WGS84_UTM_zone_30N = 32630
+    WGS84_UTM_zone_31N = 32631
+    WGS84_UTM_zone_32N = 32632
+    WGS84_UTM_zone_33N = 32633
+    WGS84_UTM_zone_34N = 32634
+    WGS84_UTM_zone_35N = 32635
+    WGS84_UTM_zone_36N = 32636
+    WGS84_UTM_zone_37N = 32637
+    WGS84_UTM_zone_38N = 32638
+    WGS84_UTM_zone_39N = 32639
+    WGS84_UTM_zone_40N = 32640
+    WGS84_UTM_zone_41N = 32641
+    WGS84_UTM_zone_42N = 32642
+    WGS84_UTM_zone_43N = 32643
+    WGS84_UTM_zone_44N = 32644
+    WGS84_UTM_zone_45N = 32645
+    WGS84_UTM_zone_46N = 32646
+    WGS84_UTM_zone_47N = 32647
+    WGS84_UTM_zone_48N = 32648
+    WGS84_UTM_zone_49N = 32649
+    WGS84_UTM_zone_50N = 32650
+    WGS84_UTM_zone_51N = 32651
+    WGS84_UTM_zone_52N = 32652
+    WGS84_UTM_zone_53N = 32653
+    WGS84_UTM_zone_54N = 32654
+    WGS84_UTM_zone_55N = 32655
+    WGS84_UTM_zone_56N = 32656
+    WGS84_UTM_zone_57N = 32657
+    WGS84_UTM_zone_58N = 32658
+    WGS84_UTM_zone_59N = 32659
+    WGS84_UTM_zone_60N = 32660
+    WGS84_UTM_zone_1S = 32701
+    WGS84_UTM_zone_2S = 32702
+    WGS84_UTM_zone_3S = 32703
+    WGS84_UTM_zone_4S = 32704
+    WGS84_UTM_zone_5S = 32705
+    WGS84_UTM_zone_6S = 32706
+    WGS84_UTM_zone_7S = 32707
+    WGS84_UTM_zone_8S = 32708
+    WGS84_UTM_zone_9S = 32709
+    WGS84_UTM_zone_10S = 32710
+    WGS84_UTM_zone_11S = 32711
+    WGS84_UTM_zone_12S = 32712
+    WGS84_UTM_zone_13S = 32713
+    WGS84_UTM_zone_14S = 32714
+    WGS84_UTM_zone_15S = 32715
+    WGS84_UTM_zone_16S = 32716
+    WGS84_UTM_zone_17S = 32717
+    WGS84_UTM_zone_18S = 32718
+    WGS84_UTM_zone_19S = 32719
+    WGS84_UTM_zone_20S = 32720
+    WGS84_UTM_zone_21S = 32721
+    WGS84_UTM_zone_22S = 32722
+    WGS84_UTM_zone_23S = 32723
+    WGS84_UTM_zone_24S = 32724
+    WGS84_UTM_zone_25S = 32725
+    WGS84_UTM_zone_26S = 32726
+    WGS84_UTM_zone_27S = 32727
+    WGS84_UTM_zone_28S = 32728
+    WGS84_UTM_zone_29S = 32729
+    WGS84_UTM_zone_30S = 32730
+    WGS84_UTM_zone_31S = 32731
+    WGS84_UTM_zone_32S = 32732
+    WGS84_UTM_zone_33S = 32733
+    WGS84_UTM_zone_34S = 32734
+    WGS84_UTM_zone_35S = 32735
+    WGS84_UTM_zone_36S = 32736
+    WGS84_UTM_zone_37S = 32737
+    WGS84_UTM_zone_38S = 32738
+    WGS84_UTM_zone_39S = 32739
+    WGS84_UTM_zone_40S = 32740
+    WGS84_UTM_zone_41S = 32741
+    WGS84_UTM_zone_42S = 32742
+    WGS84_UTM_zone_43S = 32743
+    WGS84_UTM_zone_44S = 32744
+    WGS84_UTM_zone_45S = 32745
+    WGS84_UTM_zone_46S = 32746
+    WGS84_UTM_zone_47S = 32747
+    WGS84_UTM_zone_48S = 32748
+    WGS84_UTM_zone_49S = 32749
+    WGS84_UTM_zone_50S = 32750
+    WGS84_UTM_zone_51S = 32751
+    WGS84_UTM_zone_52S = 32752
+    WGS84_UTM_zone_53S = 32753
+    WGS84_UTM_zone_54S = 32754
+    WGS84_UTM_zone_55S = 32755
+    WGS84_UTM_zone_56S = 32756
+    WGS84_UTM_zone_57S = 32757
+    WGS84_UTM_zone_58S = 32758
+    WGS84_UTM_zone_59S = 32759
+    WGS84_UTM_zone_60S = 32760
+    # New
+    GGRS87_Greek_Grid = 2100
+    KKJ_Finland_zone_1 = 2391
+    KKJ_Finland_zone_2 = 2392
+    KKJ_Finland_zone_3 = 2393
+    KKJ_Finland_zone_4 = 2394
+    RT90_2_5_gon_W = 2400
+    Lietuvos_Koordinoei_Sistema_1994 = 2600
+    Estonian_Coordinate_System_of_1992 = 3300
+    HD72_EOV = 23700
+    Dealul_Piscului_1970_Stereo_70 = 31700
+    # Newer
+    Hjorsey_1955_Lambert = 3053
+    ISN93_Lambert_1993 = 3057
+    ETRS89_Poland_CS2000_zone_5 = 2176
+    ETRS89_Poland_CS2000_zone_6 = 2177
+    ETRS89_Poland_CS2000_zone_7 = 2177
+    ETRS89_Poland_CS2000_zone_8 = 2178
+    ETRS89_Poland_CS92 = 2180
+
+
+class GCSE(enum.IntEnum):
+    """Unspecified GCS based on ellipsoid."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Airy1830 = 4001
+    AiryModified1849 = 4002
+    AustralianNationalSpheroid = 4003
+    Bessel1841 = 4004
+    BesselModified = 4005
+    BesselNamibia = 4006
+    Clarke1858 = 4007
+    Clarke1866 = 4008
+    Clarke1866Michigan = 4009
+    Clarke1880_Benoit = 4010
+    Clarke1880_IGN = 4011
+    Clarke1880_RGS = 4012
+    Clarke1880_Arc = 4013
+    Clarke1880_SGA1922 = 4014
+    Everest1830_1937Adjustment = 4015
+    Everest1830_1967Definition = 4016
+    Everest1830_1975Definition = 4017
+    Everest1830Modified = 4018
+    GRS1980 = 4019
+    Helmert1906 = 4020
+    IndonesianNationalSpheroid = 4021
+    International1924 = 4022
+    International1967 = 4023
+    Krassowsky1940 = 4024
+    NWL9D = 4025
+    NWL10D = 4026
+    Plessis1817 = 4027
+    Struve1860 = 4028
+    WarOffice = 4029
+    WGS84 = 4030
+    GEM10C = 4031
+    OSU86F = 4032
+    OSU91A = 4033
+    Clarke1880 = 4034
+    Sphere = 4035
+
+
+class GCS(enum.IntEnum):
+    """Geographic CS Type Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Adindan = 4201
+    AGD66 = 4202
+    AGD84 = 4203
+    Ain_el_Abd = 4204
+    Afgooye = 4205
+    Agadez = 4206
+    Lisbon = 4207
+    Aratu = 4208
+    Arc_1950 = 4209
+    Arc_1960 = 4210
+    Batavia = 4211
+    Barbados = 4212
+    Beduaram = 4213
+    Beijing_1954 = 4214
+    Belge_1950 = 4215
+    Bermuda_1957 = 4216
+    Bern_1898 = 4217
+    Bogota = 4218
+    Bukit_Rimpah = 4219
+    Camacupa = 4220
+    Campo_Inchauspe = 4221
+    Cape = 4222
+    Carthage = 4223
+    Chua = 4224
+    Corrego_Alegre = 4225
+    Cote_d_Ivoire = 4226
+    Deir_ez_Zor = 4227
+    Douala = 4228
+    Egypt_1907 = 4229
+    ED50 = 4230
+    ED87 = 4231
+    Fahud = 4232
+    Gandajika_1970 = 4233
+    Garoua = 4234
+    Guyane_Francaise = 4235
+    Hu_Tzu_Shan = 4236
+    HD72 = 4237
+    ID74 = 4238
+    Indian_1954 = 4239
+    Indian_1975 = 4240
+    Jamaica_1875 = 4241
+    JAD69 = 4242
+    Kalianpur = 4243
+    Kandawala = 4244
+    Kertau = 4245
+    KOC = 4246
+    La_Canoa = 4247
+    PSAD56 = 4248
+    Lake = 4249
+    Leigon = 4250
+    Liberia_1964 = 4251
+    Lome = 4252
+    Luzon_1911 = 4253
+    Hito_XVIII_1963 = 4254
+    Herat_North = 4255
+    Mahe_1971 = 4256
+    Makassar = 4257
+    EUREF89 = 4258
+    Malongo_1987 = 4259
+    Manoca = 4260
+    Merchich = 4261
+    Massawa = 4262
+    Minna = 4263
+    Mhast = 4264
+    Monte_Mario = 4265
+    M_poraloko = 4266
+    NAD27 = 4267
+    NAD_Michigan = 4268
+    NAD83 = 4269
+    Nahrwan_1967 = 4270
+    Naparima_1972 = 4271
+    GD49 = 4272
+    NGO_1948 = 4273
+    Datum_73 = 4274
+    NTF = 4275
+    NSWC_9Z_2 = 4276
+    OSGB_1936 = 4277
+    OSGB70 = 4278
+    OS_SN80 = 4279
+    Padang = 4280
+    Palestine_1923 = 4281
+    Pointe_Noire = 4282
+    GDA94 = 4283
+    Pulkovo_1942 = 4284
+    Qatar = 4285
+    Qatar_1948 = 4286
+    Qornoq = 4287
+    Loma_Quintana = 4288
+    Amersfoort = 4289
+    RT38 = 4290
+    SAD69 = 4291
+    Sapper_Hill_1943 = 4292
+    Schwarzeck = 4293
+    Segora = 4294
+    Serindung = 4295
+    Sudan = 4296
+    Tananarive = 4297
+    Timbalai_1948 = 4298
+    TM65 = 4299
+    TM75 = 4300
+    Tokyo = 4301
+    Trinidad_1903 = 4302
+    TC_1948 = 4303
+    Voirol_1875 = 4304
+    Voirol_Unifie = 4305
+    Bern_1938 = 4306
+    Nord_Sahara_1959 = 4307
+    Stockholm_1938 = 4308
+    Yacare = 4309
+    Yoff = 4310
+    Zanderij = 4311
+    MGI = 4312
+    Belge_1972 = 4313
+    DHDN = 4314
+    Conakry_1905 = 4315
+    WGS_72 = 4322
+    WGS_72BE = 4324
+    WGS_84 = 4326
+    Bern_1898_Bern = 4801
+    Bogota_Bogota = 4802
+    Lisbon_Lisbon = 4803
+    Makassar_Jakarta = 4804
+    MGI_Ferro = 4805
+    Monte_Mario_Rome = 4806
+    NTF_Paris = 4807
+    Padang_Jakarta = 4808
+    Belge_1950_Brussels = 4809
+    Tananarive_Paris = 4810
+    Voirol_1875_Paris = 4811
+    Voirol_Unifie_Paris = 4812
+    Batavia_Jakarta = 4813
+    ATF_Paris = 4901
+    NDG_Paris = 4902
+    # New GCS
+    Greek = 4120
+    GGRS87 = 4121
+    KKJ = 4123
+    RT90 = 4124
+    EST92 = 4133
+    Dealul_Piscului_1970 = 4317
+    Greek_Athens = 4815
+
+
+class Ellipse(enum.IntEnum):
+    """Ellipsoid Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Airy_1830 = 7001
+    Airy_Modified_1849 = 7002
+    Australian_National_Spheroid = 7003
+    Bessel_1841 = 7004
+    Bessel_Modified = 7005
+    Bessel_Namibia = 7006
+    Clarke_1858 = 7007
+    Clarke_1866 = 7008
+    Clarke_1866_Michigan = 7009
+    Clarke_1880_Benoit = 7010
+    Clarke_1880_IGN = 7011
+    Clarke_1880_RGS = 7012
+    Clarke_1880_Arc = 7013
+    Clarke_1880_SGA_1922 = 7014
+    Everest_1830_1937_Adjustment = 7015
+    Everest_1830_1967_Definition = 7016
+    Everest_1830_1975_Definition = 7017
+    Everest_1830_Modified = 7018
+    GRS_1980 = 7019
+    Helmert_1906 = 7020
+    Indonesian_National_Spheroid = 7021
+    International_1924 = 7022
+    International_1967 = 7023
+    Krassowsky_1940 = 7024
+    NWL_9D = 7025
+    NWL_10D = 7026
+    Plessis_1817 = 7027
+    Struve_1860 = 7028
+    War_Office = 7029
+    WGS_84 = 7030
+    GEM_10C = 7031
+    OSU86F = 7032
+    OSU91A = 7033
+    Clarke_1880 = 7034
+    Sphere = 7035
+
+
+class DatumE(enum.IntEnum):
+    """Ellipsoid-Only Geodetic Datum Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Airy1830 = 6001
+    AiryModified1849 = 6002
+    AustralianNationalSpheroid = 6003
+    Bessel1841 = 6004
+    BesselModified = 6005
+    BesselNamibia = 6006
+    Clarke1858 = 6007
+    Clarke1866 = 6008
+    Clarke1866Michigan = 6009
+    Clarke1880_Benoit = 6010
+    Clarke1880_IGN = 6011
+    Clarke1880_RGS = 6012
+    Clarke1880_Arc = 6013
+    Clarke1880_SGA1922 = 6014
+    Everest1830_1937Adjustment = 6015
+    Everest1830_1967Definition = 6016
+    Everest1830_1975Definition = 6017
+    Everest1830Modified = 6018
+    GRS1980 = 6019
+    Helmert1906 = 6020
+    IndonesianNationalSpheroid = 6021
+    International1924 = 6022
+    International1967 = 6023
+    Krassowsky1960 = 6024
+    NWL9D = 6025
+    NWL10D = 6026
+    Plessis1817 = 6027
+    Struve1860 = 6028
+    WarOffice = 6029
+    WGS84 = 6030
+    GEM10C = 6031
+    OSU86F = 6032
+    OSU91A = 6033
+    Clarke1880 = 6034
+    Sphere = 6035
+
+
+class Datum(enum.IntEnum):
+    """Geodetic Datum Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Adindan = 6201
+    Australian_Geodetic_Datum_1966 = 6202
+    Australian_Geodetic_Datum_1984 = 6203
+    Ain_el_Abd_1970 = 6204
+    Afgooye = 6205
+    Agadez = 6206
+    Lisbon = 6207
+    Aratu = 6208
+    Arc_1950 = 6209
+    Arc_1960 = 6210
+    Batavia = 6211
+    Barbados = 6212
+    Beduaram = 6213
+    Beijing_1954 = 6214
+    Reseau_National_Belge_1950 = 6215
+    Bermuda_1957 = 6216
+    Bern_1898 = 6217
+    Bogota = 6218
+    Bukit_Rimpah = 6219
+    Camacupa = 6220
+    Campo_Inchauspe = 6221
+    Cape = 6222
+    Carthage = 6223
+    Chua = 6224
+    Corrego_Alegre = 6225
+    Cote_d_Ivoire = 6226
+    Deir_ez_Zor = 6227
+    Douala = 6228
+    Egypt_1907 = 6229
+    European_Datum_1950 = 6230
+    European_Datum_1987 = 6231
+    Fahud = 6232
+    Gandajika_1970 = 6233
+    Garoua = 6234
+    Guyane_Francaise = 6235
+    Hu_Tzu_Shan = 6236
+    Hungarian_Datum_1972 = 6237
+    Indonesian_Datum_1974 = 6238
+    Indian_1954 = 6239
+    Indian_1975 = 6240
+    Jamaica_1875 = 6241
+    Jamaica_1969 = 6242
+    Kalianpur = 6243
+    Kandawala = 6244
+    Kertau = 6245
+    Kuwait_Oil_Company = 6246
+    La_Canoa = 6247
+    Provisional_S_American_Datum_1956 = 6248
+    Lake = 6249
+    Leigon = 6250
+    Liberia_1964 = 6251
+    Lome = 6252
+    Luzon_1911 = 6253
+    Hito_XVIII_1963 = 6254
+    Herat_North = 6255
+    Mahe_1971 = 6256
+    Makassar = 6257
+    European_Reference_System_1989 = 6258
+    Malongo_1987 = 6259
+    Manoca = 6260
+    Merchich = 6261
+    Massawa = 6262
+    Minna = 6263
+    Mhast = 6264
+    Monte_Mario = 6265
+    M_poraloko = 6266
+    North_American_Datum_1927 = 6267
+    NAD_Michigan = 6268
+    North_American_Datum_1983 = 6269
+    Nahrwan_1967 = 6270
+    Naparima_1972 = 6271
+    New_Zealand_Geodetic_Datum_1949 = 6272
+    NGO_1948 = 6273
+    Datum_73 = 6274
+    Nouvelle_Triangulation_Francaise = 6275
+    NSWC_9Z_2 = 6276
+    OSGB_1936 = 6277
+    OSGB_1970_SN = 6278
+    OS_SN_1980 = 6279
+    Padang_1884 = 6280
+    Palestine_1923 = 6281
+    Pointe_Noire = 6282
+    Geocentric_Datum_of_Australia_1994 = 6283
+    Pulkovo_1942 = 6284
+    Qatar = 6285
+    Qatar_1948 = 6286
+    Qornoq = 6287
+    Loma_Quintana = 6288
+    Amersfoort = 6289
+    RT38 = 6290
+    South_American_Datum_1969 = 6291
+    Sapper_Hill_1943 = 6292
+    Schwarzeck = 6293
+    Segora = 6294
+    Serindung = 6295
+    Sudan = 6296
+    Tananarive_1925 = 6297
+    Timbalai_1948 = 6298
+    TM65 = 6299
+    TM75 = 6300
+    Tokyo = 6301
+    Trinidad_1903 = 6302
+    Trucial_Coast_1948 = 6303
+    Voirol_1875 = 6304
+    Voirol_Unifie_1960 = 6305
+    Bern_1938 = 6306
+    Nord_Sahara_1959 = 6307
+    Stockholm_1938 = 6308
+    Yacare = 6309
+    Yoff = 6310
+    Zanderij = 6311
+    Militar_Geographische_Institut = 6312
+    Reseau_National_Belge_1972 = 6313
+    Deutsche_Hauptdreiecksnetz = 6314
+    Conakry_1905 = 6315
+    Dealul_Piscului_1930 = 6316
+    Dealul_Piscului_1970 = 6317
+
+    WGS72 = 6322
+    WGS72_Transit_Broadcast_Ephemeris = 6324
+    WGS84 = 6326
+    Ancienne_Triangulation_Francaise = 6901
+    Nord_de_Guerre = 6902
+
+
+class ModelType(enum.IntEnum):
+    """Model Type Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Projected = 1
+    Geographic = 2
+    Geocentric = 3
+
+
+class RasterPixel(enum.IntEnum):
+    """Raster Type Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    IsArea = 1
+    IsPoint = 2
+
+
+class Linear(enum.IntEnum):
+    """Linear Units."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Meter = 9001
+    Foot = 9002
+    Foot_US_Survey = 9003
+    Foot_Modified_American = 9004
+    Foot_Clarke = 9005
+    Foot_Indian = 9006
+    Link = 9007
+    Link_Benoit = 9008
+    Link_Sears = 9009
+    Chain_Benoit = 9010
+    Chain_Sears = 9011
+    Yard_Sears = 9012
+    Yard_Indian = 9013
+    Fathom = 9014
+    Mile_International_Nautical = 9015
+
+
+class Angular(enum.IntEnum):
+    """Angular Units."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Radian = 9101
+    Degree = 9102
+    Arc_Minute = 9103
+    Arc_Second = 9104
+    Grad = 9105
+    Gon = 9106
+    DMS = 9107
+    DMS_Hemisphere = 9108
+
+
+class PM(enum.IntEnum):
+    """Prime Meridian Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Greenwich = 8901
+    Lisbon = 8902
+    Paris = 8903
+    Bogota = 8904
+    Madrid = 8905
+    Rome = 8906
+    Bern = 8907
+    Jakarta = 8908
+    Ferro = 8909
+    Brussels = 8910
+    Stockholm = 8911
+
+
+class CT(enum.IntEnum):
+    """Coordinate Transformation Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    TransverseMercator = 1
+    TransvMercator_Modified_Alaska = 2
+    ObliqueMercator = 3
+    ObliqueMercator_Laborde = 4
+    ObliqueMercator_Rosenmund = 5
+    ObliqueMercator_Spherical = 6
+    Mercator = 7
+    LambertConfConic_2SP = 8
+    LambertConfConic_Helmert = 9
+    LambertAzimEqualArea = 10
+    AlbersEqualArea = 11
+    AzimuthalEquidistant = 12
+    EquidistantConic = 13
+    Stereographic = 14
+    PolarStereographic = 15
+    ObliqueStereographic = 16
+    Equirectangular = 17
+    CassiniSoldner = 18
+    Gnomonic = 19
+    MillerCylindrical = 20
+    Orthographic = 21
+    Polyconic = 22
+    Robinson = 23
+    Sinusoidal = 24
+    VanDerGrinten = 25
+    NewZealandMapGrid = 26
+    TransvMercator_SouthOriented = 27
+    CylindricalEqualArea = 28
+    HotineObliqueMercatorAzimuthCenter = 9815
+
+
+class VertCS(enum.IntEnum):
+    """Vertical CS Type Codes."""
+
+    Undefined = 0
+    User_Defined = 32767
+    Airy_1830_ellipsoid = 5001
+    Airy_Modified_1849_ellipsoid = 5002
+    ANS_ellipsoid = 5003
+    Bessel_1841_ellipsoid = 5004
+    Bessel_Modified_ellipsoid = 5005
+    Bessel_Namibia_ellipsoid = 5006
+    Clarke_1858_ellipsoid = 5007
+    Clarke_1866_ellipsoid = 5008
+    Clarke_1880_Benoit_ellipsoid = 5010
+    Clarke_1880_IGN_ellipsoid = 5011
+    Clarke_1880_RGS_ellipsoid = 5012
+    Clarke_1880_Arc_ellipsoid = 5013
+    Clarke_1880_SGA_1922_ellipsoid = 5014
+    Everest_1830_1937_Adjustment_ellipsoid = 5015
+    Everest_1830_1967_Definition_ellipsoid = 5016
+    Everest_1830_1975_Definition_ellipsoid = 5017
+    Everest_1830_Modified_ellipsoid = 5018
+    GRS_1980_ellipsoid = 5019
+    Helmert_1906_ellipsoid = 5020
+    INS_ellipsoid = 5021
+    International_1924_ellipsoid = 5022
+    International_1967_ellipsoid = 5023
+    Krassowsky_1940_ellipsoid = 5024
+    NWL_9D_ellipsoid = 5025
+    NWL_10D_ellipsoid = 5026
+    Plessis_1817_ellipsoid = 5027
+    Struve_1860_ellipsoid = 5028
+    War_Office_ellipsoid = 5029
+    WGS_84_ellipsoid = 5030
+    GEM_10C_ellipsoid = 5031
+    OSU86F_ellipsoid = 5032
+    OSU91A_ellipsoid = 5033
+    # Orthometric Vertical CS
+    Newlyn = 5101
+    North_American_Vertical_Datum_1929 = 5102
+    North_American_Vertical_Datum_1988 = 5103
+    Yellow_Sea_1956 = 5104
+    Baltic_Sea = 5105
+    Caspian_Sea = 5106
+
+
+GEO_CODES: dict[int, type[enum.IntEnum]] = {
+    # map :py:class:`GeoKeys` to GeoTIFF codes
+    GeoKeys.GTModelTypeGeoKey: ModelType,
+    GeoKeys.GTRasterTypeGeoKey: RasterPixel,
+    GeoKeys.GeographicTypeGeoKey: GCS,
+    GeoKeys.GeogPrimeMeridianGeoKey: PM,
+    GeoKeys.GeogLinearUnitsGeoKey: Linear,
+    GeoKeys.GeogAngularUnitsGeoKey: Angular,
+    GeoKeys.GeogEllipsoidGeoKey: Ellipse,
+    GeoKeys.GeogAzimuthUnitsGeoKey: Angular,
+    GeoKeys.ProjectedCSTypeGeoKey: PCS,
+    GeoKeys.ProjectionGeoKey: Proj,
+    GeoKeys.ProjCoordTransGeoKey: CT,
+    GeoKeys.ProjLinearUnitsGeoKey: Linear,
+    GeoKeys.VerticalCSTypeGeoKey: VertCS,
+    # GeoKeys.VerticalDatumGeoKey: VertCS,
+    GeoKeys.VerticalUnitsGeoKey: Linear,
+}

envs/kitoverlay/tifffile/lsm2bin.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# tifffile/lsm2bin.py
+
+"""Convert [MP]TZCYX LSM file to series of BIN files."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+try:
+    from .tifffile import lsm2bin
+except ImportError:
+    try:
+        from tifffile.tifffile import lsm2bin
+    except ImportError:
+        from tifffile import lsm2bin  # noqa: PLW0406
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Lsm2bin command line usage main function."""
+    parser = argparse.ArgumentParser(
+        prog='lsm2bin',
+        description='Convert [MP]TZCYX LSM file to series of BIN files.',
+        epilog='Example: lsm2bin input.lsm output --tile 512 512',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument('lsmfile', help='path to the LSM input file')
+    parser.add_argument(
+        'binfile',
+        nargs='?',
+        help='common name of output BIN files (default: lsmfile name)',
+    )
+    parser.add_argument(
+        '--tile',
+        nargs=2,
+        type=int,
+        metavar=('Y', 'X'),
+        help='tile Y and X dimensions (default: 256 256)',
+    )
+    parser.add_argument(
+        '--quiet',
+        action='store_true',
+        help='suppress progress output',
+    )
+    args = parser.parse_args(None if argv is None else argv[1:])
+
+    if args.tile is not None and any(v <= 0 for v in args.tile):
+        parser.error('--tile values must be positive integers')
+
+    tile = (args.tile[0], args.tile[1]) if args.tile is not None else None
+
+    try:
+        lsm2bin(
+            args.lsmfile,
+            args.binfile,
+            tile=tile,
+            verbose=not args.quiet,
+        )
+    except Exception as exc:
+        print(f'{args.lsmfile}: {exc}', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

envs/kitoverlay/tifffile/numcodecs.py

@@ -0,0 +1,166 @@
+# tifffile/numcodecs.py
+
+# Copyright (c) 2021-2026, Christoph Gohlke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""TIFF codec for the Numcodecs package."""
+
+from __future__ import annotations
+
+__all__ = ['Tiff', 'register_codec']
+
+from io import BytesIO
+from typing import TYPE_CHECKING
+
+from numcodecs import registry
+from numcodecs.abc import Codec
+
+from .tifffile import METADATA_DEFAULT, TiffFile, TiffWriter
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from typing import Any
+
+    from .tifffile import (
+        COMPRESSION,
+        EXTRASAMPLE,
+        PHOTOMETRIC,
+        PLANARCONFIG,
+        PREDICTOR,
+        ByteOrder,
+        TagTuple,
+    )
+
+
+class Tiff(Codec):  # type: ignore[misc]
+    """TIFF codec for Numcodecs."""
+
+    codec_id = 'tifffile'
+
+    def __init__(
+        self,
+        # TiffFile.asarray
+        key: int | slice | Sequence[int] | None = None,
+        series: int | None = None,
+        level: int | None = None,
+        squeeze: bool | None = None,
+        buffersize: int | None = None,
+        # TiffWriter
+        bigtiff: bool = False,
+        byteorder: ByteOrder | None = None,
+        imagej: bool = False,
+        ome: bool | None = None,
+        # TiffWriter.write
+        photometric: PHOTOMETRIC | int | str | None = None,
+        planarconfig: PLANARCONFIG | int | str | None = None,
+        extrasamples: Sequence[EXTRASAMPLE | int | str] | None = None,
+        volumetric: bool = False,
+        tile: Sequence[int] | None = None,
+        rowsperstrip: int | None = None,
+        compression: COMPRESSION | int | str | None = None,
+        compressionargs: dict[str, Any] | None = None,
+        predictor: PREDICTOR | int | str | bool | None = None,
+        subsampling: tuple[int, int] | None = None,
+        metadata: dict[str, Any] | None = METADATA_DEFAULT,
+        extratags: Sequence[TagTuple] | None = None,
+        truncate: bool = False,
+        maxworkers: int | None = None,
+    ) -> None:
+        self.key = key
+        self.series = series
+        self.level = level
+        self.squeeze = squeeze
+        self.buffersize = buffersize
+        self.bigtiff = bigtiff
+        self.byteorder = byteorder
+        self.imagej = imagej
+        self.ome = ome
+        self.photometric = photometric
+        self.planarconfig = planarconfig
+        self.extrasamples = extrasamples
+        self.volumetric = volumetric
+        self.tile = tile
+        self.rowsperstrip = rowsperstrip
+        self.compression = compression
+        self.compressionargs = compressionargs
+        self.predictor = predictor
+        self.subsampling = subsampling
+        self.metadata = metadata
+        self.extratags = extratags
+        self.truncate = truncate
+        self.maxworkers = maxworkers
+
+    def encode(self, buf: Any) -> bytes:
+        """Return TIFF file as bytes."""
+        with BytesIO() as fh:
+            with TiffWriter(
+                fh,
+                bigtiff=self.bigtiff,
+                byteorder=self.byteorder,
+                imagej=self.imagej,
+                ome=self.ome,
+            ) as tif:
+                tif.write(
+                    buf,
+                    photometric=self.photometric,
+                    planarconfig=self.planarconfig,
+                    extrasamples=self.extrasamples,
+                    volumetric=self.volumetric,
+                    tile=self.tile,
+                    rowsperstrip=self.rowsperstrip,
+                    compression=self.compression,
+                    compressionargs=self.compressionargs,
+                    predictor=self.predictor,
+                    subsampling=self.subsampling,
+                    metadata=self.metadata,
+                    extratags=self.extratags,
+                    truncate=self.truncate,
+                    maxworkers=self.maxworkers,
+                )
+            return fh.getvalue()
+
+    def decode(self, buf: Any, out: Any = None) -> Any:
+        """Return decoded image as NumPy array."""
+        with BytesIO(buf) as fh, TiffFile(fh) as tif:
+            return tif.asarray(
+                key=self.key,
+                series=self.series,
+                level=self.level,
+                squeeze=self.squeeze,
+                maxworkers=self.maxworkers,
+                buffersize=self.buffersize,
+                out=out,
+            )
+
+
+def register_codec(
+    cls: type[Codec] = Tiff, codec_id: str | None = None
+) -> None:
+    """Register :py:class:`Tiff` codec with Numcodecs."""
+    registry.register_codec(cls, codec_id=codec_id)

envs/kitoverlay/tifffile/tiff2fsspec.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# tifffile/tiff2fsspec.py
+
+"""Write fsspec ReferenceFileSystem for TIFF file."""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import json
+import sys
+from typing import Any
+
+try:
+    from .tifffile import tiff2fsspec
+except ImportError:
+    try:
+        from tifffile.tifffile import tiff2fsspec
+    except ImportError:
+        from tifffile import tiff2fsspec  # noqa: PLW0406
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Tiff2fsspec command line usage main function."""
+    parser = argparse.ArgumentParser(
+        prog='tiff2fsspec',
+        description='Write fsspec ReferenceFileSystem for TIFF file.',
+        epilog='Example: tiff2fsspec ./test.ome.tif https://server.com/path/',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument('tifffile', help='path to the local TIFF input file')
+    parser.add_argument(
+        'url', help='remote URL of TIFF file without file name'
+    )
+    parser.add_argument('--out', help='path to the JSON output file')
+    parser.add_argument('--series', type=int, help='index of series in file')
+    parser.add_argument('--level', type=int, help='index of level in series')
+    parser.add_argument(
+        '--key', type=int, help='index of page in file or series'
+    )
+    parser.add_argument(
+        '--chunkmode',
+        metavar='mode',
+        help='mode used for chunking (int or string, e.g. "pages")',
+    )
+    parser.add_argument(
+        '--fillvalue',
+        type=float,
+        help='fill value for missing data',
+    )
+    parser.add_argument(
+        '--squeeze',
+        action=argparse.BooleanOptionalAction,
+        help='squeeze length-1 dimensions from zarr store',
+    )
+    parser.add_argument(
+        '--groupname',
+        help='name of the zarr group in the fsspec output',
+    )
+    parser.add_argument(
+        '--zattrs',
+        metavar='JSON',
+        help='custom Zarr attributes as a JSON object string',
+    )
+    parser.add_argument(
+        '--ref-version',
+        dest='version',
+        type=int,
+        help='version of ReferenceFileSystem spec',
+    )
+    args = parser.parse_args(None if argv is None else argv[1:])
+
+    chunkmode: int | str | None = args.chunkmode
+    if chunkmode is not None:
+        with contextlib.suppress(ValueError):
+            chunkmode = int(chunkmode)
+
+    zattrs: dict[str, Any] | None = None
+    if args.zattrs is not None:
+        try:
+            zattrs = json.loads(args.zattrs)
+        except json.JSONDecodeError as exc:
+            parser.error(f'--zattrs is not valid JSON: {exc}')
+        if not isinstance(zattrs, dict):
+            parser.error(
+                '--zattrs must be a JSON object, not an array or scalar'
+            )
+
+    try:
+        tiff2fsspec(
+            args.tifffile,
+            args.url,
+            out=args.out,
+            key=args.key,
+            series=args.series,
+            level=args.level,
+            chunkmode=chunkmode,
+            fillvalue=args.fillvalue,
+            squeeze=args.squeeze,
+            groupname=args.groupname,
+            zattrs=zattrs,
+            version=args.version,
+        )
+    except Exception as exc:
+        print(f'{args.tifffile}: {exc}', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

envs/kitoverlay/tifffile/tiffcomment.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# tifffile/tiffcomment.py
+
+"""Print or replace ImageDescription in first page of TIFF file."""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import sys
+
+try:
+    from .tifffile import tiffcomment
+except ImportError:
+    try:
+        from tifffile.tifffile import tiffcomment
+    except ImportError:
+        from tifffile import tiffcomment  # noqa: PLW0406
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Tiffcomment command line usage main function."""
+    parser = argparse.ArgumentParser(
+        prog='tiffcomment',
+        description=(
+            'Print or replace ImageDescription in first page of TIFF file.'
+        ),
+        epilog=(
+            'Example: tiffcomment --set "my description" image.tif\n'
+            'When multiple files are given with --set or --set-file,'
+            ' the same comment is written to all of them.'
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        'files',
+        nargs='+',
+        metavar='file',
+        help='TIFF file(s) to read or modify',
+    )
+    comment_group = parser.add_mutually_exclusive_group()
+    comment_group.add_argument(
+        '--set',
+        dest='comment',
+        metavar='comment',
+        help='replacement comment string',
+    )
+    comment_group.add_argument(
+        '--set-file',
+        dest='comment_file',
+        type=argparse.FileType('rb'),
+        metavar='file',
+        help='path to a file whose raw bytes replace the comment',
+    )
+    parser.add_argument(
+        '--page',
+        dest='pageindex',
+        type=int,
+        metavar='N',
+        help='index of page to read or modify (default: 0)',
+    )
+    parser.add_argument(
+        '--tag',
+        dest='tagcode',
+        metavar='code',
+        help='tag code or name to read or modify (default: ImageDescription)',
+    )
+    args = parser.parse_args(None if argv is None else argv[1:])
+
+    comment: bytes | None
+    if args.comment_file is not None:
+        with args.comment_file:
+            comment = args.comment_file.read()
+    elif args.comment is not None:
+        try:
+            comment = args.comment.encode('ascii')
+        except UnicodeEncodeError:
+            parser.error(
+                'comment contains non-ASCII characters;'
+                ' use --set-file with a pre-encoded file'
+            )
+            # comment = b''  # unreachable; satisfies mypy
+    else:
+        comment = None
+
+    tagcode: int | str | None = args.tagcode
+    if tagcode is not None:
+        with contextlib.suppress(ValueError):
+            tagcode = int(tagcode)
+
+    ret = 0
+    for file in args.files:
+        try:
+            result = tiffcomment(
+                file, comment, pageindex=args.pageindex, tagcode=tagcode
+            )
+        except Exception as exc:
+            print(f'{file}: {exc}', file=sys.stderr)
+            ret = 1
+        else:
+            if result:
+                if isinstance(result, bytes):
+                    result = result.decode(errors='replace')
+                if len(args.files) > 1:
+                    print(f'# {file}')
+                print(result)
+                if len(args.files) > 1:
+                    print()
+    return ret
+
+
+if __name__ == '__main__':
+    sys.exit(main())

envs/kitoverlay/tifffile/zarr.py

@@ -0,0 +1,1617 @@
+# tifffile/zarr.py
+
+# Copyright (c) 2008-2026, Christoph Gohlke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""Zarr 3 TIFF and file sequence stores."""
+
+from __future__ import annotations
+
+__all__ = ['ZarrFileSequenceStore', 'ZarrStore', 'ZarrTiffStore']
+
+import asyncio
+import base64
+import contextlib
+import json
+import sys
+from typing import TYPE_CHECKING
+
+import numpy
+import zarr
+
+try:
+    from zarr.abc.store import ByteRequest, Store
+    from zarr.core.buffer.cpu import NDBuffer
+    from zarr.core.chunk_grids import RegularChunkGrid
+    from zarr.core.indexing import BasicIndexer
+except ImportError as exc:
+    msg = f'zarr {zarr.__version__} < 3 is not supported'
+    raise ValueError(msg) from exc
+
+from .tifffile import (
+    CHUNKMODE,
+    COMPRESSION,
+    FileCache,
+    FileSequence,
+    NullContext,
+    TiffFrame,
+    TiffPage,
+    TiffPageSeries,
+    TiledSequence,
+    create_output,
+    enumarg,
+    imread,
+    jpeg_decode_colorspace,
+    product,
+)
+
+if TYPE_CHECKING:
+    import os
+    import threading
+    from collections.abc import (
+        AsyncIterator,
+        Callable,
+        Iterable,
+        Iterator,
+        Sequence,
+    )
+    from typing import Any, TextIO
+
+    from numpy.typing import DTypeLike, NDArray
+    from zarr.core.buffer import Buffer, BufferPrototype
+    from zarr.core.indexing import BasicSelection
+
+    from .tifffile import ByteOrder, OutputType
+
+
+class ZarrStore(Store):
+    """Zarr 3 store base class.
+
+    Parameters:
+        fillvalue:
+            Value to use for missing chunks of Zarr store.
+            The default is 0.
+        chunkmode:
+            Specifies how to chunk data.
+        read_only:
+            Passed to :py:class:`zarr.abc.store.Store`.
+
+    References:
+        1. https://zarr.readthedocs.io/en/stable/api/zarr/abc/store/
+        2. https://zarr.readthedocs.io/en/stable/spec/v2.html
+        3. https://forum.image.sc/t/multiscale-arrays-v0-1/37930
+
+    """
+
+    _read_only: bool
+    _store: dict[str, Any]
+    _fillvalue: float
+    _chunkmode: int
+
+    def __init__(
+        self,
+        /,
+        *,
+        fillvalue: float | None = None,
+        chunkmode: CHUNKMODE | int | str | None = None,
+        read_only: bool = True,
+    ) -> None:
+        super().__init__(read_only=read_only)
+
+        self._store = {}
+        self._fillvalue = 0 if fillvalue is None else fillvalue
+        if chunkmode is None:
+            self._chunkmode = CHUNKMODE(0)
+        else:
+            self._chunkmode = enumarg(CHUNKMODE, chunkmode)
+
+    def __hash__(self) -> int:
+        return hash(
+            (tuple(self._store.items()), self._fillvalue, self._chunkmode)
+        )
+
+    def __eq__(self, other: object) -> bool:
+        """Return whether objects are equal."""
+        return (
+            isinstance(other, type(self))
+            and self._store == other._store
+            and self._fillvalue == other._fillvalue
+            and self._chunkmode == other._chunkmode
+        )
+
+    async def get_partial_values(
+        self,
+        prototype: BufferPrototype,
+        key_ranges: Iterable[tuple[str, ByteRequest | None]],
+    ) -> list[Buffer | None]:
+        """Return possibly partial values from given key_ranges."""
+        # print(f'get_partial_values({key_ranges=})')
+        return [
+            await self.get(key, prototype, byte_range)
+            for key, byte_range in key_ranges
+        ]
+
+    @property
+    def supports_writes(self) -> bool:
+        """Store supports writes."""
+        return not self._read_only
+
+    def _set(self, key: str, value: Buffer, /) -> None:
+        """Store (key, value) pair."""
+        raise NotImplementedError
+
+    async def set(self, key: str, value: Buffer) -> None:
+        """Store (key, value) pair."""
+        self._set(key, value)
+
+    @property
+    def supports_deletes(self) -> bool:
+        """Store supports deletes."""
+        return False
+
+    async def delete(self, key: str) -> None:
+        """Remove key from store."""
+        msg = 'ZarrStore does not support deletes'
+        raise PermissionError(msg)
+
+    @property
+    def supports_listing(self) -> bool:
+        """Store supports listing."""
+        return True
+
+    async def list(self) -> AsyncIterator[str]:
+        """Return all keys in store."""
+        for key in self._store:
+            yield key
+
+    async def list_prefix(self, prefix: str) -> AsyncIterator[str]:
+        """Return all keys in store that begin with prefix.
+
+        Keys are returned relative to the root of the store.
+
+        """
+        for key in list(self._store):
+            if key.startswith(prefix):
+                yield key
+
+    async def list_dir(self, prefix: str) -> AsyncIterator[str]:
+        """Return all keys and prefixes with prefix.
+
+        Keys and prefixes do not contain the character "/" after the given
+        prefix.
+
+        """
+        prefix = prefix.rstrip('/')
+        if prefix == '':
+            keys_unique = {k.split('/')[0] for k in self._store}
+        else:
+            keys_unique = {
+                key.removeprefix(prefix + '/').split('/')[0]
+                for key in self._store
+                if key.startswith(prefix + '/') and key != prefix
+            }
+        for key in keys_unique:
+            yield key
+
+    @property
+    def is_multiscales(self) -> bool:
+        """Return whether ZarrStore contains multiscales."""
+        return b'multiscales' in self._store.get('.zattrs', b'')
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}'
+
+    # async def _get_many(
+    #     self,
+    #     requests: Iterable[tuple[str, BufferPrototype, ByteRequest | None]]
+    # ) -> AsyncGenerator[tuple[str, Buffer | None], None]:
+    #     print(f'_get_many({requests=})')
+    #     return super()._get_many(requests)
+
+    # async def getsize_prefix(self, prefix: str) -> int:
+    #     print(f'getsize_prefix({prefix=})')
+    #     return super().getsize_prefix(prefix)
+
+
+class ZarrTiffStore(ZarrStore):
+    """Zarr 3 store interface to image array in TiffPage or TiffPageSeries.
+
+    ZarrTiffStore is using a TiffFile instance for reading and decoding chunks.
+    Therefore, ZarrTiffStore instances cannot be pickled.
+
+    For writing, image data must be stored in uncompressed, unpredicted,
+    and unpacked form. Sparse strips and tiles are not written.
+
+    Parameters:
+        arg:
+            TIFF page or series to wrap as Zarr store.
+        level:
+            Pyramidal level to wrap. The default is 0.
+        chunkmode:
+            Use strips or tiles (0) or whole page data (2) as chunks.
+            The default is 0.
+        fillvalue:
+            Value to use for missing chunks. The default is 0.
+        zattrs:
+            Additional attributes to store in `.zattrs`.
+        multiscales:
+            Create a multiscales-compatible Zarr group store.
+            By default, create a Zarr array store for pages and non-pyramidal
+            series.
+        lock:
+            Reentrant lock to synchronize seeks and reads from file.
+            By default, the lock of the parent's file handle is used.
+        squeeze:
+            Remove length-1 dimensions from shape of TiffPageSeries.
+        maxworkers:
+            If `chunkmode=0`, asynchronously run chunk decode function
+            in separate thread if greater than 1.
+            If `chunkmode=2`, maximum number of threads to concurrently decode
+            strips or tiles.
+            If *None* or *0*, use up to :py:attr:`_TIFF.MAXWORKERS` or
+            asyncio assigned threads.
+        buffersize:
+            Approximate number of bytes to read from file in one pass
+            if `chunkmode=2`. The default is :py:attr:`_TIFF.BUFFERSIZE`.
+        read_only:
+            Passed to :py:class:`zarr.abc.store.Store`.
+        _openfiles:
+            Internal API.
+
+    """
+
+    _data: list[TiffPageSeries]
+    _filecache: FileCache
+    _transform: Callable[[NDArray[Any]], NDArray[Any]] | None
+    _maxworkers: int
+    _buffersize: int | None
+    _squeeze: bool | None
+    _multiscales: bool
+
+    def __init__(
+        self,
+        arg: TiffPage | TiffFrame | TiffPageSeries,
+        /,
+        *,
+        level: int | None = None,
+        chunkmode: CHUNKMODE | int | str | None = None,
+        fillvalue: float | None = None,
+        zattrs: dict[str, Any] | None = None,
+        multiscales: bool | None = None,
+        lock: threading.RLock | NullContext | None = None,
+        squeeze: bool | None = None,
+        maxworkers: int | None = None,
+        buffersize: int | None = None,
+        read_only: bool | None = None,
+        _openfiles: int | None = None,
+    ) -> None:
+        if chunkmode is None:
+            chunkmode = CHUNKMODE(0)
+        else:
+            chunkmode = enumarg(CHUNKMODE, chunkmode)
+
+        if chunkmode not in {0, 2}:
+            msg = f'{chunkmode!r} not implemented'
+            raise NotImplementedError(msg)
+
+        self._squeeze = None if squeeze is None else bool(squeeze)
+        self._buffersize = buffersize
+
+        if isinstance(arg, TiffPageSeries):
+            self._data = arg.levels
+            self._transform = arg.transform
+            if multiscales is False:
+                level = 0
+            if level is not None:
+                self._data = [self._data[level]]
+            name = arg.name
+        else:
+            self._data = [TiffPageSeries([arg])]
+            self._transform = None
+            name = 'Unnamed'
+
+        if not maxworkers:
+            maxworkers = self._data[0].keyframe.maxworkers
+            if maxworkers < 3 and chunkmode == 0:
+                maxworkers = 1
+        self._maxworkers = maxworkers
+
+        fh = self._data[0].keyframe.parent.root.filehandle
+
+        if read_only is None:
+            read_only = not fh.writable() or chunkmode != 0
+
+        super().__init__(
+            fillvalue=fillvalue, chunkmode=chunkmode, read_only=read_only
+        )
+
+        if lock is None:
+            fh.set_lock(True)
+            lock = fh.lock
+        self._filecache = FileCache(size=_openfiles, lock=lock)
+
+        zattrs = {} if zattrs is None else dict(zattrs)
+        # TODO: Zarr Encoding Specification
+        # https://xarray.pydata.org/en/stable/internals/zarr-encoding-spec.html
+
+        if multiscales is True or (
+            multiscales is None and len(self._data) > 1
+        ):
+            # multiscales
+            self._multiscales = True
+            if '_ARRAY_DIMENSIONS' in zattrs:
+                array_dimensions = zattrs.pop('_ARRAY_DIMENSIONS')
+            else:
+                array_dimensions = list(self._data[0].get_axes(squeeze))
+            self._store['.zgroup'] = _json_dumps({'zarr_format': 2})
+            self._store['.zattrs'] = _json_dumps(
+                {
+                    # TODO: use https://ngff.openmicroscopy.org/latest/
+                    'multiscales': [
+                        {
+                            'version': '0.1',
+                            'name': name,
+                            'datasets': [
+                                {'path': str(i)}
+                                for i in range(len(self._data))
+                            ],
+                            # 'axes': [...]
+                            # 'type': 'unknown',
+                            'metadata': {},
+                        }
+                    ],
+                    **zattrs,
+                }
+            )
+            shape0 = self._data[0].get_shape(squeeze)
+            for ilevel, series in enumerate(self._data):
+                fillvalue, shape = self._init_zarray(
+                    series, f'{ilevel}/.zarray', squeeze, fillvalue
+                )
+                self._store[f'{ilevel}/.zattrs'] = _json_dumps(
+                    {
+                        '_ARRAY_DIMENSIONS': [
+                            (f'{ax}{ilevel}' if i != j else ax)
+                            for ax, i, j in zip(
+                                array_dimensions, shape, shape0, strict=True
+                            )
+                        ]
+                    }
+                )
+        else:
+            self._multiscales = False
+            series = self._data[0]
+            if '_ARRAY_DIMENSIONS' not in zattrs:
+                zattrs['_ARRAY_DIMENSIONS'] = list(series.get_axes(squeeze))
+            self._store['.zattrs'] = _json_dumps(zattrs)
+            self._init_zarray(series, '.zarray', squeeze, fillvalue)
+
+    def _init_zarray(
+        self,
+        series: TiffPageSeries,
+        key: str,
+        squeeze: bool | None,  # noqa: FBT001
+        fillvalue: float | None,
+        /,
+    ) -> tuple[float | None, tuple[int, ...]]:
+        """Store .zarray for series; return updated fillvalue and shape."""
+        keyframe = series.keyframe
+        keyframe.decode  # noqa: B018 - cache decode function
+        shape = series.get_shape(squeeze)
+        dtype = series.dtype
+        if fillvalue is None:
+            fillvalue = keyframe.nodata
+            self._fillvalue = fillvalue
+        chunks = keyframe.shape if self._chunkmode else keyframe.chunks
+        self._store[key] = _json_dumps(
+            {
+                'zarr_format': 2,
+                'shape': shape,
+                'chunks': _chunks(chunks, shape, keyframe.shaped),
+                'dtype': _dtype_str(dtype),
+                'compressor': None,
+                'fill_value': _json_value(fillvalue, dtype),
+                'order': 'C',
+                'filters': None,
+            }
+        )
+        if not self._read_only:
+            self._read_only = not _is_writable(keyframe)
+        return fillvalue, shape
+
+    def close(self) -> None:
+        """Close store."""
+        super().close()
+        self._filecache.clear()
+
+    def write_fsspec(
+        self,
+        jsonfile: str | os.PathLike[Any] | TextIO,
+        /,
+        url: str | None,
+        *,
+        groupname: str | None = None,
+        templatename: str | None = None,
+        compressors: dict[COMPRESSION | int, str | None] | None = None,
+        version: int | None = None,
+        _shape: Sequence[int] | None = None,
+        _axes: Sequence[str] | None = None,
+        _index: Sequence[int] | None = None,
+        _append: bool = False,
+        _close: bool = True,
+    ) -> None:
+        """Write fsspec ReferenceFileSystem as JSON to file.
+
+        Parameters:
+            jsonfile:
+                Name or open file handle of output JSON file.
+            url:
+                Remote location of TIFF file(s) without file name(s).
+            groupname:
+                Zarr group name.
+            templatename:
+                Version 1 URL template name. The default is 'u'.
+            compressors:
+                Mapping of :py:class:`COMPRESSION` codes to Numcodecs codec
+                names.
+            version:
+                Version of fsspec file to write. The default is 0.
+            _shape:
+                Shape of file sequence (experimental).
+            _axes:
+                Axes of file sequence (experimental).
+            _index:
+                Index of file in sequence (experimental).
+            _append:
+                If *True*, only write index keys and values (experimental).
+            _close:
+                If *True*, no more appends (experimental).
+
+        Raises:
+            ValueError:
+                ZarrTiffStore cannot be represented as ReferenceFileSystem
+                due to features that are not supported by Zarr, Numcodecs,
+                or Imagecodecs:
+
+                - compressors, such as CCITT
+                - filters, such as bitorder reversal, packed integers
+                - dtypes, such as float24, complex integers
+                - JPEGTables in multi-page series
+                - incomplete chunks, such as `imagelength % rowsperstrip != 0`
+
+                Files containing incomplete tiles may fail at runtime.
+
+        Notes:
+            Parameters `_shape`,  `_axes`, `_index`, `_append`, and `_close`
+            are an experimental API for joining the ReferenceFileSystems of
+            multiple files of a TiffSequence.
+
+        References:
+            - `fsspec ReferenceFileSystem format
+              <https://github.com/fsspec/kerchunk>`_
+
+        """
+        compressors = {
+            1: None,
+            8: 'zlib',
+            32946: 'zlib',
+            34925: 'lzma',
+            50013: 'zlib',  # pixtiff
+            5: 'imagecodecs_lzw',
+            7: 'imagecodecs_jpeg',
+            22610: 'imagecodecs_jpegxr',
+            32773: 'imagecodecs_packbits',
+            33003: 'imagecodecs_jpeg2k',
+            33004: 'imagecodecs_jpeg2k',
+            33005: 'imagecodecs_jpeg2k',
+            33007: 'imagecodecs_jpeg',
+            34712: 'imagecodecs_jpeg2k',
+            34887: 'imagecodecs_lerc',
+            34892: 'imagecodecs_jpeg',
+            34933: 'imagecodecs_png',
+            34934: 'imagecodecs_jpegxr',
+            48124: 'imagecodecs_jetraw',
+            50000: 'imagecodecs_zstd',  # numcodecs.zstd fails w/ unknown sizes
+            50001: 'imagecodecs_webp',
+            50002: 'imagecodecs_jpegxl',
+            52546: 'imagecodecs_jpegxl',
+            **({} if compressors is None else compressors),
+        }
+
+        for series in self._data:
+            errormsg = ' not supported by the fsspec ReferenceFileSystem'
+            keyframe = series.keyframe
+            if (
+                keyframe.compression in {65000, 65001, 65002}
+                and keyframe.parent.is_eer
+            ):
+                compressors[keyframe.compression] = 'imagecodecs_eer'
+            if keyframe.compression not in compressors:
+                raise ValueError(f'{keyframe.compression!r} is' + errormsg)
+            if keyframe.fillorder != 1:
+                raise ValueError(f'{keyframe.fillorder!r} is' + errormsg)
+            if keyframe.sampleformat not in {1, 2, 3, 6}:
+                # TODO: support float24 and cint via filters?
+                raise ValueError(f'{keyframe.sampleformat!r} is' + errormsg)
+            if (
+                keyframe.bitspersample
+                not in {
+                    8,
+                    16,
+                    32,
+                    64,
+                    128,
+                }
+                and keyframe.compression
+                not in {
+                    # JPEG
+                    7,
+                    33007,
+                    34892,
+                }
+                and compressors[keyframe.compression] != 'imagecodecs_eer'
+            ):
+                raise ValueError(
+                    f'BitsPerSample {keyframe.bitspersample} is' + errormsg
+                )
+            if (
+                not self._chunkmode
+                and not keyframe.is_tiled
+                and keyframe.imagelength % keyframe.rowsperstrip
+            ):
+                raise ValueError('incomplete chunks are' + errormsg)
+            if self._chunkmode and not keyframe.is_final:
+                raise ValueError(f'{self._chunkmode!r} is' + errormsg)
+            if keyframe.jpegtables is not None and len(series.pages) > 1:
+                raise ValueError(
+                    'JPEGTables in multi-page files are' + errormsg
+                )
+
+        if url is None:
+            url = ''
+        elif url and url[-1] != '/':
+            url += '/'
+        url = url.replace('\\', '/')
+
+        if groupname is None:
+            groupname = ''
+        elif groupname and groupname[-1] != '/':
+            groupname += '/'
+
+        byteorder: ByteOrder | None = '<' if sys.byteorder == 'big' else '>'
+        if (
+            self._data[0].keyframe.parent.byteorder != byteorder
+            or self._data[0].keyframe.dtype is None
+            or self._data[0].keyframe.dtype.itemsize == 1
+        ):
+            byteorder = None
+
+        index: str
+        _shape = [] if _shape is None else list(_shape)
+        _axes = [] if _axes is None else list(_axes)
+        if len(_shape) != len(_axes):
+            msg = 'len(_shape) != len(_axes)'
+            raise ValueError(msg)
+        if _index is None:
+            index = ''
+        elif len(_shape) != len(_index):
+            msg = 'len(_shape) != len(_index)'
+            raise ValueError(msg)
+        elif _index:
+            index = '.'.join(str(i) for i in _index)
+            index += '.'
+
+        refs: dict[str, Any] = {}
+        refzarr: dict[str, Any]
+        if version == 1:
+            if _append:
+                msg = 'cannot append to version 1'
+                raise ValueError(msg)
+            if templatename is None:
+                templatename = 'u'
+            refs['version'] = 1
+            refs['templates'] = {}
+            refs['gen'] = []
+            templates = {}
+            if self._data[0].is_multifile:
+                i = 0
+                for page in self._data[0].pages:
+                    if page is None or page.keyframe is None:
+                        continue
+                    filename = page.keyframe.parent.filehandle.name
+                    if filename in templates:
+                        continue
+                    key = f'{templatename}{i}'
+                    templates[filename] = f'{{{{{key}}}}}'
+                    refs['templates'][key] = url + filename
+                    i += 1
+            else:
+                filename = self._data[0].keyframe.parent.filehandle.name
+                key = f'{templatename}'
+                templates[filename] = f'{{{{{key}}}}}'
+                refs['templates'][key] = url + filename
+
+            refs['refs'] = refzarr = {}
+        else:
+            refzarr = refs
+
+        if not _append:
+            if groupname:
+                # TODO: support nested groups
+                refzarr['.zgroup'] = _json_dumps({'zarr_format': 2}).decode()
+
+            for item in self._store.items():
+                key, value = item
+                if '.zattrs' in key and _axes:
+                    value = json.loads(value)
+                    if '_ARRAY_DIMENSIONS' in value:
+                        value['_ARRAY_DIMENSIONS'] = (
+                            _axes + value['_ARRAY_DIMENSIONS']
+                        )
+                    value = _json_dumps(value)
+                elif '.zarray' in key:
+                    value = json.loads(value)
+                    level = int(key.split('/')[0]) if '/' in key else 0
+                    keyframe = self._data[level].keyframe
+                    if _shape:
+                        value['shape'] = _shape + value['shape']
+                        value['chunks'] = [1] * len(_shape) + value['chunks']
+                    codec_id = compressors[keyframe.compression]
+                    if codec_id == 'imagecodecs_jpeg':
+                        # TODO: handle JPEG color spaces
+                        jpegtables = keyframe.jpegtables
+                        if jpegtables is None:
+                            tables = None
+                        else:
+                            tables = base64.b64encode(jpegtables).decode()
+                        jpegheader = keyframe.jpegheader
+                        if jpegheader is None:
+                            header = None
+                        else:
+                            header = base64.b64encode(jpegheader).decode()
+                        (
+                            colorspace_jpeg,
+                            colorspace_data,
+                        ) = jpeg_decode_colorspace(
+                            keyframe.photometric,
+                            keyframe.planarconfig,
+                            keyframe.extrasamples,
+                            keyframe.is_jfif,
+                        )
+                        value['compressor'] = {
+                            'id': codec_id,
+                            'tables': tables,
+                            'header': header,
+                            'bitspersample': keyframe.bitspersample,
+                            'colorspace_jpeg': colorspace_jpeg,
+                            'colorspace_data': colorspace_data,
+                        }
+                    elif (
+                        codec_id == 'imagecodecs_webp'
+                        and keyframe.samplesperpixel == 4
+                    ):
+                        value['compressor'] = {
+                            'id': codec_id,
+                            'hasalpha': True,
+                        }
+                    elif codec_id == 'imagecodecs_eer':
+                        horzbits = vertbits = 2
+                        if keyframe.compression == 65002:
+                            skipbits = int(keyframe.tags.valueof(65007, 7))
+                            horzbits = int(keyframe.tags.valueof(65008, 2))
+                            vertbits = int(keyframe.tags.valueof(65009, 2))
+                        elif keyframe.compression == 65001:
+                            skipbits = 7
+                        else:
+                            skipbits = 8
+                        value['compressor'] = {
+                            'id': codec_id,
+                            'shape': keyframe.chunks,
+                            'skipbits': skipbits,
+                            'horzbits': horzbits,
+                            'vertbits': vertbits,
+                            'superres': keyframe.parent._superres,
+                        }
+                    elif codec_id is not None:
+                        value['compressor'] = {'id': codec_id}
+                    if byteorder is not None:
+                        value['dtype'] = byteorder + value['dtype'][1:]
+                    if keyframe.predictor > 1:
+                        # predictors need access to chunk shape and dtype
+                        # requires imagecodecs > 2021.8.26 to read
+                        if keyframe.predictor in {2, 34892, 34893}:
+                            filter_id = 'imagecodecs_delta'
+                        else:
+                            filter_id = 'imagecodecs_floatpred'
+                        if keyframe.predictor <= 3:
+                            dist = 1
+                        elif keyframe.predictor in {34892, 34894}:
+                            dist = 2
+                        else:
+                            dist = 4
+                        if (
+                            keyframe.planarconfig == 1
+                            and keyframe.samplesperpixel > 1
+                        ):
+                            axis = -2
+                        else:
+                            axis = -1
+                        value['filters'] = [
+                            {
+                                'id': filter_id,
+                                'axis': axis,
+                                'dist': dist,
+                                'shape': value['chunks'],
+                                'dtype': value['dtype'],
+                            }
+                        ]
+                    value = _json_dumps(value)
+                # else:
+                #     pass through value
+
+                refzarr[groupname + key] = value.decode()
+
+        fh: TextIO
+        with contextlib.ExitStack() as stack:
+            if hasattr(jsonfile, 'write'):
+                fh = jsonfile  # type: ignore[assignment]
+            else:
+                fh = stack.enter_context(open(jsonfile, 'w', encoding='utf-8'))
+
+            if version == 1:
+                fh.write(json.dumps(refs, indent=1).rsplit('}"', 1)[0] + '}"')
+                indent = '  '
+            elif _append:
+                indent = ' '
+            else:
+                fh.write(json.dumps(refs, indent=1)[:-2])
+                indent = ' '
+
+            offset: int | None
+            for item in self._store.items():
+                key, value = item
+                if '.zarray' in key:
+                    value = json.loads(value)
+                    shape = value['shape']
+                    chunks = value['chunks']
+                    levelstr = (key.split('/')[0] + '/') if '/' in key else ''
+                    for chunkindex in _ndindex(shape, chunks):
+                        key = levelstr + chunkindex
+                        keyframe, page, _, offset, bytecount = self._parse_key(
+                            key
+                        )
+                        if page and self._chunkmode and offset is None:
+                            offset = page.dataoffsets[0]
+                            bytecount = keyframe.nbytes
+                        if offset and bytecount:
+                            filename = keyframe.parent.filehandle.name
+                            if version == 1:
+                                filename = templates[filename]
+                            else:
+                                filename = f'{url}{filename}'
+                            fh.write(
+                                f',\n{indent}"{groupname}{key}": '
+                                f'["{filename}", {offset}, {bytecount}]'
+                            )
+
+            # TODO: support nested groups
+            if version == 1:
+                fh.write('\n }\n}')
+            elif _close:
+                fh.write('\n}')
+
+    async def get(
+        self,
+        key: str,
+        prototype: BufferPrototype,
+        byte_range: ByteRequest | None = None,
+    ) -> Buffer | None:
+        """Return value associated with key."""
+        # print(f'get({key=}, {byte_range=})')
+        if byte_range is not None:
+            msg = f'{byte_range=!r} not supported'
+            raise NotImplementedError(msg)
+
+        if key in self._store:
+            return prototype.buffer.from_bytes(self._store[key])
+
+        if (
+            key == 'zarr.json'
+            or key[-10:] == '.zmetadata'
+            or key[-7:] == '.zarray'
+            or key[-7:] == '.zgroup'
+        ):
+            # catch '.zarray' and 'attribute/.zarray'
+            return None
+
+        keyframe, page, chunkindex, offset, bytecount = self._parse_key(key)
+
+        if page is None or offset == 0 or bytecount == 0:
+            return None
+
+        fh = page.parent.filehandle
+
+        if self._chunkmode:
+            if offset is not None:
+                # contiguous image data in page or series
+                # create virtual frame instead of loading page from file
+                assert bytecount is not None
+                page = TiffFrame(
+                    page.parent,
+                    index=0,
+                    keyframe=keyframe,
+                    dataoffsets=(offset,),
+                    databytecounts=(bytecount,),
+                )
+            # TODO: use asyncio.to_thread ?
+            self._filecache.open(fh)
+            chunk = page.asarray(
+                lock=self._filecache.lock,
+                maxworkers=self._maxworkers,
+                buffersize=self._buffersize,
+            )
+            self._filecache.close(fh)
+            if self._transform is not None:
+                chunk = self._transform(chunk)
+            return prototype.buffer.from_array_like(
+                chunk.reshape(-1).view('B')
+            )
+
+        assert offset is not None
+        assert bytecount is not None
+        chunk_bytes = self._filecache.read(fh, offset, bytecount)
+
+        decodeargs: dict[str, Any] = {'_fullsize': True}
+        if page.jpegtables is not None:
+            decodeargs['jpegtables'] = page.jpegtables
+        if keyframe.jpegheader is not None:
+            decodeargs['jpegheader'] = keyframe.jpegheader
+
+        assert chunkindex is not None
+        keyframe.decode  # noqa: B018 - cache decode function
+        if self._maxworkers > 1:
+            decoded = await asyncio.to_thread(
+                keyframe.decode, chunk_bytes, chunkindex, **decodeargs
+            )
+        else:
+            decoded = keyframe.decode(chunk_bytes, chunkindex, **decodeargs)
+        chunk = decoded[0]  # type: ignore[assignment]
+        assert chunk is not None
+        if self._transform is not None:
+            chunk = self._transform(chunk)
+
+        chunks = keyframe.chunks
+        if chunk.size != product(chunks):
+            msg = f'{chunk.size=} != {product(chunks)=}'
+            raise RuntimeError(msg)
+        return prototype.buffer.from_array_like(chunk.reshape(-1).view('B'))
+
+    async def exists(self, key: str) -> bool:
+        """Return whether key exists in store."""
+        # print(f'exists({key=})')
+        if key in self._store:
+            return True
+        try:
+            _kf, page, _ci, offset, bytecount = self._parse_key(key)
+        except (KeyError, IndexError):
+            return False
+        if self._chunkmode and offset is None:
+            return True
+        return (
+            page is not None
+            and offset is not None
+            and bytecount is not None
+            and offset > 0
+            and bytecount > 0
+        )
+
+    async def set(self, key: str, value: Buffer) -> None:
+        """Store (key, value) pair."""
+        if self._read_only:
+            msg = 'ZarrTiffStore is read-only'
+            raise PermissionError(msg)
+
+        if (
+            key in self._store
+            or key == 'zarr.json'
+            or key[-10:] == '.zmetadata'
+            or key[-7:] == '.zarray'
+            or key[-7:] == '.zgroup'
+        ):
+            # catch '.zarray' and 'attribute/.zarray'
+            return
+
+        _keyframe, page, _chunkindex, offset, bytecount = self._parse_key(key)
+        if (
+            page is None
+            or offset is None
+            or offset == 0
+            or bytecount is None
+            or bytecount == 0
+        ):
+            return
+        data = value.to_bytes()
+        if bytecount < len(data):
+            data = data[:bytecount]
+        self._filecache.write(page.parent.filehandle, offset, data)
+
+    def _parse_key(self, key: str, /) -> tuple[
+        TiffPage,
+        TiffPage | TiffFrame | None,
+        int | None,
+        int | None,
+        int | None,
+    ]:
+        """Return keyframe, page, index, offset, and bytecount from key.
+
+        Raise KeyError if key is not valid.
+
+        """
+        if self._multiscales:
+            try:
+                level, chunk_key = key.split('/', 1)
+                series = self._data[int(level)]
+            except (ValueError, IndexError) as exc:
+                raise KeyError(key) from exc
+            key = chunk_key
+        else:
+            series = self._data[0]
+        keyframe = series.keyframe
+        page: TiffPage | TiffFrame | None = None
+        offset: int | None = None
+        pageindex, chunkindex = self._indices(key, series)
+        if series.dataoffset is not None:
+            # contiguous or truncated
+            page = series[0]
+            if page is None or page.dtype is None or page.keyframe is None:
+                return keyframe, None, chunkindex, 0, 0
+            offset = pageindex * page.size * page.dtype.itemsize
+            try:
+                offset += page.dataoffsets[chunkindex]
+            except IndexError as exc:
+                raise KeyError(key) from exc
+            if self._chunkmode:
+                bytecount = page.size * page.dtype.itemsize
+                return page.keyframe, page, chunkindex, offset, bytecount
+        elif self._chunkmode:
+            with self._filecache.lock:
+                page = series[pageindex]
+            if page is None or page.keyframe is None:
+                return keyframe, None, None, 0, 0
+            return page.keyframe, page, None, None, None
+        else:
+            with self._filecache.lock:
+                page = series[pageindex]
+            if page is None or page.keyframe is None:
+                return keyframe, None, chunkindex, 0, 0
+            try:
+                offset = page.dataoffsets[chunkindex]
+            except IndexError:
+                # raise KeyError(key) from exc
+                # issue #249: Philips may be missing last row of tiles
+                return page.keyframe, page, chunkindex, 0, 0
+        try:
+            bytecount = page.databytecounts[chunkindex]
+        except IndexError as exc:
+            raise KeyError(key) from exc
+        return page.keyframe, page, chunkindex, offset, bytecount
+
+    def _indices(self, key: str, series: TiffPageSeries, /) -> tuple[int, int]:
+        """Return page and strile indices from Zarr chunk index."""
+        keyframe = series.keyframe
+        shape = series.get_shape(self._squeeze)
+        try:
+            indices = [int(i) for i in key.split('.')]
+        except ValueError as exc:
+            raise KeyError(key) from exc
+        assert len(indices) == len(shape)
+        if self._chunkmode:
+            chunked = (1,) * len(keyframe.shape)
+        else:
+            chunked = keyframe.chunked
+        p = 1
+        for j, s in enumerate(shape[::-1]):
+            p *= s
+            if p == keyframe.size:
+                i = len(indices) - j - 1
+                frames_indices = indices[:i]
+                strile_indices = indices[i:]
+                frames_chunked = shape[:i]
+                strile_chunked = list(shape[i:])  # updated later
+                break
+        else:
+            msg = 'shape does not match keyframe size'
+            raise RuntimeError(msg)
+        if len(strile_chunked) == len(keyframe.shape):
+            strile_chunked = list(chunked)
+        else:
+            # get strile_chunked including singleton dimensions
+            i = len(strile_indices) - 1
+            j = len(keyframe.shape) - 1
+            while True:
+                if strile_chunked[i] == keyframe.shape[j]:
+                    strile_chunked[i] = chunked[j]
+                    i -= 1
+                    j -= 1
+                elif strile_chunked[i] == 1:
+                    i -= 1
+                else:
+                    msg = 'shape does not match page shape'
+                    raise RuntimeError(msg)
+                if i < 0 or j < 0:
+                    break
+            assert product(strile_chunked) == product(chunked)
+        frameindex = 0
+        strileindex = 0
+        if frames_indices:
+            frameindex = int(
+                numpy.ravel_multi_index(frames_indices, frames_chunked)
+            )
+        if strile_indices:
+            strileindex = int(
+                numpy.ravel_multi_index(strile_indices, strile_chunked)
+            )
+        return frameindex, strileindex
+
+
+class ZarrFileSequenceStore(ZarrStore):
+    """Zarr 3 store interface to image array in FileSequence.
+
+    Parameters:
+        filesequence:
+            FileSequence instance to wrap as Zarr store.
+            Files in containers are not supported.
+        fillvalue:
+            Value to use for missing chunks. The default is 0.
+        chunkmode:
+            Currently only one chunk per file is supported.
+        chunkshape:
+            Shape of chunk in each file.
+            Must match ``FileSequence.imread(file, **imreadargs).shape``.
+        chunkdtype:
+            Data type of chunk in each file.
+            Must match ``FileSequence.imread(file, **imreadargs).dtype``.
+        axestiled:
+            Axes to be tiled. Map stacked sequence axis to chunk axis.
+        zattrs:
+            Additional attributes to store in `.zattrs`.
+        ioworkers:
+            If not 1, asynchronously run `imread` function in separate thread.
+            If enabled, internal threading for the `imread` function
+            should be disabled.
+        read_only:
+            Passed to :py:class:`zarr.abc.store.Store`.
+        imreadargs:
+            Arguments passed to :py:attr:`FileSequence.imread`.
+        **kwargs:
+            Arguments passed to :py:attr:`FileSequence.imread` in addition
+            to `imreadargs`.
+
+    Notes:
+        If `chunkshape` or `chunkdtype` are *None* (default), their values
+        are determined by reading the first file with
+        ``FileSequence.imread(arg.files[0], **imreadargs)``.
+
+    """
+
+    _imread: Callable[..., NDArray[Any]]
+    _lookup: dict[tuple[int, ...], str]
+    _chunks: tuple[int, ...]
+    _dtype: numpy.dtype[Any]
+    _tiled: TiledSequence
+    _commonpath: str
+    _ioworkers: int
+    _kwargs: dict[str, Any]
+
+    def __init__(
+        self,
+        filesequence: FileSequence,
+        /,
+        *,
+        fillvalue: float | None = None,
+        chunkmode: CHUNKMODE | int | str | None = None,
+        chunkshape: Sequence[int] | None = None,
+        chunkdtype: DTypeLike | None = None,
+        axestiled: dict[int, int] | Sequence[tuple[int, int]] | None = None,
+        zattrs: dict[str, Any] | None = None,
+        ioworkers: int | None = 1,
+        imreadargs: dict[str, Any] | None = None,
+        read_only: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        if not isinstance(filesequence, FileSequence):
+            msg = 'not a FileSequence'  # type: ignore[unreachable]
+            raise TypeError(msg)
+
+        if filesequence._container:
+            msg = 'cannot open container as Zarr store'
+            raise NotImplementedError(msg)
+
+        if len(filesequence) == 0:
+            msg = 'filesequence is empty'
+            raise ValueError(msg)
+
+        super().__init__(
+            fillvalue=fillvalue, chunkmode=chunkmode, read_only=read_only
+        )
+
+        if self._chunkmode not in {0, 3}:
+            msg = f'invalid chunkmode {self._chunkmode!r}'
+            raise ValueError(msg)
+
+        # TODO: deprecate kwargs?
+        if imreadargs is not None:
+            kwargs |= imreadargs
+
+        self._ioworkers = 1 if ioworkers is None else ioworkers
+
+        self._kwargs = kwargs
+        self._imread = filesequence.imread
+        self._commonpath = filesequence.commonpath()
+
+        if chunkshape is None or chunkdtype is None:
+            chunk = filesequence.imread(filesequence[0], **kwargs)
+            self._chunks = chunk.shape
+            self._dtype = chunk.dtype
+        else:
+            self._chunks = tuple(chunkshape)
+            self._dtype = numpy.dtype(chunkdtype)
+
+        self._tiled = TiledSequence(
+            filesequence.shape, self._chunks, axestiled=axestiled
+        )
+        self._lookup = dict(
+            zip(
+                self._tiled.indices(filesequence.indices),
+                filesequence,
+                strict=True,
+            )
+        )
+
+        zattrs = {} if zattrs is None else dict(zattrs)
+        # TODO: add _ARRAY_DIMENSIONS to ZarrFileSequenceStore
+        # if '_ARRAY_DIMENSIONS' not in zattrs:
+        #     zattrs['_ARRAY_DIMENSIONS'] = list(...)
+
+        self._store['.zattrs'] = _json_dumps(zattrs)
+        self._store['.zarray'] = _json_dumps(
+            {
+                'zarr_format': 2,
+                'shape': self._tiled.shape,
+                'chunks': self._tiled.chunks,
+                'dtype': _dtype_str(self._dtype),
+                'compressor': None,
+                'fill_value': _json_value(fillvalue, self._dtype),
+                'order': 'C',
+                'filters': None,
+            }
+        )
+
+    async def exists(self, key: str) -> bool:
+        """Return whether key exists in store."""
+        # print(f'exists({key=})')
+        if key in self._store:
+            return True
+        assert isinstance(key, str)
+        try:
+            indices = tuple(int(i) for i in key.split('.'))
+        except ValueError:
+            return False
+        return indices in self._lookup
+
+    async def get(
+        self,
+        key: str,
+        prototype: BufferPrototype,
+        byte_range: ByteRequest | None = None,
+    ) -> Buffer | None:
+        """Return value associated with key."""
+        if byte_range is not None:
+            msg = f'{byte_range=!r} not supported'
+            raise NotImplementedError(msg)
+
+        if key in self._store:
+            return prototype.buffer.from_bytes(self._store[key])
+
+        if (
+            key == 'zarr.json'
+            or key[-10:] == '.zmetadata'
+            or key[-7:] == '.zarray'
+            or key[-7:] == '.zgroup'
+        ):
+            # catch '.zarray' and 'attribute/.zarray'
+            return None
+
+        try:
+            indices = tuple(int(i) for i in key.split('.'))
+        except ValueError:
+            return None
+        filename = self._lookup.get(indices)
+        if filename is None:
+            return None
+        if self._ioworkers != 1:
+            chunk = await asyncio.to_thread(
+                self._imread, filename, **self._kwargs
+            )
+        else:
+            chunk = self._imread(filename, **self._kwargs)
+        return prototype.buffer.from_array_like(chunk.reshape(-1).view('B'))
+
+    def write_fsspec(
+        self,
+        jsonfile: str | os.PathLike[Any] | TextIO,
+        /,
+        url: str | None,
+        *,
+        quote: bool | None = None,
+        groupname: str | None = None,
+        templatename: str | None = None,
+        codec_id: str | None = None,
+        version: int | None = None,
+        _append: bool = False,
+        _close: bool = True,
+    ) -> None:
+        """Write fsspec ReferenceFileSystem as JSON to file.
+
+        Parameters:
+            jsonfile:
+                Name or open file handle of output JSON file.
+            url:
+                Remote location of TIFF file(s) without file name(s).
+            quote:
+                Quote file names, that is, replace ' ' with '%20'.
+                The default is True.
+            groupname:
+                Zarr group name.
+            templatename:
+                Version 1 URL template name. The default is 'u'.
+            codec_id:
+                Name of Numcodecs codec to decode files or chunks.
+            version:
+                Version of fsspec file to write. The default is 0.
+            _append, _close:
+                Experimental API.
+
+        References:
+            - `fsspec ReferenceFileSystem format
+              <https://github.com/fsspec/kerchunk>`_
+
+        """
+        from urllib.parse import quote as quote_
+
+        kwargs = self._kwargs.copy()
+
+        if codec_id is not None:
+            pass
+        elif self._imread is imread:
+            codec_id = 'tifffile'
+        elif 'imagecodecs' in self._imread.__module__:
+            if (
+                self._imread.__name__ != 'imread'
+                or 'codec' not in self._kwargs
+            ):
+                msg = 'cannot determine codec_id'
+                raise ValueError(msg)
+            codec = kwargs.pop('codec')
+            if isinstance(codec, (list, tuple)):
+                codec = codec[0]
+            if callable(codec):
+                codec = codec.__name__.split('_')[0]
+            try:
+                codec_id = {
+                    'apng': 'imagecodecs_apng',
+                    'avif': 'imagecodecs_avif',
+                    'gif': 'imagecodecs_gif',
+                    'heif': 'imagecodecs_heif',
+                    'jpeg': 'imagecodecs_jpeg',
+                    'jpeg8': 'imagecodecs_jpeg',
+                    'jpeg12': 'imagecodecs_jpeg',
+                    'jpeg2k': 'imagecodecs_jpeg2k',
+                    'jpegls': 'imagecodecs_jpegls',
+                    'jpegxl': 'imagecodecs_jpegxl',
+                    'jpegxr': 'imagecodecs_jpegxr',
+                    'ljpeg': 'imagecodecs_ljpeg',
+                    'lerc': 'imagecodecs_lerc',
+                    # 'npy': 'imagecodecs_npy',
+                    'png': 'imagecodecs_png',
+                    'qoi': 'imagecodecs_qoi',
+                    'tiff': 'imagecodecs_tiff',
+                    'webp': 'imagecodecs_webp',
+                    'zfp': 'imagecodecs_zfp',
+                }[codec]
+            except KeyError:
+                msg = f'unknown {codec=!r}'
+                raise ValueError(msg) from None
+        else:
+            # TODO: choose codec from filename
+            msg = 'cannot determine codec_id'
+            raise ValueError(msg)
+
+        if url is None:
+            url = ''
+        elif url and url[-1] != '/':
+            url += '/'
+
+        if groupname is None:
+            groupname = ''
+        elif groupname and groupname[-1] != '/':
+            groupname += '/'
+
+        refs: dict[str, Any] = {}
+        if version == 1:
+            if _append:
+                msg = 'cannot append to version 1 files'
+                raise ValueError(msg)
+            if templatename is None:
+                templatename = 'u'
+            refs['version'] = 1
+            refs['templates'] = {templatename: url}
+            refs['gen'] = []
+            refs['refs'] = refzarr = {}
+            url = f'{{{{{templatename}}}}}'
+        else:
+            refzarr = refs
+
+        if groupname and not _append:
+            refzarr['.zgroup'] = _json_dumps({'zarr_format': 2}).decode()
+
+        for item in self._store.items():
+            key, value = item
+            if '.zarray' in key:
+                value = json.loads(value)
+                # TODO: make kwargs serializable
+                value['compressor'] = {'id': codec_id, **kwargs}
+                value = _json_dumps(value)
+            refzarr[groupname + key] = value.decode()
+
+        fh: TextIO
+        with contextlib.ExitStack() as stack:
+            if hasattr(jsonfile, 'write'):
+                fh = jsonfile  # type: ignore[assignment]
+            else:
+                fh = stack.enter_context(open(jsonfile, 'w', encoding='utf-8'))
+
+            if version == 1:
+                fh.write(json.dumps(refs, indent=1).rsplit('}"', 1)[0] + '}"')
+                indent = '  '
+            elif _append:
+                fh.write(',\n')
+                fh.write(json.dumps(refs, indent=1)[2:-2])
+                indent = ' '
+            else:
+                fh.write(json.dumps(refs, indent=1)[:-2])
+                indent = ' '
+
+            for item in self._store.items():
+                key, value = item
+                if '.zarray' in key:
+                    value = json.loads(value)
+                    for index, fname in sorted(
+                        self._lookup.items(), key=lambda x: x[0]
+                    ):
+                        filename = fname.removeprefix(self._commonpath)
+                        filename = filename.replace('\\', '/')
+                        if quote is None or quote:
+                            filename = quote_(filename)
+                        if filename and filename[0] == '/':
+                            filename = filename[1:]
+                        indexstr = '.'.join(str(i) for i in index)
+                        fh.write(
+                            f',\n{indent}"{groupname}{indexstr}": '
+                            f'["{url}{filename}"]'
+                        )
+
+            if version == 1:
+                fh.write('\n }\n}')
+            elif _close:
+                fh.write('\n}')
+
+
+def zarr_selection(
+    store: ZarrStore,
+    selection: BasicSelection,
+    /,
+    *,
+    groupindex: str | None = None,
+    close: bool = True,
+    out: OutputType = None,
+) -> NDArray[Any]:
+    """Return selection from Zarr store.
+
+    Parameters:
+        store:
+            ZarrStore instance to read selection from.
+        selection:
+            Subset of image to be extracted and returned.
+            Refer to the Zarr documentation for valid selections.
+        groupindex:
+            Index of array if store is Zarr group.
+        close:
+            Close store before returning.
+        out:
+            Specifies how image array is returned.
+            By default, create a new array.
+            If a *numpy.ndarray*, a writable array to which the images
+            are copied.
+            If *'memmap'*, create a memory-mapped array in a temporary
+            file.
+            If a *string* or *open file*, the file used to create a
+            memory-mapped array.
+
+    """
+    zarray: zarr.Array[Any]
+
+    try:
+        z = zarr.open(store, mode='r', zarr_format=2)
+        if isinstance(z, zarr.Group):
+            if groupindex is None:
+                groupindex = '0'
+            zarray = z[groupindex]  # type: ignore[assignment]
+        else:
+            zarray = z
+        if out is not None:
+            shape = BasicIndexer(
+                selection,
+                shape=zarray.shape,
+                chunk_grid=RegularChunkGrid(chunk_shape=zarray.chunks),
+            ).shape
+            ndbuffer = NDBuffer.from_numpy_array(
+                create_output(out, shape, zarray.dtype)
+            )
+        else:
+            ndbuffer = None
+        result = zarray.get_basic_selection(selection, out=ndbuffer)
+        del zarray
+    finally:
+        if close:
+            store.close()
+    return result  # type: ignore[return-value]
+
+
+def _empty_chunk(
+    shape: tuple[int, ...],
+    dtype: DTypeLike | None,
+    fillvalue: float | None,
+    /,
+) -> NDArray[Any]:
+    """Return empty chunk."""
+    if fillvalue is None or fillvalue == 0:
+        # return bytes(product(shape) * dtype.itemsize)
+        return numpy.zeros(shape, dtype)
+    chunk = numpy.empty(shape, dtype)
+    chunk[:] = fillvalue
+    return chunk  # .tobytes()
+
+
+def _dtype_str(dtype: numpy.dtype[Any], /) -> str:
+    """Return dtype as string with native byte order."""
+    if dtype.itemsize == 1:
+        byteorder = '|'
+    else:
+        byteorder = {'big': '>', 'little': '<'}[sys.byteorder]
+    return byteorder + dtype.str[1:]
+
+
+def _json_dumps(obj: Any, /) -> bytes:
+    """Serialize object to JSON formatted bytes."""
+    return json.dumps(
+        obj,
+        indent=1,
+        sort_keys=True,
+        ensure_ascii=True,
+        separators=(',', ': '),
+    ).encode('ascii')
+
+
+def _json_value(value: Any, dtype: numpy.dtype[Any], /) -> Any:
+    """Return value which is serializable to JSON."""
+    if value is None:
+        return value
+    if dtype.kind == 'b':
+        return bool(value)
+    if dtype.kind in 'ui':
+        return int(value)
+    if dtype.kind == 'f':
+        if numpy.isnan(value):
+            return 'NaN'
+        if numpy.isposinf(value):
+            return 'Infinity'
+        if numpy.isneginf(value):
+            return '-Infinity'
+        return float(value)
+    if dtype.kind == 'c':
+        value = numpy.array(value, dtype)
+        return (
+            _json_value(value.real, value.real.dtype),
+            _json_value(value.imag, value.imag.dtype),
+        )
+    return value
+
+
+def _ndindex(
+    shape: tuple[int, ...], chunks: tuple[int, ...], /
+) -> Iterator[str]:
+    """Return iterator over all chunk index strings."""
+    assert len(shape) == len(chunks)
+    chunked = tuple(
+        (i + j - 1) // j for i, j in zip(shape, chunks, strict=True)
+    )
+    for indices in numpy.ndindex(chunked):
+        yield '.'.join(str(index) for index in indices)
+
+
+def _is_writable(keyframe: TiffPage) -> bool:
+    """Return True if chunks are writable."""
+    return (
+        keyframe.compression == 1
+        and keyframe.fillorder == 1
+        and keyframe.sampleformat in {1, 2, 3, 6}
+        and keyframe.bitspersample in {8, 16, 32, 64, 128}
+        # and (
+        #     keyframe.rowsperstrip == 0
+        #     or keyframe.imagelength % keyframe.rowsperstrip == 0
+        # )
+    )
+
+
+def _chunks(
+    chunks: tuple[int, ...],
+    shape: tuple[int, ...],
+    shaped: tuple[int, int, int, int, int],
+    /,
+) -> tuple[int, ...]:
+    """Return chunks with same length as shape."""
+    ndim = len(shape)
+    if ndim == 0:
+        return ()  # empty array
+    if 0 in shape:
+        return (1,) * ndim
+    d = 0 if shaped[1] == 1 else 1
+    i = min(ndim, 3 + d)
+    if (
+        len(chunks) == 2 + d
+        and i != 2 + d
+        and shape[-1] == 1
+        and shape[-i:] == shaped[-i:]
+    ):
+        # planarconfig=contig with one sample
+        chunks = (*chunks, 1)
+    if ndim < len(chunks):
+        # remove leading dimensions of size 1 from chunks
+        i = 0
+        for size in chunks:
+            if size > 1:
+                break
+            i += 1
+        chunks = chunks[i:]
+        if ndim < len(chunks):
+            msg = f'{shape=!r} is shorter than {chunks=!r}'
+            raise ValueError(msg)
+    # prepend size 1 dimensions to chunks to match length of shape
+    return (1,) * (ndim - len(chunks)) + chunks

envs/simpy.freeze.txt

@@ -0,0 +1,15 @@
+cffi==2.1.0
+imageio==2.37.0
+lazy-loader==0.5
+networkx==3.6.1
+numpy==1.26.0
+packaging==26.0
+pillow==12.3.0
+pycparser==3.0
+PyYAML==6.0.2
+scikit-image==0.26.0
+scipy==1.15.3
+soundfile==0.14.0
+tifffile==2026.3.3
+trimesh==4.5.1
+typing_extensions==4.16.0