large-image-source-vips 1.23.7.dev4__tar.gz → 1.33.4.dev37__tar.gz

large_image_source_vips-1.33.4.dev37/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: large-image-source-vips
+Version: 1.33.4.dev37
+Summary: A libvips tilesource for large_image.
+Home-page: https://github.com/girder/large_image
+Author: Kitware, Inc.
+Author-email: kitware@kitware.com
+License: Apache-2.0
+Keywords: large_image,tile source
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: large-image>=1.33.4.dev37
+Requires-Dist: numpy
+Requires-Dist: packaging
+Requires-Dist: pyvips
+Provides-Extra: girder
+Requires-Dist: girder-large-image; extra == "girder"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A libvips tilesource for large_image.
+
+See the large-image package for more details.

{large-image-source-vips-1.23.7.dev4 → large_image_source_vips-1.33.4.dev37}/README.rst

@@ -1,25 +1,23 @@
 Large Image
 ===========
 
-|build-status| |codecov-io| |license-badge| |doi-badge| |pypi-badge|
+.. image:: https://img.shields.io/circleci/build/github/girder/large_image.svg
+  :target: https://circleci.com/gh/girder/large_image
+  :alt: Build Status
 
-.. |build-status| image:: https://img.shields.io/circleci/build/github/girder/large_image.svg
-    :target: https://circleci.com/gh/girder/large_image
-    :alt: Build Status
+.. image:: https://img.shields.io/badge/license-Apache%202-blue.svg
+  :target: https://raw.githubusercontent.com/girder/large_image/master/LICENSE
+  :alt: License
 
-.. |license-badge| image:: https://img.shields.io/badge/license-Apache%202-blue.svg
-    :target: https://raw.githubusercontent.com/girder/large_image/master/LICENSE
-    :alt: License
+.. image:: https://img.shields.io/codecov/c/github/girder/large_image.svg
+  :target: https://codecov.io/github/girder/large_image?branch=master
+  :alt: codecov.io
 
-.. |codecov-io| image:: https://img.shields.io/codecov/c/github/girder/large_image.svg
-   :target: https://codecov.io/github/girder/large_image?branch=master
-   :alt: codecov.io
+.. image:: https://img.shields.io/badge/DOI-10.5281%2Fzenodo.4562625-blue.svg
+  :target: https://doi.org/10.5281/zenodo.4562625
 
-.. |doi-badge| image:: https://img.shields.io/badge/DOI-10.5281%2Fzenodo.4723355-blue
-   :target: https://zenodo.org/badge/latestdoi/45569214
-
-.. |pypi-badge| image:: https://img.shields.io/pypi/v/large-image.svg?logo=python&logoColor=white
-   :target: https://pypi.org/project/large-image/
+.. image:: https://img.shields.io/pypi/v/large-image.svg?logo=python&logoColor=white
+  :target: https://pypi.org/project/large-image/
 
 *Python modules to work with large, multiresolution images.*
 
@@ -39,16 +37,20 @@ Highlights
 Installation
 ------------
 
-In addition to installing the ``large-image`` package, you'll need at least one tile source (a ``large-image-source-xxx`` package).   You can install everything from the main project with one of these commands:
+In addition to installing the base ``large-image`` package, you'll need at least one tile source which corresponds to your target file format(s) (a ``large-image-source-xxx`` package).   You can install everything from the main project with one of these commands:
 
 Pip
 ~~~
 
+Install common tile sources on linux, OSX, or Windows::
+
+    pip install large-image[common]
+
 Install all tile sources on linux::
 
     pip install large-image[all] --find-links https://girder.github.io/large_image_wheels
 
-Install all tile sources and all Girder plugins on linux::
+When using large-image with an instance of `Girder`_, install all tile sources and all Girder plugins on linux::
 
     pip install large-image[all] girder-large-image-annotation[tasks] --find-links https://girder.github.io/large_image_wheels
 
@@ -56,8 +58,9 @@ Install all tile sources and all Girder plugins on linux::
 Conda
 ~~~~~
 
-Conda makes dependency management a bit easier if not on Linux. Some of the source modules are available on conda-forge. You can install the following::
+Conda makes dependency management a bit easier if not on Linux. The base module, converter module, and two of the source modules are available on conda-forge. You can install the following::
 
+    conda install -c conda-forge large-image
     conda install -c conda-forge large-image-source-gdal
     conda install -c conda-forge large-image-source-tiff
     conda install -c conda-forge large-image-converter
@@ -101,81 +104,66 @@ Large Image consists of several Python modules designed to work together.  These
 
   - ``performance``: include optional modules that can improve performance
 
+  - ``common``: all of the tile sources and above packages that will install directly from pypi without other external libraries on linux, OSX, and Windows.
+
   - ``all``: for all of the above
 
 - ``large-image-converter``: A utility for using pyvips and other libraries to convert images into pyramidal tiff files that can be read efficiently by large_image.
-  You can specify extras_require of ``jp2k`` to include modules to allow output to JPEG2000 compression, ``sources`` to include all sources, and ``stats`` to include modules to allow computing compression noise statistics.
+  You can specify extras_require of ``jp2k`` to include modules to allow output to JPEG2000 compression, ``sources`` to include all sources, ``stats`` to include modules to allow computing compression noise statistics, ``geospatial`` to include support for converting geospatial sources, or ``all`` for all of the optional extras_require.
 
 - Tile sources:
 
-  - ``large-image-source-tiff``: A tile source for reading pyramidal tiff files in common compression formats.
-
-  - ``large-image-source-openslide``: A tile source using the OpenSlide library.  This works with svs, ndpi, Mirax, tiff, vms, and other file formats.
+  - ``large-image-source-bioformats``: A tile source for reading any file handled by the Java Bioformats library.
 
-  - ``large-image-source-ometiff``: A tile source using the tiff library that can handle some multi-frame OMETiff files.
+  - ``large-image-source-deepzoom``: A tile source for reading Deepzoom tiles.
 
-  - ``large-image-source-pil``: A tile source for small images via the Python Imaging Library (Pillow).
+  - ``large-image-source-dicom``: A tile source for reading DICOM Whole Slide Images (WSI).
 
   - ``large-image-source-gdal``: A tile source for reading geotiff files via GDAL.  This handles source data with more complex transforms than the mapnik tile source.
 
   - ``large-image-source-mapnik``: A tile source for reading geotiff and netcdf files via Mapnik and GDAL.  This handles more vector issues than the gdal tile source.
 
-  - ``large-image-source-openjpeg``: A tile source using the Glymur library to read jp2 (JPEG 2000) files.
-
-  - ``large-image-source-nd2``: A tile source for reading nd2 (NIS Element) images.
-
-  - ``large-image-source-bioformats``: A tile source for reading any file handled by the Java Bioformats library.
-
-  - ``large-image-source-deepzoom``: A tile source for reading Deepzoom tiles.
-
   - ``large-image-source-multi``: A tile source for compositing other tile sources into a single multi-frame source.
 
-  - ``large-image-source-vips``: A tile source for reading any files handled by libvips.  This also can be used for writing tiled images from numpy arrays.
-
-  - ``large-image-source-tifffile``: A tile source using the tifffile library that can handle a wide variety of tiff-like files.
+  - ``large-image-source-nd2``: A tile source for reading nd2 (NIS Element) images.
 
-  - ``large-image-source-dicom``: A tile source for reading DICOM WSI images.
+  - ``large-image-source-ometiff``: A tile source using the tiff library that can handle most multi-frame OMETiff files that are compliant with the specification.
 
-  - ``large-image-source-test``: A tile source that generates test tiles, including a simple fractal pattern.  Useful for testing extreme zoom levels.
-
-  - ``large-image-source-dummy``: A tile source that does nothing.
+  - ``large-image-source-openjpeg``: A tile source using the Glymur library to read jp2 (JPEG 2000) files.
 
-  Most tile sources can be used with girder-large-image.  You can specific an extras_require of ``girder`` to include ``girder-large-image`` with the source.
+  - ``large-image-source-openslide``: A tile source using the OpenSlide library.  This works with svs, ndpi, Mirax, tiff, vms, and other file formats.
 
-- As a Girder plugin:
+  - ``large-image-source-pil``: A tile source for small images via the Python Imaging Library (Pillow). By default, the maximum size is 4096, but the maximum size can be configured.
 
-  - ``girder-large-image``: Large Image as a Girder_ 3.x plugin.
-    You can specify extras_require of ``tasks`` to install a Girder Worker task that can convert otherwise unreadable images to pyramidal tiff files.
+  - ``large-image-source-tiff``: A tile source for reading pyramidal tiff files in common compression formats.
 
-  - ``girder-large-image-annotation``: Annotations for large images as a Girder_ 3.x plugin.
+  - ``large-image-source-tifffile``: A tile source using the tifffile library that can handle a wide variety of tiff-like files.
 
-  - ``large-image-tasks``: A utility for running the converter via Girder Worker.
-    You can specify an extras_require of ``girder`` to include modules needed to work with the Girder remote worker or ``worker`` to include modules needed on the remote side of the Girder remote worker.  If neither is specified, some conversion tasks can be run using Girder local jobs.
+  - ``large-image-source-vips``: A tile source for reading any files handled by libvips.  This also can be used for writing tiled images from numpy arrays (up to 4 dimensions).
 
+  - ``large-image-source-zarr``: A tile source using the zarr library that can handle OME-Zarr (OME-NGFF) files as well as some other zarr files. This can also be used for writing N-dimensional tiled images from numpy arrays. Written images can be saved as any supported format.
 
-Developer Installation
-----------------------
+  - ``large-image-source-test``: A tile source that generates test tiles, including a simple fractal pattern.  Useful for testing extreme zoom levels.
 
-To install all packages from source, clone the repository::
+  - ``large-image-source-dummy``: A tile source that does nothing. This is an absolutely minimal implementation of a tile source used for testing. If you want to create a custom tile source, start with this implementation.
 
-    git clone https://github.com/girder/large_image.git
-    cd large_image
 
-Install all packages and dependencies::
+As a `Girder`_ plugin, ``large-image`` adds end points to access all of the image formats it can read both to get metadata and to act as a tile server.
+In the Girder UI, ``large-image`` shows images on item pages, and can show thumbnails in item lists when browsing folders.
+There is also cache management to balance memory use and speed of response in Girder when ``large-image`` is used as a tile server.
 
-    pip install -e . -r requirements-dev.txt
+Most tile sources can be used with Girder Large Image.  You can specify an extras_require of ``girder`` to install the following packages:
 
-If you aren't developing with Girder 3, you can skip installing those components.  Use ``requirements-dev-core.txt`` instead of ``requirements-dev.txt``::
+- ``girder-large-image``: Large Image as a Girder 3.x plugin.
 
-    pip install -e . -r requirements-dev-core.txt
+  You can install ``large-image[tasks]`` to install a Girder Worker task that can convert otherwise unreadable images to pyramidal tiff files.
 
+- ``girder-large-image-annotation``: Adds models to the Girder database for supporting annotating large images.  These annotations can be rendered on images. Annotations can include polygons, points, image overlays, and other types. Each annotation can have a label and metadata.
 
-Tile source prerequisites
-=========================
+- ``large-image-tasks``: A utility for running the converter via Girder Worker.
 
-Many tile sources have complex prerequisites.  These can be installed directly using your system's package manager or from some prebuilt Python wheels for Linux.  The prebuilt wheels are not official packages, but they can be used by instructing pip to use them by preference::
+  You can specify an extras_require of ``girder`` to include modules needed to work with the Girder remote worker or ``worker`` to include modules needed on the remote side of the Girder remote worker.  If neither is specified, some conversion tasks can be run using Girder local jobs.
 
