large-image-source-tiff 1.27.5.dev65__tar.gz → 1.30.7.dev10__tar.gz

{large-image-source-tiff-1.27.5.dev65 → large_image_source_tiff-1.30.7.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: large-image-source-tiff
-Version: 1.27.5.dev65
+Version: 1.30.7.dev10
 Summary: A TIFF tilesource for large_image.
 Home-page: https://github.com/girder/large_image
 Author: Kitware, Inc.
@@ -15,9 +15,17 @@ 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.8
-Provides-Extra: girder
+Description-Content-Type: text/x-rst
 License-File: LICENSE
+Requires-Dist: large-image>=1.30.7.dev10
+Requires-Dist: pylibtiff
+Requires-Dist: tifftools>=1.2.0
+Provides-Extra: all
+Requires-Dist: pylibjpeg-openjpeg; extra == "all"
+Provides-Extra: girder
+Requires-Dist: girder-large-image>=1.30.7.dev10; extra == "girder"
 
 A TIFF tilesource for large_image.
 

{large-image-source-tiff-1.27.5.dev65 → large_image_source_tiff-1.30.7.dev10}/README.rst

@@ -15,7 +15,7 @@ Large Image
    :target: https://codecov.io/github/girder/large_image?branch=master
    :alt: codecov.io
 
-.. |doi-badge| image:: https://img.shields.io/badge/DOI-10.5281%2Fzenodo.4723355-blue
+.. |doi-badge| image:: https://img.shields.io/badge/DOI-10.5281%2Fzenodo.4723355-blue.svg
    :target: https://zenodo.org/badge/latestdoi/45569214
 
 .. |pypi-badge| image:: https://img.shields.io/pypi/v/large-image.svg?logo=python&logoColor=white
@@ -39,7 +39,7 @@ 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
 ~~~
@@ -52,7 +52,7 @@ 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
 
@@ -60,8 +60,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
@@ -118,7 +119,7 @@ Large Image consists of several Python modules designed to work together.  These
 
   - ``large-image-source-deepzoom``: A tile source for reading Deepzoom tiles.
 
-  - ``large-image-source-dicom``: A tile source for reading DICOM WSI images.
+  - ``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.
 
@@ -128,62 +129,41 @@ Large Image consists of several Python modules designed to work together.  These
 
   - ``large-image-source-nd2``: A tile source for reading nd2 (NIS Element) images.
 
-  - ``large-image-source-ometiff``: A tile source using the tiff library that can handle some multi-frame OMETiff files.
+  - ``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-openjpeg``: A tile source using the Glymur library to read jp2 (JPEG 2000) files.
 
   - ``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-pil``: A tile source for small images via the Python Imaging Library (Pillow).
+  - ``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.
 
   - ``large-image-source-tiff``: A tile source for reading pyramidal tiff files in common compression formats.
 
   - ``large-image-source-tifffile``: A tile source using the tifffile library that can handle a wide variety of tiff-like files.
 
-  - ``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-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.
+  - ``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.
 
   - ``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-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.
 
-  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.
 
-- As a Girder plugin:
+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.
 
-  - ``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.
+Most tile sources can be used with Girder Large Image.  You can specify an extras_require of ``girder`` to install the following packages:
 
-  - ``girder-large-image-annotation``: Annotations for large images as a Girder_ 3.x plugin.
+  - ``girder-large-image``: Large Image as a Girder 3.x plugin.
+    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.
 
   - ``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.
 
 
-Developer Installation
-----------------------
-
-To install all packages from source, clone the repository::
-
-    git clone https://github.com/girder/large_image.git
-    cd large_image
-
-Install all packages and dependencies::
-
-    pip install -e . -r requirements-dev.txt
-
-If you aren't developing with Girder 3, you can skip installing those components.  Use ``requirements-dev-core.txt`` instead of ``requirements-dev.txt``::
-
-    pip install -e . -r requirements-dev-core.txt
-
-
-Tile source prerequisites
-=========================
-
-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::
-
-    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-tiff-1.27.5.dev65 → large_image_source_tiff-1.30.7.dev10}/large_image_source_tiff/__init__.py

@@ -30,7 +30,9 @@ import tifftools
 
 from large_image.cache_util import LruCacheMetaclass, methodcache
 from large_image.constants import TILE_FORMAT_NUMPY, TILE_FORMAT_PIL, SourcePriority
-from large_image.exceptions import TileSourceError, TileSourceFileNotFoundError
+from large_image.exceptions import (TileSourceError,
+                                    TileSourceFileNotFoundError,
+                                    TileSourceMalformedError)
 from large_image.tilesource import FileTileSource, nearPowerOfTwo
 
 from . import tiff_reader
@@ -73,6 +75,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
     }
 
     _maxAssociatedImageSize = 8192
+    _maxUntiledImage = 4096
 
     def __init__(self, path, **kwargs):  # noqa
         """
@@ -85,18 +88,20 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
 
         self._largeImagePath = str(self._getLargeImagePath())
 
+        lastException = None
         try:
             self._initWithTiffTools()
             return
+        except TileSourceMalformedError:
+            raise
         except Exception as exc:
             self.logger.debug('Cannot read with tifftools route; %r', exc)
+            lastException = exc
 
         alldir = []
         try:
             if hasattr(self, '_info'):
                 alldir = self._scanDirectories()
-            else:
-                lastException = 'Could not parse file with tifftools'
         except IOOpenTiffError:
             msg = 'File cannot be opened via tiff source.'
             raise TileSourceError(msg)
@@ -136,7 +141,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                 continue
             # If a layer is a multiple of the tile size, the number of tiles
             # should be a power of two rounded up from the primary.
-            if (not (td.imageWidth % td.tileWidth) and not (td.imageHeight % td.tileHeight)):
+            if not (td.imageWidth % td.tileWidth) and not (td.imageHeight % td.tileHeight):
                 htw = highest.imageWidth // td.tileWidth
                 hth = highest.imageHeight // td.tileHeight
                 ttw = td.imageWidth // td.tileWidth
@@ -157,7 +162,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             tifftools.constants.SampleFormat[sampleformat or 1].name,
             bitspersample,
         ))
-        self._bandCount = highest._tiffInfo.get('samplesperpixel')
+        self._bandCount = highest._tiffInfo.get('samplesperpixel', 1)
         # Sort the directories so that the highest resolution is the last one;
         # if a level is missing, put a None value in its place.
         self._tiffDirectories = [directories.get(key) for key in
@@ -252,8 +257,13 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         """
         sizeX = ifd['tags'][tifftools.Tag.ImageWidth.value]['data'][0]
         sizeY = ifd['tags'][tifftools.Tag.ImageLength.value]['data'][0]
-        tileWidth = baseifd['tags'][tifftools.Tag.TileWidth.value]['data'][0]
-        tileHeight = baseifd['tags'][tifftools.Tag.TileLength.value]['data'][0]
+        if tifftools.Tag.TileWidth.value in baseifd['tags']:
+            tileWidth = baseifd['tags'][tifftools.Tag.TileWidth.value]['data'][0]
+            tileHeight = baseifd['tags'][tifftools.Tag.TileLength.value]['data'][0]
+        else:
+            tileWidth = sizeX
+            tileHeight = baseifd['tags'][tifftools.Tag.RowsPerStrip.value]['data'][0]
+
         for tag in {
                 tifftools.Tag.SamplesPerPixel.value,
                 tifftools.Tag.BitsPerSample.value,
@@ -298,7 +308,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         directories are the same size and format; all non-tiled directories are
         treated as associated images.
         """
-        dir0 = self.getTiffDir(0)
+        dir0 = self.getTiffDir(0, mustBeTiled=None)
         self.tileWidth = dir0.tileWidth
         self.tileHeight = dir0.tileHeight
         self.sizeX = dir0.imageWidth
@@ -312,21 +322,26 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             tifftools.constants.SampleFormat[sampleformat or 1].name,
             bitspersample,
         ))
-        self._bandCount = dir0._tiffInfo.get('samplesperpixel')
+        self._bandCount = dir0._tiffInfo.get('samplesperpixel', 1)
         info = _cached_read_tiff(self._largeImagePath)
         self._info = info
         frames = []
         associated = []  # for now, a list of directories
-        curframe = -1
+        used_subifd = False
         for idx, ifd in enumerate(info['ifds']):
             # if not tiles, add to associated images
             if tifftools.Tag.tileWidth.value not in ifd['tags']:
-                associated.append(idx)
+                associated.append((idx, False))
                 continue
-            level = self._levelFromIfd(ifd, info['ifds'][0])
+            try:
+                level = self._levelFromIfd(ifd, info['ifds'][0])
+            except TileSourceError:
+                if idx and used_subifd:
+                    associated.append((idx, True))
+                    continue
+                raise
             # if the same resolution as the main image, add a frame
             if level == self.levels - 1:
-                curframe += 1
                 frames.append({'dirs': [None] * self.levels})
                 frames[-1]['dirs'][-1] = (idx, 0)
                 try:
@@ -359,15 +374,52 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                     if len(subifds) != 1:
                         msg = 'When stored in subifds, each subifd should be a single ifd.'
                         raise TileSourceError(msg)
-                    level = self._levelFromIfd(subifds[0], info['ifds'][0])
+                    if (tifftools.Tag.StripOffsets.value not in subifds[0]['tags'] and
+                            tifftools.Tag.TileOffsets.value not in subifds[0]['tags']):
+                        msg = 'Subifd has no strip or tile offsets.'
+                        raise TileSourceMalformedError(msg)
+                    try:
+                        level = self._levelFromIfd(subifds[0], info['ifds'][0])
+                    except Exception:
+                        break
                     if level < self.levels - 1 and frames[-1]['dirs'][level] is None:
                         frames[-1]['dirs'][level] = (idx, subidx + 1)
+                        used_subifd = True
                     else:
                         msg = 'Tile layers are in a surprising order'
                         raise TileSourceError(msg)
+        # If we have a single untiled ifd that is "small", use it
+        if tifftools.Tag.tileWidth.value not in info['ifds'][0]['tags']:
+            if (
+                self.sizeX > self._maxUntiledImage or self.sizeY > self._maxUntiledImage or
+                (len(info['ifds']) != 1 or tifftools.Tag.SubIfd.value in ifd['tags']) or
+                (tifftools.Tag.ImageDescription.value in ifd['tags'] and
+                 'ImageJ' in ifd['tags'][tifftools.Tag.ImageDescription.value]['data'])
+            ):
+                msg = 'A tiled TIFF is required.'
+                raise ValidationTiffError(msg)
+            associated = []
+            level = self._levelFromIfd(ifd, info['ifds'][0])
+            frames.append({'dirs': [None] * self.levels})
+            frames[-1]['dirs'][-1] = (idx, 0)
+            try:
+                frameMetadata = json.loads(
+                    ifd['tags'][tifftools.Tag.ImageDescription.value]['data'])
+                for key in {'channels', 'frame'}:
+                    if key in frameMetadata:
+                        frames[-1][key] = frameMetadata[key]
+            except Exception:
+                pass
+            if tifftools.Tag.ICCProfile.value in ifd['tags']:
+                if not hasattr(self, '_iccprofiles'):
+                    self._iccprofiles = []
+                while len(self._iccprofiles) < len(frames) - 1:
+                    self._iccprofiles.append(None)
+                self._iccprofiles.append(ifd['tags'][
+                    tifftools.Tag.ICCProfile.value]['data'])
         self._associatedImages = {}
-        for dirNum in associated:
-            self._addAssociatedImage(dirNum)
+        for dirNum, isTiled in associated:
+            self._addAssociatedImage(dirNum, isTiled)
         self._frames = frames
         self._tiffDirectories = [
             self.getTiffDir(
@@ -449,7 +501,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                 frame.setdefault('frame', {})
                 frame['frame']['IndexC'] = idx
 
-    def _addAssociatedImage(self, directoryNum, mustBeTiled=False, topImage=None):
+    def _addAssociatedImage(self, directoryNum, mustBeTiled=False, topImage=None, imageId=None):
         """
         Check if the specified TIFF directory contains an image with a sensible
         image description that can be used as an ID.  If so, and if the image
@@ -460,6 +512,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
            untiled images.
         :param topImage: if specified, add image-embedded metadata to this
            image.
+        :param imageId: if specified, use this as the image name.
         """
         try:
             associated = self.getTiffDir(directoryNum, mustBeTiled)
@@ -473,6 +526,8 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                 id = 'dir%d' % directoryNum
                 if not len(self._associatedImages):
                     id = 'macro'
+            if imageId:
+                id = imageId
             if not id and not mustBeTiled:
                 id = {1: 'label', 9: 'macro'}.get(associated._tiffInfo.get('subfiletype'))
             if not isinstance(id, str):
@@ -484,7 +539,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                     associated._pixelInfo['width'] <= self._maxAssociatedImageSize and
                     associated._pixelInfo['height'] <= self._maxAssociatedImageSize and
                     id not in self._associatedImages):
-                image = associated._tiffFile.read_image()
+                image = associated.read_image()
                 # Optrascan scanners store xml image descriptions in a "tiled
                 # image".  Check if this is the case, and, if so, parse such
                 # data
@@ -631,20 +686,16 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         else:
             dir = self._tiffDirectories[z]
         try:
-            allowStyle = True
             if dir is None:
                 try:
                     if not kwargs.get('inSparseFallback'):
-                        tile = self._getTileFromEmptyLevel(x, y, z, **kwargs)
+                        tile, format = self._getTileFromEmptyLevel(x, y, z, **kwargs)
                     else:
                         raise IOTiffError('Missing z level %d' % z)
                 except Exception:
                     if sparseFallback:
                         raise IOTiffError('Missing z level %d' % z)
-                    else:
-                        raise
-                allowStyle = False
-                format = TILE_FORMAT_PIL
+                    raise
             else:
                 tile = dir.getTile(x, y, asarray=numpyAllowed == 'always')
                 format = 'JPEG'
@@ -653,7 +704,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             if isinstance(tile, np.ndarray):
                 format = TILE_FORMAT_NUMPY
             return self._outputTile(tile, format, x, y, z, pilImageAllowed,
-                                    numpyAllowed, applyStyle=allowStyle, **kwargs)
+                                    numpyAllowed, **kwargs)
         except InvalidOperationTiffError as e:
             raise TileSourceError(e.args[0])
         except IOTiffError as e:
@@ -702,7 +753,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             else:
                 image = PIL.Image.new('RGBA', (self.tileWidth, self.tileHeight))
             return self._outputTile(image, TILE_FORMAT_PIL, x, y, z, pilImageAllowed,
-                                    numpyAllowed, applyStyle=False, **kwargs)
+                                    numpyAllowed, **kwargs)
         raise TileSourceError('Internal I/O failure: %s' % exception.args[0])
 
     def _nonemptyLevelsList(self, frame=0):
@@ -727,7 +778,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         """
         imageList = set(self._associatedImages)
         for td in self._tiffDirectories:
-            if td is not None:
+            if td is not None and td is not False:
                 imageList |= set(td._embeddedImages)
         return sorted(imageList)
 
@@ -742,11 +793,11 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         # _associatedImages.  There are some sample files where libtiff's
         # read_image fails to read the _associatedImage properly because of
         # separated jpeg information.  For the samples we currently have,
-        # preferring the _embeddedImages is sufficient, but if find other files
-        # with seemingly bad associated images, we may need to read them with a
-        # more complex process than read_image.
+        # preferring the _embeddedImages is sufficient, but if we find other
+        # files with seemingly bad associated images, we may need to read them
+        # with a more complex process than read_image.
         for td in self._tiffDirectories:
-            if td is not None and imageKey in td._embeddedImages:
+            if td is not None and td is not False and imageKey in td._embeddedImages:
                 return PIL.Image.open(io.BytesIO(base64.b64decode(td._embeddedImages[imageKey])))
         if imageKey in self._associatedImages:
             return PIL.Image.fromarray(self._associatedImages[imageKey])

{large-image-source-tiff-1.27.5.dev65 → large_image_source_tiff-1.30.7.dev10}/large_image_source_tiff/tiff_reader.py

@@ -121,7 +121,12 @@ class TiledTiffDirectory:
         self._tileLock = threading.RLock()
 
         self._open(filePath, directoryNum, subDirectoryNum)
-        self._loadMetadata()
+        try:
+            self._loadMetadata()
+        except Exception:
+            self.logger.exception('Could not parse tiff metadata')
+            raise IOOpenTiffError(
+                'Could not open TIFF file: %s' % filePath)
         self.logger.debug(
             'TiffDirectory %d:%d Information %r',
             directoryNum, subDirectoryNum or 0, self._tiffInfo)
@@ -207,8 +212,8 @@ class TiledTiffDirectory:
         # the create_image.py script, such as flatten or colourspace.  These
         # should only be done if necessary, which would require the conversion
         # job to check output and perform subsequent processing as needed.
-        if (not self._tiffInfo.get('samplesperpixel') or
-                self._tiffInfo.get('samplesperpixel') < 1):
+        if (not self._tiffInfo.get('samplesperpixel', 1) or
+                self._tiffInfo.get('samplesperpixel', 1) < 1):
             msg = 'Only RGB and greyscale TIFF files are supported'
             raise ValidationTiffError(msg)
 
@@ -442,12 +447,11 @@ class TiledTiffDirectory:
 
         if tileByteCountsLibtiffType == libtiff_ctypes.TIFFDataType.TIFF_LONG8:
             return ctypes.c_uint64
-        elif tileByteCountsLibtiffType == \
+        if tileByteCountsLibtiffType == \
                 libtiff_ctypes.TIFFDataType.TIFF_SHORT:
             return ctypes.c_uint16
-        else:
-            raise IOTiffError(
-                'Invalid type for TIFFTAG_TILEBYTECOUNTS: %s' % tileByteCountsLibtiffType)
+        raise IOTiffError(
+            'Invalid type for TIFFTAG_TILEBYTECOUNTS: %s' % tileByteCountsLibtiffType)
 
     def _getJpegFrameSize(self, tileNum):
         """
@@ -524,10 +528,10 @@ class TiledTiffDirectory:
         if bytesRead == -1:
             msg = 'Failed to read raw tile'
             raise IOTiffError(msg)
-        elif bytesRead < rawTileSize:
+        if bytesRead < rawTileSize:
             msg = 'Buffer underflow when reading tile'
             raise IOTiffError(msg)
-        elif bytesRead > rawTileSize:
+        if bytesRead > rawTileSize:
             # It's unlikely that this will ever occur, but incomplete reads will
             # be checked for by looking for the JPEG end marker
             msg = 'Buffer overflow when reading tile'
@@ -607,7 +611,7 @@ class TiledTiffDirectory:
             self._tiffInfo.get('bitspersample'),
             self._tiffInfo.get('sampleformat') if self._tiffInfo.get(
                 'sampleformat') is not None else libtiff_ctypes.SAMPLEFORMAT_UINT)
-        image = np.empty((th, tw, self._tiffInfo['samplesperpixel']),
+        image = np.empty((th, tw, self._tiffInfo.get('samplesperpixel', 1)),
                          dtype=_ctypesFormattbl[format])
         imageBuffer = image.ctypes.data_as(ctypes.POINTER(ctypes.c_char))
         if self._tiffInfo.get('istiled'):
@@ -635,7 +639,7 @@ class TiledTiffDirectory:
             raise IOTiffError(
                 'Read an unexpected number of bytes from an encoded tile' if readSize >= 0 else
                 'Failed to read from an encoded tile')
-        if (self._tiffInfo.get('samplesperpixel') == 3 and
+        if (self._tiffInfo.get('samplesperpixel', 1) == 3 and
                 self._tiffInfo.get('photometric') == libtiff_ctypes.PHOTOMETRIC_YCBCR):
             if self._tiffInfo.get('bitspersample') == 16:
                 image = np.floor_divide(image, 256).astype(np.uint8)
@@ -783,11 +787,13 @@ class TiledTiffDirectory:
 
         if (not self._tiffInfo.get('istiled') or
                 self._tiffInfo.get('compression') not in {
-                    libtiff_ctypes.COMPRESSION_JPEG, 33003, 33005, 34712} or
+                    libtiff_ctypes.COMPRESSION_JPEG, 33003, 33004, 33005, 34712} or
                 self._tiffInfo.get('bitspersample') != 8 or
                 self._tiffInfo.get('sampleformat') not in {
                     None, libtiff_ctypes.SAMPLEFORMAT_UINT} or
-                (asarray and self._tiffInfo.get('compression') not in {33003, 33005, 34712} and (
+                (asarray and self._tiffInfo.get('compression') not in {
+                    33003, 33004, 33005, 34712,
+                } and (
                     self._tiffInfo.get('compression') != libtiff_ctypes.COMPRESSION_JPEG or
                     self._tiffInfo.get('photometric') != libtiff_ctypes.PHOTOMETRIC_YCBCR))):
             return self._getUncompressedTile(tileNum)
@@ -803,9 +809,18 @@ class TiledTiffDirectory:
             # Write JPEG End Of Image marker
             imageBuffer.write(b'\xff\xd9')
             return imageBuffer.getvalue()
-        # Get the whole frame, which is in a JPEG or JPEG 2000 format, and
+        # Get the whole frame, which is in a JPEG or JPEG 2000 format
+        frame = self._getJpegFrame(tileNum, True)
+        # For JP2K, see if we can convert it faster than PIL
+        if self._tiffInfo.get('compression') in {33003, 33004, 33005, 34712}:
+            try:
+                import openjpeg
+
+                return openjpeg.decode(frame)
+            except Exception:
+                pass
         # convert it to a PIL image
-        imageBuffer.write(self._getJpegFrame(tileNum, True))
+        imageBuffer.write(frame)
         image = PIL.Image.open(imageBuffer)
         # Converting the image mode ensures that it gets loaded once and is in
         # a form we expect.  If this isn't done, then PIL can load the image
@@ -822,7 +837,7 @@ class TiledTiffDirectory:
         self._embeddedImages = {}
 
         if not meta:
-            return
+            return None
         if not isinstance(meta, str):
             meta = meta.decode(errors='ignore')
         try:
@@ -844,7 +859,7 @@ class TiledTiffDirectory:
                         meta.split('|MPP = ', 1)[1].split('|')[0].strip()) * 0.001
                 except Exception:
                     pass
-            return
+            return None
         try:
             image = xml.find(
                 ".//DataObject[@ObjectType='DPScannedImage']")
@@ -880,3 +895,26 @@ class TiledTiffDirectory:
         except Exception:
             pass
         return True
+
+    def read_image(self):
+        """
+        Use the underlying _tiffFile to read an image.  But, if it is in a jp2k
+        encoding, read the raw data and convert it.
+        """
+        if self._tiffInfo.get('compression') not in {33003, 33004, 33005, 34712}:
+            return self._tiffFile.read_image()
+        output = None
+        for yidx, y in enumerate(range(0, self.imageHeight, self.tileHeight)):
+            for xidx, x in enumerate(range(0, self.imageWidth, self.tileWidth)):
+                tile = self.getTile(xidx, yidx, asarray=True)
+                if len(tile.shape) == 2:
+                    tile = tile[:, :, np.newaxis]
+                if output is None:
+                    output = np.zeros(
+                        (self.imageHeight, self.imageWidth, tile.shape[2]), dtype=tile.dtype)
+                if tile.shape[0] > self.imageHeight - y:
+                    tile = tile[:self.imageHeight - y, :, :]
+                if tile.shape[1] > self.imageWidth - x:
+                    tile = tile[:, :self.imageWidth - x, :]
+                output[y:y + tile.shape[0], x:x + tile.shape[1], :] = tile
+        return output

{large-image-source-tiff-1.27.5.dev65 → large_image_source_tiff-1.30.7.dev10}/large_image_source_tiff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: large-image-source-tiff
-Version: 1.27.5.dev65
+Version: 1.30.7.dev10
 Summary: A TIFF tilesource for large_image.
 Home-page: https://github.com/girder/large_image
 Author: Kitware, Inc.
@@ -15,9 +15,17 @@ 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.8
-Provides-Extra: girder
+Description-Content-Type: text/x-rst
 License-File: LICENSE
+Requires-Dist: large-image>=1.30.7.dev10
+Requires-Dist: pylibtiff
+Requires-Dist: tifftools>=1.2.0
+Provides-Extra: all
+Requires-Dist: pylibjpeg-openjpeg; extra == "all"
+Provides-Extra: girder
+Requires-Dist: girder-large-image>=1.30.7.dev10; extra == "girder"
 
 A TIFF tilesource for large_image.
 

large_image_source_tiff-1.30.7.dev10/large_image_source_tiff.egg-info/requires.txt

@@ -0,0 +1,9 @@
+large-image>=1.30.7.dev10
+pylibtiff
+tifftools>=1.2.0
+
+[all]
+pylibjpeg-openjpeg
+
+[girder]
+girder-large-image>=1.30.7.dev10

{large-image-source-tiff-1.27.5.dev65 → large_image_source_tiff-1.30.7.dev10}/setup.py

@@ -19,8 +19,7 @@ def prerelease_local_scheme(version):
 
     if os.getenv('CIRCLE_BRANCH') in ('master', ):
         return ''
-    else:
-        return get_local_node_and_date(version)
+    return get_local_node_and_date(version)
 
 
 try:
@@ -37,6 +36,7 @@ setup(
                      'fallback_version': '0.0.0'},
     description=description,
     long_description=long_description,
+    long_description_content_type='text/x-rst',
     license='Apache Software License 2.0',
     author='Kitware, Inc.',
     author_email='kitware@kitware.com',
@@ -49,6 +49,7 @@ setup(
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
     ],
     install_requires=[
         f'large-image{limit_version}',
@@ -56,6 +57,9 @@ setup(
         'tifftools>=1.2.0',
     ],
     extras_require={
+        'all': [
+            'pylibjpeg-openjpeg',
+        ],
         'girder': f'girder-large-image{limit_version}',
     },
     keywords='large_image, tile source',

large-image-source-tiff-1.27.5.dev65/large_image_source_tiff.egg-info/requires.txt

@@ -1,6 +0,0 @@
-large-image>=1.27.5.dev65
-pylibtiff
-tifftools>=1.2.0
-
-[girder]
-girder-large-image>=1.27.5.dev65