large-image 1.27.1.dev40__tar.gz → 1.27.1.dev44__tar.gz

{large-image-1.27.1.dev40/large_image.egg-info → large-image-1.27.1.dev44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: large-image
-Version: 1.27.1.dev40
+Version: 1.27.1.dev44
 Summary: Python modules to work with large, multiresolution images.
 Home-page: https://github.com/girder/large_image
 Author: Kitware, Inc.

{large-image-1.27.1.dev40 → large-image-1.27.1.dev44}/large_image/tilesource/base.py

@@ -56,8 +56,6 @@ class TileSource(IPyLeafletMixin):
     nameMatches: Dict[str, SourcePriority] = {
     }
 
-    geospatial = False
-
     # When getting tiles for otherwise empty levels (missing powers of two), we
     # composite the tile from higher resolution levels.  This can use excessive
     # memory if there are too many missing levels.  For instance, if there are
@@ -203,6 +201,10 @@ class TileSource(IPyLeafletMixin):
     def _repr_png_(self):
         return self.getThumbnail(encoding='PNG')[0]
 
+    @property
+    def geospatial(self) -> bool:
+        return False
+
     def _setStyle(self, style: Any) -> None:
         """
         Check and set the specified style from a json string or a dictionary.
@@ -842,8 +844,9 @@ class TileSource(IPyLeafletMixin):
 
         self.logger.debug(
             'Fetching region of an image with a source size of %d x %d; '
-            'getting %d tiles',
-            regionWidth, regionHeight, (xmax - xmin) * (ymax - ymin))
+            'getting %d tile%s',
+            regionWidth, regionHeight, (xmax - xmin) * (ymax - ymin),
+            '' if (xmax - xmin) * (ymax - ymin) == 1 else 's')
 
         # If tile is specified, return at most one tile
         if iterInfo.get('tile_position') is not None:
@@ -1604,7 +1607,7 @@ class TileSource(IPyLeafletMixin):
             tile = self._applyStyle(tile, getattr(self, 'style', None), x, y, z, frame)
         if tile.shape[0] != self.tileHeight or tile.shape[1] != self.tileWidth:
             extend = np.zeros(
-                (self.tileHeight, self.tileWidth, tile.shape[2]),
+                (self.tileHeight, self.tileWidth, tile.shape[2]),  # type: ignore[misc]
                 dtype=tile.dtype)
             extend[:min(self.tileHeight, tile.shape[0]),
                    :min(self.tileWidth, tile.shape[1])] = tile
@@ -1672,10 +1675,10 @@ class TileSource(IPyLeafletMixin):
                                 sizeY - (maxY - self.tileHeight))
             tile, mode = _imageToNumpy(tile)
             if self.edge in (True, 'crop'):
-                tile = cast(np.ndarray, tile)[:contentHeight, :contentWidth]
+                tile = tile[:contentHeight, :contentWidth]
             else:
-                color = PIL.ImageColor.getcolor(self.edge, cast(str, mode))
-                tile = cast(np.ndarray, tile).copy()
+                color = PIL.ImageColor.getcolor(self.edge, mode)
+                tile = tile.copy()
                 tile[:, contentWidth:] = color
                 tile[contentHeight:] = color
         if isinstance(tile, np.ndarray) and numpyAllowed:
@@ -2207,7 +2210,7 @@ class TileSource(IPyLeafletMixin):
         mode = None if TILE_FORMAT_NUMPY in format else iterInfo['mode']
         outWidth = iterInfo['output']['width']
         outHeight = iterInfo['output']['height']
-        image: Optional[np.ndarray] = None
+        image: Optional[Union[np.ndarray, PIL.Image.Image, ImageBytes, bytes]] = None
         tiledimage = None
         for tile in self._tileIterator(iterInfo):
             # Add each tile to the image
@@ -2218,7 +2221,7 @@ class TileSource(IPyLeafletMixin):
                     tiledimage, subimage, x0, y0, regionWidth, regionHeight, tile, **kwargs)
             else:
                 image = utilities._addSubimageToImage(
-                    image, subimage, x0, y0, regionWidth, regionHeight)
+                    cast(Optional[np.ndarray], image), subimage, x0, y0, regionWidth, regionHeight)
             # Somehow discarding the tile here speeds things up.
             del tile
             del subimage
@@ -2230,7 +2233,7 @@ class TileSource(IPyLeafletMixin):
                 cast(Dict[str, Any], tiledimage), outWidth, outHeight, iterInfo, **kwargs)
         if outWidth != regionWidth or outHeight != regionHeight:
             dtype = cast(np.ndarray, image).dtype
-            image = _imageToPIL(image, mode).resize(
+            image = _imageToPIL(cast(np.ndarray, image), mode).resize(
                 (outWidth, outHeight),
                 getattr(PIL.Image, 'Resampling', PIL.Image).BICUBIC
                 if outWidth > regionWidth else
@@ -2241,8 +2244,8 @@ class TileSource(IPyLeafletMixin):
         maxHeight = kwargs.get('output', {}).get('maxHeight')
         if kwargs.get('fill') and maxWidth and maxHeight:
             image = utilities._letterboxImage(
-                _imageToPIL(image, mode), maxWidth, maxHeight, kwargs['fill'])
-        return utilities._encodeImage(image, format=format, **kwargs)
+                _imageToPIL(cast(np.ndarray, image), mode), maxWidth, maxHeight, kwargs['fill'])
+        return utilities._encodeImage(cast(np.ndarray, image), format=format, **kwargs)
 
     def _encodeTiledImage(
             self, image: Dict[str, Any], outWidth: int, outHeight: int,
@@ -2435,14 +2438,16 @@ class TileSource(IPyLeafletMixin):
                         frame, idx, len(frameList), offsetX, offsetY)
                 if tiled:
                     tiledimage = utilities._addRegionTileToTiled(
-                        tiledimage, subimage, offsetX, offsetY, outWidth, outHeight, tile, **kwargs)
-            else:
-                image = utilities._addSubimageToImage(
-                    image, subimage, offsetX, offsetY, outWidth, outHeight)
+                        tiledimage, cast(np.ndarray, subimage), offsetX,
+                        offsetY, outWidth, outHeight, tile, **kwargs)
+                else:
+                    image = utilities._addSubimageToImage(
+                        image, cast(np.ndarray, subimage), offsetX, offsetY,
+                        outWidth, outHeight)
         if tiled:
             return self._encodeTiledImage(
                 cast(Dict[str, Any], tiledimage), outWidth, outHeight, iterInfo, **kwargs)
-        return utilities._encodeImage(image, format=format, **kwargs)
+        return utilities._encodeImage(cast(np.ndarray, image), format=format, **kwargs)
 
     def getRegionAtAnotherScale(
             self, sourceRegion: Dict[str, Any],
@@ -2851,7 +2856,7 @@ class TileSource(IPyLeafletMixin):
                 getattr(PIL.Image, 'Resampling', PIL.Image).BICUBIC
                 if width > imageWidth else
                 getattr(PIL.Image, 'Resampling', PIL.Image).LANCZOS)
-        return utilities._encodeImage(image, **kwargs)
+        return cast(Tuple[ImageBytes, str], utilities._encodeImage(image, **kwargs))
 
     def getPixel(self, includeTileRecord: bool = False, **kwargs) -> JSONDict:
         """

{large-image-1.27.1.dev40 → large-image-1.27.1.dev44}/large_image/tilesource/geo.py

@@ -1,11 +1,15 @@
+import pathlib
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 from urllib.parse import urlencode, urlparse
 
-from large_image.cache_util import CacheProperties, methodcache
-from large_image.constants import SourcePriority, TileInputUnits
-from large_image.exceptions import TileSourceError
+import numpy as np
+import PIL.Image
 
+from ..cache_util import CacheProperties, methodcache
+from ..constants import SourcePriority, TileInputUnits
+from ..exceptions import TileSourceError
 from .base import FileTileSource
-from .utilities import JSONDict, getPaletteColors
+from .utilities import ImageBytes, JSONDict, getPaletteColors
 
 try:
     import pyproj
@@ -20,16 +24,16 @@ CacheProperties['tilesource']['itemExpectedSize'] = max(
     100 * 1024 ** 2)
 
 # Used to cache pixel size for projections
-ProjUnitsAcrossLevel0 = {}
+ProjUnitsAcrossLevel0: Dict[str, float] = {}
 ProjUnitsAcrossLevel0_MaxSize = 100
 
 InitPrefix = ''
 NeededInitPrefix = '+init=' if has_pyproj and _pyproj_under_6 else InitPrefix
 
 
-def make_vsi(url: str, **options):
+def make_vsi(url: Union[str, pathlib.Path, Dict[Any, Any]], **options) -> str:
     if str(url).startswith('s3://'):
-        s3_path = url.replace('s3://', '')
+        s3_path = str(url).replace('s3://', '')
         vsi = f'/vsis3/{s3_path}'
     else:
         gdal_options = {
@@ -74,7 +78,14 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
         'image/x-tiff': SourcePriority.LOW,
     }
 
-    def _getDriver(self):
+    projection: Union[str, bytes]
+    projectionOrigin: Tuple[float, float]
+    sourceLevels: int
+    sourceSizeX: int
+    sourceSizeY: int
+    unitsAcrossLevel0: float
+
+    def _getDriver(self) -> str:
         """
         Get the GDAL driver used to read this dataset.
 
@@ -82,20 +93,20 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
         """
         raise NotImplementedError
 
-    def _convertProjectionUnits(self, *args, **kwargs):
+    def _convertProjectionUnits(self, *args, **kwargs) -> Tuple[float, float, float, float, str]:
         raise NotImplementedError
 
-    def pixelToProjection(self, *args, **kwargs):
+    def pixelToProjection(self, *args, **kwargs) -> Tuple[float, float]:
         raise NotImplementedError
 
-    def toNativePixelCoordinates(self, *args, **kwargs):
+    def toNativePixelCoordinates(self, *args, **kwargs) -> Tuple[float, float]:
         raise NotImplementedError
 
-    def getBounds(self, *args, **kwargs):
+    def getBounds(self, *args, **kwargs) -> Dict[str, Any]:
         raise NotImplementedError
 
     @staticmethod
-    def isGeospatial(path):
+    def isGeospatial(path: Union[str, pathlib.Path]) -> bool:
         """
         Check if a path is likely to be a geospatial file.
 
@@ -105,13 +116,13 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
         raise NotImplementedError
 
     @property
-    def geospatial(self):
+    def geospatial(self) -> bool:
         """
         This is true if the source has geospatial information.
         """
         return bool(self.projection)
 
-    def _getLargeImagePath(self):
+    def _getLargeImagePath(self) -> str:
         """Get GDAL-compatible image path.
 
         This will cast the output to a string and can also handle URLs
@@ -122,7 +133,7 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
             return make_vsi(self.largeImagePath)
         return str(self.largeImagePath)
 
-    def _setStyle(self, style):
+    def _setStyle(self, style: Any) -> None:
         """
         Check and set the specified style from a json string or a dictionary.
 
@@ -132,7 +143,7 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
         if hasattr(self, '_getTileLock'):
             self._setDefaultStyle()
 
-    def _styleBands(self):
+    def _styleBands(self) -> List[Dict[str, Any]]:
         interpColorTable = {
             'red': ['#000000', '#ff0000'],
             'green': ['#000000', '#00ff00'],
@@ -178,7 +189,7 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
                     })
         return style
 
-    def _setDefaultStyle(self):
+    def _setDefaultStyle(self) -> None:
         """If no style was specified, create a default style."""
         self._bandNames = {}
         for idx, band in self.getBandInformation().items():
@@ -224,16 +235,16 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
             self._style = JSONDict({'bands': style})
 
     @staticmethod
-    def getHexColors(palette):
+    def getHexColors(palette: Union[str, List[Union[str, float, Tuple[float, ...]]]]) -> List[str]:
         """
         Returns list of hex colors for a given color palette
 
         :returns: List of colors
         """
-        palette = getPaletteColors(palette)
-        return ['#%02X%02X%02X%02X' % tuple(int(val) for val in clr) for clr in palette]
+        pal = getPaletteColors(palette)
+        return ['#%02X%02X%02X%02X' % tuple(int(val) for val in clr) for clr in pal]
 
-    def getPixelSizeInMeters(self):
+    def getPixelSizeInMeters(self) -> Optional[float]:
         """
         Get the approximate base pixel size in meters.  This is calculated as
         the average scale of the four edges in the WGS84 ellipsoid.
@@ -242,13 +253,13 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
         """
         bounds = self.getBounds(NeededInitPrefix + 'epsg:4326')
         if not bounds:
-            return
+            return None
         if has_pyproj:
             geod = pyproj.Geod(ellps='WGS84')
-            computer = geod.inv
+            computer = cast(Callable[[Any, Any, Any, Any], Tuple[Any, Any, float]], geod.inv)
         else:
             # Estimate based on great-cirlce distance
-            def computer(lon1, lat1, lon2, lat2):
+            def computer(lon1, lat1, lon2, lat2) -> Tuple[Any, Any, float]:
                 from math import acos, cos, radians, sin
                 lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
                 return None, None, 6.378e+6 * (
@@ -264,7 +275,7 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
                             bounds['ul']['x'], bounds['ul']['y'])
         return (s1 + s2 + s3 + s4) / (self.sourceSizeX * 2 + self.sourceSizeY * 2)
 
-    def getNativeMagnification(self):
+    def getNativeMagnification(self) -> Dict[str, Optional[float]]:
         """
         Get the magnification at the base level.
 
@@ -277,7 +288,7 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
             'mm_y': scale * 100 if scale else None,
         }
 