-    pip install -e . -r requirements-dev.txt --find-links https://girder.github.io/large_image_wheels
 
 
-.. _Girder: https://github.com/girder/girder
+.. _Girder: https://girder.readthedocs.io/en/latest/

{large-image-source-vips-1.23.7.dev4 → large_image_source_vips-1.33.4.dev37}/large_image_source_vips/__init__.py

@@ -16,22 +16,28 @@ from large_image.constants import (NEW_IMAGE_PATH_FLAG, TILE_FORMAT_NUMPY,
                                    dtypeToGValue)
 from large_image.exceptions import TileSourceError, TileSourceFileNotFoundError
 from large_image.tilesource import FileTileSource
-from large_image.tilesource.utilities import _imageToNumpy
+from large_image.tilesource.utilities import _imageToNumpy, _newFromFileLock, nearPowerOfTwo
 
 logging.getLogger('pyvips').setLevel(logging.ERROR)
 
 # Default to ignoring files with no extension and some specific extensions.
-config.ConfigValues['source_vips_ignored_names'] = \
-    r'(^[^.]*|\.(yml|yaml|json|png|svs))$'
+config.ConfigValues.setdefault(
+    'source_vips_ignored_names', r'(^[^.]*|\.(yml|yaml|json|png|svs|mrxs))$')
 
 
 def _clearVipsCache():
-    old = pyvips.voperation.cache_get_max_files()
-    pyvips.voperation.cache_set_max_files(0)
-    pyvips.voperation.cache_set_max_files(old)
-    old = pyvips.voperation.cache_get_max()
-    pyvips.voperation.cache_set_max(0)
-    pyvips.voperation.cache_set_max(old)
+    oldfiles = pyvips.cache_get_max_files()
+    oldmax = pyvips.cache_get_max()
+    oldmem = pyvips.cache_get_max_mem()
+    # print('Clearing vips cache: size %r, max files %r, max %r, mem %r' % (
+    #     pyvips.cache_get_size(), oldfiles, oldmax, oldmem))
+    pyvips.cache_set_max_files(0)
+    # This shouldn't ever go to zero
+    pyvips.cache_set_max(1)
+    pyvips.cache_set_max_mem(0)
+    pyvips.cache_set_max_files(oldfiles)
+    pyvips.cache_set_max(oldmax)
+    pyvips.cache_set_max_mem(oldmem)
 
 
 _cacheClearFuncs.append(_clearVipsCache)
@@ -50,10 +56,11 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
     mimeTypes = {
         None: SourcePriority.FALLBACK,
     }
+    newPriority = SourcePriority.MEDIUM
 
     _tileSize = 256
 
-    def __init__(self, path, **kwargs):
+    def __init__(self, path, **kwargs):  # noqa
         """
         Initialize the tile class.  See the base class for other available
         parameters.
@@ -61,20 +68,29 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         :param path: a filesystem path for the tile source.
         """
         super().__init__(path, **kwargs)
+        self.addKnownExtensions()
 
+        self._suffix = ''
         if str(path).startswith(NEW_IMAGE_PATH_FLAG):
-            return self._initNew(**kwargs)
+            self._initNew(**kwargs)
+            return
         self._largeImagePath = str(self._getLargeImagePath())
         self._editable = False
 
-        self._ignoreSourceNames('vips', self._largeImagePath)
+        config._ignoreSourceNames('vips', self._largeImagePath)
         try:
-            self._image = pyvips.Image.new_from_file(self._largeImagePath)
+            with _newFromFileLock:
+                self._image = pyvips.Image.new_from_file(self._largeImagePath)
         except pyvips.error.Error:
             if not os.path.isfile(self._largeImagePath):
                 raise TileSourceFileNotFoundError(self._largeImagePath) from None
             msg = 'File cannot be opened via pyvips'
             raise TileSourceError(msg)
+        # Ask pdfs to render at a higher resolution
+        if ('vips-loader' in self._image.get_fields() and
+                self._image.get('vips-loader') in {'pdfload'}):
+            self._suffix = ',dpi=144'
+            self._image = pyvips.Image.new_from_file(self._largeImagePath + '[dpi=300]')
         self.sizeX = self._image.width
         self.sizeY = self._image.height
         self.tileWidth = self.tileHeight = self._tileSize
@@ -82,15 +98,29 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         if 'n-pages' in self._image.get_fields():
             pages = self._image.get('n-pages')
         self._frames = [0]
+        self._lowres = {}
         for page in range(1, pages):
-            subInputPath = self._largeImagePath + '[page=%d]' % page
-            subImage = pyvips.Image.new_from_file(subInputPath)
+            subInputPath = self._largeImagePath + f'[page={page}{self._suffix}]'
+            with _newFromFileLock:
+                try:
+                    subImage = pyvips.Image.new_from_file(subInputPath)
+                except Exception:
+                    continue
             if subImage.width == self.sizeX and subImage.height == self.sizeY:
                 self._frames.append(page)
                 continue
+            if (self.sizeX - 16 < subImage.width <= self.sizeX and
+                    self.sizeY - 16 < subImage.height <= self.sizeY):
+                self._frames.append(page)
+                continue
             if subImage.width * subImage.height < self.sizeX * self.sizeY:
+                if (nearPowerOfTwo(self.sizeX, subImage.width) and
+                        nearPowerOfTwo(self.sizeY, subImage.height)):
+                    level = int(round(math.log(self.sizeX / subImage.width) / math.log(2)))
+                    self._lowres.setdefault(len(self._frames) - 1, {})[level] = page
                 continue
             self._frames = [page]
+            self._lowres = {}
             self.sizeX = subImage.width
             self.sizeY = subImage.height
             try:
@@ -98,12 +128,41 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             except Exception:
                 pass
             self._image = subImage
+        self._checkLowerLevels()
         self.levels = int(max(1, math.ceil(math.log(
             float(max(self.sizeX, self.sizeY)) / self.tileWidth) / math.log(2)) + 1))
-        if len(self._frames) > 1:
+        if len(self._frames) > 1 or self._lowres is not None:
             self._recentFrames = cachetools.LRUCache(maxsize=6)
             self._frameLock = threading.RLock()
 
+    def _checkLowerLevels(self):
+        if (len(self._lowres) != len(self._frames) or
+                min(len(v) for v in self._lowres.values()) !=
+                max(len(v) for v in self._lowres.values()) or
+                min(len(v) for v in self._lowres.values()) == 0):
+            self._lowres = None
+            if len(self._frames) == 1 and 'openslide.level-count' in self._image.get_fields():
+                self._lowres = [{}]
+                for oslevel in range(1, int(self._image.get('openslide.level-count'))):
+                    with _newFromFileLock:
+                        try:
+                            subImage = pyvips.Image.new_from_file(
+                                self._largeImagePath, level=oslevel)
+                        except Exception:
+                            continue
+                        if subImage.width * subImage.height < self.sizeX * self.sizeY:
+                            if (nearPowerOfTwo(self.sizeX, subImage.width) and
+                                    nearPowerOfTwo(self.sizeY, subImage.height)):
+                                level = int(round(math.log(
+                                    self.sizeX / subImage.width) / math.log(2)))
+                                self._lowres[0][level] = (self._frames[0], oslevel)
+                if not len(self._lowres[0]):
+                    self._lowres = None
+        else:
+            self._lowres = list(self._lowres.values())
+        if self._lowres is not None:
+            self._populatedLevels = len(self._lowres[0]) + 1
+
     def _initNew(self, **kwargs):
         """
         Initialize the tile class for creating a new image.
@@ -115,6 +174,7 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         self.sizeX = self.sizeY = self.levels = 0
         self.tileWidth = self.tileHeight = self._tileSize
         self._frames = [0]
+        self._lowres = None
         self._cacheValue = str(uuid.uuid4())
         self._output = None
         self._editable = True
@@ -170,24 +230,38 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             self._addMetadataFrameInformation(result)
         return result
 
-    def _getFrameImage(self, frame=0):
+    def _getFrameImage(self, frame=0, lowres=None):
         """
         Get the vips image associated with a specific frame.
 
         :param frame: the 0-based frame to get.
+        :param lowres: the lower resolution part of the frame
         :returns: a vips image.
         """
         if self._image is None and self._output:
             self._outputToImage()
         img = self._image
-        if frame > 0:
+        if frame > 0 or lowres:
             with self._frameLock:
-                if frame not in self._recentFrames:
-                    subpath = self._largeImagePath + '[page=%d]' % self._frames[frame]
-                    img = pyvips.Image.new_from_file(subpath)
-                    self._recentFrames[frame] = img
+                key = (frame, lowres)
+                frameval = self._frames[frame]
+                params = {}
+                if lowres is not None:
+                    if isinstance(self._lowres[frame][lowres], tuple):
+                        frameval = self._lowres[frame][lowres][0]
+                        params = {'level': self._lowres[frame][lowres][1]}
+                    else:
+                        frameval = self._lowres[frame][lowres]
+                if key not in self._recentFrames:
+                    if frameval:
+                        subpath = self._largeImagePath + f'[page={frameval}{self._suffix}]'
+                    else:
+                        subpath = self._largeImagePath
+                    with _newFromFileLock:
+                        img = pyvips.Image.new_from_file(subpath, **params)
+                    self._recentFrames[key] = img
                 else:
-                    img = self._recentFrames[frame]
+                    img = self._recentFrames[key]
         return img
 
     def getNativeMagnification(self):
@@ -206,14 +280,35 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
     def getTile(self, x, y, z, pilImageAllowed=False, numpyAllowed=False, **kwargs):
         frame = self._getFrame(**kwargs)
         self._xyzInRange(x, y, z, frame, len(self._frames))
-        img = self._getFrameImage(frame)
         x0, y0, x1, y1, step = self._xyzToCorners(x, y, z)
-        tileimg = img.crop(x0, y0, x1 - x0, y1 - y0)
-        tileimg = tileimg.reduce(step, step, kernel=pyvips.enums.Kernel.NEAREST)
-        tile = np.ndarray(
-            buffer=tileimg.write_to_memory(),
-            dtype=GValueToDtype[tileimg.format],
-            shape=[tileimg.height, tileimg.width, tileimg.bands])
+        lowres = None
+        if self._lowres and step > 1:
+            use = 0
+            for ll in self._lowres[frame].keys():
+                if 2 ** ll <= step:
+                    use = max(use, ll)
+            if use:
+                lowres = use
+                div = 2 ** use
+                x0 //= div
+                y0 //= div
+                x1 //= div
+                y1 //= div
+                step //= div
+        img = self._getFrameImage(frame, lowres)
+        tileimg = img.crop(min(x0, img.width), min(y0, img.height),
+                           min(x1, img.width) - min(x0, img.width),
+                           min(y1, img.height) - min(y0, img.height))
+        try:
+            if step != 1:
+                tileimg = tileimg.resize(1.0 / step, kernel=pyvips.enums.Kernel.NEAREST, gap=0)
+            tile = np.ndarray(
+                buffer=tileimg.write_to_memory(),
+                dtype=GValueToDtype[tileimg.format],
+                shape=[tileimg.height, tileimg.width, tileimg.bands])
+        except Exception:
+            self.logger.exception('Failed to getTile')
+            tile = np.zeros((1, 1))
         return self._outputTile(tile, TILE_FORMAT_NUMPY, x, y, z,
                                 pilImageAllowed, numpyAllowed, **kwargs)
 
@@ -298,7 +393,8 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         """
         if self._output is not None:
             self._image = None
-            w, h = self._output['width'], self._output['height']
+            w = self._output['width'] - min(0, self._output['minx'])
+            h = self._output['height'] - min(0, self._output['miny'])
             w = max(self.minWidth or w, w)
             h = max(self.minHeight or h, h)
             self.sizeX = w
@@ -310,7 +406,10 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
     def addTile(self, tile, x=0, y=0, mask=None, interpretation=None):
         """
         Add a numpy or image tile to the image, expanding the image as needed
-        to accommodate it.
+        to accommodate it.  Note that x and y can be negative.  If so, the
+        output image (and internal memory access of the image) will act as if
+        the 0, 0 point is the most negative position.  Cropping is applied
+        after this offset.
 
         :param tile: a numpy array, PIL Image, vips image, or a binary string
             with an image.  The numpy array can have 2 or 3 dimensions.
@@ -431,7 +530,9 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                 if img.format == 'float' and entry['image'].format == 'double':
                     entryimage = entryimage.cast(img.format)
                 branch = branch.composite(
-                    entryimage, pyvips.BlendMode.OVER, x=entry['x'], y=entry['y'])
+                    entryimage, pyvips.BlendMode.OVER,
+                    x=entry['x'] - min(0, self._output['minx']),
+                    y=entry['y'] - min(0, self._output['miny']))
                 if not ((idx + 1) % leaves) or idx + 1 == len(self._output['images']):
                     trunk = trunk.composite(branch, pyvips.BlendMode.OVER, x=0, y=0)
                     branch = baseimg.copy()
@@ -593,9 +694,25 @@ class VipsFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         if not self._editable:
             return self._image.format
         return self._getVipsFormat()
-
     # TODO: specify bit depth / bandFormat explicitly
 
+    @property
+    def origin(self):
+        if not self._editable:
+            return {'x': 0, 'y': 0}
+        return {'x': min(0, self._output['minx'] or 0),
+                'y': min(0, self._output['miny'] or 0)}
+
+    @classmethod
+    def addKnownExtensions(cls):
+        if not hasattr(cls, '_addedExtensions'):
+            cls._addedExtensions = True
+            cls.extensions = cls.extensions.copy()
+            for dotext in pyvips.base.get_suffixes():
+                ext = dotext.lstrip('.')
+                if ext not in cls.extensions:
+                    cls.extensions[ext] = SourcePriority.IMPLICIT
+
 
 def open(*args, **kwargs):
     """Create an instance of the module class."""

large_image_source_vips-1.33.4.dev37/large_image_source_vips.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: large-image-source-vips
+Version: 1.33.4.dev37
+Summary: A libvips tilesource for large_image.
+Home-page: https://github.com/girder/large_image
+Author: Kitware, Inc.
+Author-email: kitware@kitware.com
+License: Apache-2.0
+Keywords: large_image,tile source
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: large-image>=1.33.4.dev37
+Requires-Dist: numpy
+Requires-Dist: packaging
+Requires-Dist: pyvips
+Provides-Extra: girder
+Requires-Dist: girder-large-image; extra == "girder"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A libvips tilesource for large_image.
+
+See the large-image package for more details.

{large-image-source-vips-1.23.7.dev4 → large_image_source_vips-1.33.4.dev37}/large_image_source_vips.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.rst
+pyproject.toml
 setup.py
 large_image_source_vips/__init__.py
 large_image_source_vips/girder_source.py

large_image_source_vips-1.33.4.dev37/large_image_source_vips.egg-info/requires.txt

@@ -0,0 +1,7 @@
+large-image>=1.33.4.dev37
+numpy
+packaging
+pyvips
+
+[girder]
+girder-large-image

large_image_source_vips-1.33.4.dev37/pyproject.toml

@@ -0,0 +1,7 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+fallback_version = "0.0.0"
+root = "../.."

{large-image-source-vips-1.23.7.dev4 → large_image_source_vips-1.33.4.dev37}/setup.py

@@ -6,58 +6,37 @@ description = 'A libvips tilesource for large_image.'
 long_description = description + '\n\nSee the large-image package for more details.'
 
 
-def prerelease_local_scheme(version):
-    """
-    Return local scheme version unless building on master in CircleCI.
-
-    This function returns the local scheme version number
-    (e.g. 0.0.0.dev<N>+g<HASH>) unless building on CircleCI for a
-    pre-release in which case it ignores the hash and produces a
-    PEP440 compliant pre-release version number (e.g. 0.0.0.dev<N>).
-    """
-    from setuptools_scm.version import get_local_node_and_date
-
-    if os.getenv('CIRCLE_BRANCH') in ('master', ):
-        return ''
-    else:
-        return get_local_node_and_date(version)
-
-
 try:
     from setuptools_scm import get_version
 
-    version = get_version(root='../..', local_scheme=prerelease_local_scheme)
-    limit_version = f'>={version}' if '+' not in version else ''
+    version = get_version(root='../..')
+    limit_version = f'>={version}' if '+' not in version and not os.getenv('TOX_ENV_NAME') else ''
 except (ImportError, LookupError):
     limit_version = ''
 
 setup(
     name='large-image-source-vips',
-    use_scm_version={'root': '../..', 'local_scheme': prerelease_local_scheme,
-                     'fallback_version': '0.0.0'},
-    setup_requires=['setuptools-scm'],
     description=description,
     long_description=long_description,
-    license='Apache Software License 2.0',
+    long_description_content_type='text/x-rst',
+    license='Apache-2.0',
     author='Kitware, Inc.',
     author_email='kitware@kitware.com',
     classifiers=[
         'Development Status :: 5 - Production/Stable',
-        'License :: OSI Approved :: Apache Software License',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
     ],
+    python_requires='>=3.9',
     install_requires=[
         f'large-image{limit_version}',
         'numpy',
         'packaging',
         'pyvips',
-        'importlib-metadata<5 ; python_version < "3.8"',
     ],
     extras_require={
         'girder': 'girder-large-image',
@@ -65,7 +44,6 @@ setup(
     keywords='large_image, tile source',
     packages=find_packages(exclude=['test', 'test.*']),
     url='https://github.com/girder/large_image',
-    python_requires='>=3.6',
     entry_points={
         'large_image.source': [
             'vips = large_image_source_vips:VipsFileTileSource',

large-image-source-vips-1.23.7.dev4/PKG-INFO

@@ -1,25 +0,0 @@
-Metadata-Version: 2.1
-Name: large-image-source-vips
-Version: 1.23.7.dev4
-Summary: A libvips tilesource for large_image.
-Home-page: https://github.com/girder/large_image
-Author: Kitware, Inc.
-Author-email: kitware@kitware.com
-License: Apache Software License 2.0
-Keywords: large_image,tile source
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.6
-Provides-Extra: girder
-License-File: LICENSE
-
-A libvips tilesource for large_image.
-
-See the large-image package for more details.

large-image-source-vips-1.23.7.dev4/large_image_source_vips.egg-info/PKG-INFO

@@ -1,25 +0,0 @@
-Metadata-Version: 2.1
-Name: large-image-source-vips
-Version: 1.23.7.dev4
-Summary: A libvips tilesource for large_image.
-Home-page: https://github.com/girder/large_image
-Author: Kitware, Inc.
-Author-email: kitware@kitware.com
-License: Apache Software License 2.0
-Keywords: large_image,tile source
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.6
-Provides-Extra: girder
-License-File: LICENSE
-
-A libvips tilesource for large_image.
-
-See the large-image package for more details.

large-image-source-vips-1.23.7.dev4/large_image_source_vips.egg-info/requires.txt

@@ -1,10 +0,0 @@
-large-image>=1.23.7.dev4
-numpy
-packaging
-pyvips
-
-[:python_version < "3.8"]
-importlib-metadata<5
-
-[girder]
-girder-large-image