-    def getTileCorners(self, z, x, y):
+    def getTileCorners(self, z: int, x: float, y: float) -> Tuple[float, float, float, float]:
         """
         Returns bounds of a tile for a given x,y,z index.
 
@@ -307,7 +318,7 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
             ymin, ymax = self.sourceSizeY - ymax, self.sourceSizeY - ymin
         return xmin, ymin, xmax, ymax
 
-    def _bandNumber(self, band, exc=True):
+    def _bandNumber(self, band: Optional[Union[str, int]], exc: bool = True) -> Optional[int]:
         """Given a band number or interpretation name, return a validated band number.
 
         :param band: either -1, a positive integer, or the name of a band interpretation
@@ -339,9 +350,13 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
 
         return band
 
-    def _getRegionBounds(self, metadata, left=None, top=None, right=None,
-                         bottom=None, width=None, height=None, units=None,
-                         **kwargs):
+    def _getRegionBounds(
+            self, metadata: JSONDict, left: Optional[float] = None,
+            top: Optional[float] = None, right: Optional[float] = None,
+            bottom: Optional[float] = None, width: Optional[float] = None,
+            height: Optional[float] = None, units: Optional[str] = None,
+            desiredMagnification: Optional[Dict[str, Optional[float]]] = None,
+            cropToImage: bool = True, **kwargs) -> Tuple[float, float, float, float]:
         """
         Given a set of arguments that can include left, right, top, bottom,
         width, height, and units, generate actual pixel values for left, top,
@@ -385,7 +400,7 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
             if top is None:
                 top = bounds['ymax'] if bottom is None or width is None else bottom - width
             if bottom is None:
-                bottom = bounds['ymin'] if width is None else top + height
+                bottom = bounds['ymin'] if width is None else cast(float, top) + cast(float, height)
             if not kwargs.get('unitsWH') or kwargs.get('unitsWH') == units:
                 width = height = None
             # Convert to [-0.5, 0.5], [-0.5, 0.5] coordinate range
@@ -401,14 +416,18 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
             top = max(0, min(yScale, (0.5 - top) * yScale))
             bottom = max(0, min(yScale, (0.5 - bottom) * yScale))
             # Ensure correct ordering
-            left, right = min(left, right), max(left, right)
-            top, bottom = min(top, bottom), max(top, bottom)
+            left, right = min(cast(float, left), cast(float, right)), max(left, cast(float, right))
+            top, bottom = min(cast(float, top), cast(float, bottom)), max(top, cast(float, bottom))
             units = 'base_pixels'
         return super()._getRegionBounds(
-            metadata, left, top, right, bottom, width, height, units, **kwargs)
+            metadata, left, top, right, bottom, width, height, units,
+            desiredMagnification, cropToImage, **kwargs)
 
     @methodcache()
-    def getThumbnail(self, width=None, height=None, **kwargs):
+    def getThumbnail(
+            self, width: Optional[Union[str, int]] = None,
+            height: Optional[Union[str, int]] = None, **kwargs) -> Tuple[
+                Union[np.ndarray, PIL.Image.Image, ImageBytes, bytes, pathlib.Path], str]:
         """
         Get a basic thumbnail from the current tile source.  Aspect ratio is
         preserved.  If neither width nor height is given, a default value is
@@ -424,8 +443,8 @@ class GDALBaseFileTileSource(GeoBaseFileTileSource):
         :returns: thumbData, thumbMime: the image data and the mime type.
         """
         if self.projection:
-            if ((width is not None and width < 2) or
-                    (height is not None and height < 2)):
+            if ((width is not None and float(width) < 2) or
+                    (height is not None and float(height) < 2)):
                 msg = 'Invalid width or height.  Minimum value is 2.'
                 raise ValueError(msg)
             if width is None and height is None: