tilegrab 1.1.0__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

tilegrab/__init__.py

@@ -1,4 +1,4 @@
-version = "1.1.0"
+__version__ = "1.2.0b1"
 # from tilegrab import downloader
 # from tilegrab import sources
 # from tilegrab import mosaic

tilegrab/cli.py

@@ -1,91 +1,16 @@
 #!/usr/bin/env python3
 import logging
 import argparse
-import random
-import sys
 from pathlib import Path
 from tilegrab.downloader import Downloader
 from tilegrab.images import TileImageCollection
+from tilegrab.logs import setup_logging
 from tilegrab.tiles import TilesByShape, TilesByBBox
 from tilegrab.dataset import GeoDataset
-from tilegrab import version
-
-# Configure root logger
-# logging.basicConfig(
-#     level=logging.INFO,
-#     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-#     handlers=[
-#         logging.StreamHandler(sys.stdout),
-#         logging.FileHandler('tilegrab.log')
-#     ]
-# )
-
-# Normal colors
-BLACK   = "\033[30m"
-RED     = "\033[31m"
-GREEN   = "\033[32m"
-YELLOW  = "\033[33m"
-BLUE    = "\033[34m"
-MAGENTA = "\033[35m"
-CYAN    = "\033[36m"
-GRAY    = "\033[90m"
-WHITE  = "\033[37m"
-
-# Bright colors
-BBLACK   = "\033[90m"
-BRED     = "\033[91m"
-BGREEN   = "\033[92m"
-BYELLOW  = "\033[93m"
-BBLUE    = "\033[94m"
-BMAGENTA = "\033[95m"
-BCYAN    = "\033[96m"
-BGRAY    = "\033[97m"
-BWHITE = "\033[97m"
-
-RESET = "\033[0m"
-
-
-class LogFormatter(logging.Formatter):
-    NAME_WIDTH = 14
-
-    LEVEL_MAP = {
-        logging.CRITICAL: f'{RED}‼ {RESET}',
-        logging.ERROR:    f'{RED}✖ {RESET}',
-        logging.WARNING:  f'{YELLOW}⚠ {RESET}',
-        logging.INFO:     f'{BLUE}• {RESET}',
-        logging.DEBUG:    f'{GRAY}· {RESET}',
-        logging.NOTSET:   f'{CYAN}- {RESET}',
-    }
-
-    def format(self, record):
-        record.level_letter = self.LEVEL_MAP.get(record.levelno, '?')
-
-        short = record.name.rsplit('.', 1)[-1]
-        record.short_name = f"{short:<{self.NAME_WIDTH}}"
-
-        return super().format(record)
-
-
-console_formatter = LogFormatter(
-    f'   %(level_letter)s %(message)s'
-)
-file_formatter = logging.Formatter(
-    '%(asctime)s %(levelname)s %(name)s - %(message)s'
-)
-
-console = logging.StreamHandler(sys.stdout)
-console.setFormatter(console_formatter )
-
-file = logging.FileHandler('tilegrab.log')
-file.setFormatter(file_formatter)
-
-logging.basicConfig(
-    level=logging.INFO,
-    handlers=[console, file],
-)
+from tilegrab import __version__
 
-logger = logging.getLogger(__name__)
 
+logger = logging.getLogger(__name__)
 
 def parse_args() -> argparse.Namespace:
     p = argparse.ArgumentParser(
@@ -127,13 +52,22 @@ def parse_args() -> argparse.Namespace:
         "--key", type=str, default=None, help="API key where required by source"
     )
 
+    # Create a named group for merged output format
+    mosaic_out_group = p.add_argument_group(
+        title="Mosaic export formats", description="Formats for the output mosaic image"
+    )
+    mosaic_group = mosaic_out_group.add_mutually_exclusive_group(required=True)
+    mosaic_group.add_argument("--jpg", action="store_true", help="JPG image; no geo-reference")
+    mosaic_group.add_argument("--png", action="store_true", help="PNG image; no geo-reference")
+    mosaic_group.add_argument("--tiff", action="store_true", help="GeoTiff image; with geo-reference")
+
     # other options
     p.add_argument("--zoom", type=int, required=True, help="Zoom level (integer)")
     p.add_argument(
-        "--out",
+        "--tiles-out",
         type=Path,
         default=Path.cwd() / "saved_tiles",
-        help="Output directory (default: ./saved_tiles)",
+        help="Output directory for downloaded tiles (default: ./saved_tiles)",
     )
     p.add_argument(
         "--download-only",
@@ -148,56 +82,47 @@ def parse_args() -> argparse.Namespace:
     p.add_argument(
         "--no-progress", action="store_false", help="Hide download progress bar"
     )
+    p.add_argument("--quiet", action="store_true", help="Hide all prints")
+    p.add_argument("--debug", action="store_true", help="Enable debug logging")
     p.add_argument(
-        "--quiet", action="store_true", help="Hide all prints"
-    )
-    p.add_argument(
-        "--debug", action="store_true", help="Enable debug logging"
-    )
-    p.add_argument(
-        "--test", action="store_true", help="Only for testing purposes, not for normal use"
+        "--test",
+        action="store_true",
+        help="Only for testing purposes, not for normal use",
     )
 
     return p.parse_args()
 
 
 def main():
+    LOG_LEVEL = logging.INFO
+    ENABLE_CLI_LOG = True
+    ENABLE_FILE_LOG = True
+
     args = parse_args()
-    
-    # Adjust logging level
     if args.debug:
-        logging.getLogger().setLevel(logging.DEBUG)
-        # logger.debug("Debug logging enabled")
-    elif args.quiet:
-        console.close()
-        
-    
+        LOG_LEVEL = logging.DEBUG
+    if args.quiet:
+        ENABLE_CLI_LOG = False
     
-    BANNER_NORMAL, BANNER_BRIGHT = random.choice([
-        (RED, BRED),
-        (GREEN, BGREEN),
-        (YELLOW, BYELLOW),
-        (BLUE, BBLUE),
-        (MAGENTA, BMAGENTA),
-        (CYAN, BCYAN),
-        (GRAY, BGRAY),
-    ])
+    setup_logging(ENABLE_CLI_LOG, ENABLE_FILE_LOG, LOG_LEVEL)
 
     if not args.quiet:
         print()
-        print(f"{WHITE}   " + ("-" * 60) + f"{RESET}")
-        print(f"{BWHITE}  TileGrab v{version}{RESET}".rjust(50))
-        print(f"{WHITE}   " + ("-" * 60) + f"{RESET}")
-    
+        print(f"\033[37m   " + ("-" * 60) + "\033[0m")
+        print(f"\033[97m  TileGrab v{__version__}\033[0m".rjust(50))
+        print(f"\033[37m   " + ("-" * 60) + "\033[0m")
+
     try:
         dataset = GeoDataset(args.source)
         logger.info(f"Dataset loaded successfully from {args.source}")
 
         _tmp = "bbox" if args.bbox else "shape" if args.shape else "DnE"
-        logger.info(f"""Downloading tiles using {_tmp}
+        logger.info(
+            f"""Downloading tiles using {_tmp}
         - minX: {dataset.bbox.minx:.4f}     - minY: {dataset.bbox.miny:.4f}
         - maxX: {dataset.bbox.maxx:.4f}     - maxY: {dataset.bbox.maxy:.4f}
-        - zoom: {args.zoom}""")
+        - zoom: {args.zoom}"""
+        )
 
         if args.shape:
             tiles = TilesByShape(dataset, zoom=args.zoom)
@@ -210,34 +135,39 @@ def main():
         # Choose source provider
         if args.osm:
             from tilegrab.sources import OSM
+
             logger.info("Using OpenStreetMap (OSM) as tile source")
             source = OSM(api_key=args.key) if args.key else OSM()
         elif args.google_sat:
             from tilegrab.sources import GoogleSat
+
             logger.info("Using Google Satellite as tile source")
             source = GoogleSat(api_key=args.key) if args.key else GoogleSat()
         elif args.esri_sat:
             from tilegrab.sources import ESRIWorldImagery
+
             logger.info("Using ESRI World Imagery as tile source")
-            source = ESRIWorldImagery(api_key=args.key) if args.key else ESRIWorldImagery()
+            source = (
+                ESRIWorldImagery(api_key=args.key) if args.key else ESRIWorldImagery()
+            )
         else:
             logger.error("No tile source selected")
             raise SystemExit("No tile source selected")
-        
-        downloader = Downloader(tiles, source, args.out)
+
+        downloader = Downloader(tiles, source, args.tiles_out)
         result: TileImageCollection
 
         if args.mosaic_only:
-            result = TileImageCollection(args.out)
-            result.load(tiles)  
+            result = TileImageCollection(args.tiles_out)
+            result.load(tiles)
         else:
             result = downloader.run(show_progress=args.no_progress)
             logger.info(f"Download result: {result}")
-        
-        if not args.download_only: result.mosaic()
+
+        if not args.download_only:
+            result.mosaic(tiff=args.tiff, png=args.png)
         logger.info("Done")
 
-        
     except Exception as e:
         logger.exception("Fatal error during execution")
         raise SystemExit(1)

tilegrab/dataset.py

@@ -6,6 +6,7 @@ from typing import Union
 
 logger = logging.getLogger(__name__)
 
+TILE_EPSG = 4326 #Web Mercator - 3857 | 4326 - WGS84
 class GeoDataset:
 
     @property
@@ -63,14 +64,14 @@ class GeoDataset:
             logger.critical("Dataset has no CRS defined")
             raise RuntimeError("Missing CRS")
 
-        if epsg != 4326:
-            logger.info(f"Reprojecting dataset from EPSG:{epsg} to EPSG:4326")
-            gdf = gdf.to_crs(epsg=4326)
+        if epsg != TILE_EPSG: #Web Mercator
+            logger.info(f"Reprojecting dataset from EPSG:{epsg} to EPSG:{TILE_EPSG}")
+            gdf = gdf.to_crs(epsg=TILE_EPSG)
         else:
-            logger.debug("Dataset already in EPSG:4326")
+            logger.debug(f"Dataset already in EPSG:{TILE_EPSG}")
 
         self.original_epsg = epsg
-        self.current_epsg = 4326
+        self.current_epsg = TILE_EPSG
         self.source = gdf
         self.source_path = source_path
         logger.info(f"GeoDataset initialized successfully: {len(gdf)} features")

tilegrab/images.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from io import BytesIO
 from pathlib import Path, PosixPath, WindowsPath
 import re
-from typing import Any, List, Optional, Tuple, Union
+from typing import Any, List, Union
 from PIL import Image as PLIImage
 from box import Box
 from tilegrab.tiles import Tile, TileCollection
@@ -132,16 +132,30 @@ class TileImage:
     def url(self) -> Union[str, None]:
         return self._tile.url
 
-
+WEB_MERCATOR_EXTENT = 20037508.342789244
+EPSG = 3857
 class TileImageCollection:
     images: List[TileImage] = []
     width: int = 0
     height: int = 0
 
+    def mosaic_bounds(self, x_min, y_min, x_max, y_max, z):
+        n = 2 ** z
+        tile_size_m = 2 * WEB_MERCATOR_EXTENT / n
+
+        xmin = (WEB_MERCATOR_EXTENT*-1) + x_min * tile_size_m
+        xmax = (WEB_MERCATOR_EXTENT*-1) + (x_max + 1) * tile_size_m
+
+        ymax = WEB_MERCATOR_EXTENT - y_min * tile_size_m
+        ymin = WEB_MERCATOR_EXTENT - (y_max + 1) * tile_size_m
+
+        return xmin, ymin, xmax, ymax
+
     def load(self, tile_collection:TileCollection):
         logger.info("Start loading saved ImageTiles")
         pat = re.compile(r'^([0-9]+)_([0-9]+)_([0-9]+)\.[A-Za-z0-9]+$')
         image_col = [p for p in self.path.glob(f"*.*") if p.is_file()]
+        self.zoom = tile_collection.to_list[0].z
 
         for tile in tile_collection.to_list:
             found_matching_image = False
@@ -169,6 +183,8 @@ class TileImageCollection:
         logger.debug(f"Image appended to collection: {img.name}")
         img.save()
 
+        self.zoom = img.tile.z
+
     def __init__(self, path: Union[Path, str]) -> None:
         self.path = Path(path)
         logger.info(f"TileImageCollection initialized at {self.path}")
@@ -195,12 +211,15 @@ class TileImageCollection:
 
         self.width = int((maxx - minx + 1) * self.images[0].width)
         self.height = int((maxy - miny + 1) * self.images[0].height)
+        self.minx, self.maxx = minx, maxx
+        self.miny, self.maxy = miny, maxy
+
         logger.info(f"Collection dimensions calculated: {self.width}x{self.height}")
 
-    def mosaic(self):
+    def mosaic(self, tiff:bool=True, png:bool=False):
         logger.info("Starting mosaic creation")
         self._update_collection_dim()
-
+    
         logger.info(f"Mosaicking {len(self.images)} images into {self.width}x{self.height}")
         merged_image = PLIImage.new("RGB", (self.width, self.height))
 
@@ -210,9 +229,44 @@ class TileImageCollection:
             logger.debug(f"Pasting image at position ({px}, {py}): {image.name}")
             merged_image.paste(image.image, (px, py))
 
-        output_path = "merged_output.png"
-        merged_image.save(output_path)
-        logger.info(f"Mosaic saved to {output_path}")
+        # TODO: fix this monkey patch
+        if tiff:
+            output_path = "mosaic.tiff"
+            import numpy as np
+            from rasterio.transform import from_bounds
+            import rasterio
+            
+            data = np.array(merged_image)
+            data = data.transpose(2, 0, 1)
+
+            width_px, height_px = merged_image.size
+            xmin, ymin, xmax, ymax = self.mosaic_bounds(
+                self.minx, self.miny, self.maxx, self.maxy, self.images[0].tile.z
+            )
+
+            transform = from_bounds(
+                xmin, ymin, xmax, ymax,
+                width_px, height_px
+            )
+
+            with rasterio.open(
+                output_path,
+                "w",
+                driver="GTiff",
+                height=height_px,
+                width=width_px,
+                count=data.shape[0],
+                dtype=data.dtype,
+                crs=f"EPSG:{EPSG}",
+                transform=transform,
+            ) as dst:
+                dst.write(data)
+
+            logger.info(f"Mosaic saved to {output_path}")
+        if png:
+            output_path = "mosaic.png"
+            merged_image.save(output_path)
+            logger.info(f"Mosaic saved to {output_path}")
 
     def export_collection(self, type: ExportType):
         logger.info(f"Exporting collection as type {type}")

tilegrab/logs.py

@@ -0,0 +1,84 @@
+import logging
+import sys
+
+# Normal colors
+BLACK   = "\033[30m"
+RED     = "\033[31m"
+GREEN   = "\033[32m"
+YELLOW  = "\033[33m"
+BLUE    = "\033[34m"
+MAGENTA = "\033[35m"
+CYAN    = "\033[36m"
+GRAY    = "\033[90m"
+WHITE  = "\033[37m"
+
+# Bright colors
+BBLACK   = "\033[90m"
+BRED     = "\033[91m"
+BGREEN   = "\033[92m"
+BYELLOW  = "\033[93m"
+BBLUE    = "\033[94m"
+BMAGENTA = "\033[95m"
+BCYAN    = "\033[96m"
+BGRAY    = "\033[97m"
+BWHITE = "\033[97m"
+
+RESET = "\033[0m"
+
+
+class CLILogFormatter(logging.Formatter):
+    NAME_WIDTH = 20
+    LEVEL_MAP = {
+        logging.CRITICAL: f'{RED}‼ {RESET}',
+        logging.ERROR:    f'{RED}✖ {RESET}',
+        logging.WARNING:  f'{YELLOW}⚠ {RESET}',
+        logging.INFO:     f'{BLUE}• {RESET}',
+        logging.DEBUG:    f'{GRAY}· {RESET}',
+        logging.NOTSET:   f'{CYAN}- {RESET}',
+    }
+
+    def __init__(self, fmt=None):
+        super().__init__(fmt or '   %(level_icon)s %(message)s')
+
+    def format(self, record):
+        record.level_icon = self.LEVEL_MAP.get(record.levelno, '?')
+        short = record.name.rsplit('.', 1)[-1]
+        record.short_name = f"{short:<{self.NAME_WIDTH}}"
+
+        return super().format(record)
+
+class FileLogFormatter(logging.Formatter):
+    def __init__(self):
+        super().__init__(
+            '%(asctime)s %(levelname)s %(name)s - %(message)s'
+        )
+
+def create_cli_handler(level=logging.INFO):
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(level)
+    handler.setFormatter(CLILogFormatter())
+    return handler
+
+def create_file_handler(path="tilegrab.log", level=logging.DEBUG):
+    handler = logging.FileHandler(path)
+    handler.setLevel(level)
+    handler.setFormatter(FileLogFormatter())
+    return handler
+
+def setup_logging(
+    enable_cli=True,
+    enable_file=True,
+    level=logging.INFO
+):
+    handlers = []
+
+    if enable_cli:
+        handlers.append(create_cli_handler(level))
+
+    if enable_file:
+        handlers.append(create_file_handler(level=level))
+
+    logging.basicConfig(
+        level=level,
+        handlers=handlers,
+    )

tilegrab/tiles.py

@@ -1,15 +1,20 @@
 import logging
 import math
-from typing import Any, List, Tuple
-import mercantile
+from typing import Any, Dict, Generator, Iterator, List, Tuple
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Union
 from .dataset import GeoDataset
 from box import Box
+from shapely.geometry import box
+from shapely import intersects
 
 logger = logging.getLogger(__name__)
 
+EPSILON = 1e-14
+LL_EPSILON = 1e-11
+
+
 @dataclass
 class Tile:
     x: int = 0
@@ -24,7 +29,7 @@ class Tile:
     # def from_tuple(cls, t: tuple[int, int, int]) -> "Tile":
     #     logger.debug(f"Creating Tile from tuple: {t}")
     #     return cls(*t)
-    
+
     @property
     def url(self) -> Union[str, None]:
         return self._url
@@ -38,59 +43,63 @@ class Tile:
     def position(self) -> Box:
         if self._position is None:
             logger.error(f"Tile position not set: z={self.z}, x={self.x}, y={self.y}")
-            raise RuntimeError("Image does not have an position")
+            raise RuntimeError("Image does not have a position")
         return self._position
 
     @position.setter
     def position(self, value: Tuple[float, float]):
         x, y = self.x - value[0], self.y - value[1]
-        self._position = Box({'x': x, 'y': y})
+        self._position = Box({"x": x, "y": y})
         logger.debug(f"Tile position calculated: x={x}, y={y}")
 
+
 class TileCollection(ABC):
-    
+
     MIN_X: float = 0
     MAX_X: float = 0
     MIN_Y: float = 0
     MAX_Y: float = 0
-    _cache: Union[List[Tile], None] = None
+    _cache: List[Tile]
+    _tile_count: int = 0
 
     @abstractmethod
-    def _build_tile_cache(self) -> list[Tile]:
+    def _build_tile_cache(self) -> List[Tile]:
         raise NotImplementedError
 
     def __len__(self):
-        return sum(1 for _ in self)
+        return self._tile_count
 
     def __iter__(self):
-        for t in self._cache:  # type: ignore
-            yield t.z, t.x, t.y
+        for t in self._cache:
+            yield t
 
     def __init__(self, feature: GeoDataset, zoom: int, SAFE_LIMIT: int = 250):
         self.zoom = zoom
         self.SAFE_LIMIT = SAFE_LIMIT
         self.feature = feature
 
-        logger.info(f"Initializing TileCollection: zoom={zoom}, safe_limit={SAFE_LIMIT}")
+        logger.info(
+            f"Initializing TileCollection: zoom={zoom}, safe_limit={SAFE_LIMIT}"
+        )
 
         assert feature.bbox.minx < feature.bbox.maxx
         assert feature.bbox.miny < feature.bbox.maxy
 
         self._build_tile_cache()
-        self._update_min_max()
-        
+
         if len(self) > SAFE_LIMIT:
             logger.error(f"Tile count exceeds safe limit: {len(self)} > {SAFE_LIMIT}")
             raise ValueError(
                 f"Your query excedes the hard limit {len(self)} > {SAFE_LIMIT}"
             )
-        
+
         logger.info(f"TileCollection initialized with {len(self)} tiles")
 
     def __repr__(self) -> str:
         return f"TileCollection; len={len(self)}; x-extent=({self.feature.bbox.minx}-{self.feature.bbox.maxx}); y-extent=({self.feature.bbox.miny}-{self.feature.bbox.maxy})"
 
-    def tile_bounds(self, x, y, z) -> Tuple[float, float, float, float]:
+    def tile_bounds(self, tile: Union[Tile, Box]) -> Tuple[float, float, float, float]:
+        x, y, z = tile.x, tile.y, tile.z
         n = 2**z
 
         lon_min = x / n * 360.0 - 180.0
@@ -99,81 +108,154 @@ class TileCollection(ABC):
         lat_min = math.degrees(math.atan(math.sinh(math.pi * (1 - 2 * (y + 1) / n))))
         lat_max = math.degrees(math.atan(math.sinh(math.pi * (1 - 2 * y / n))))
 
-        logger.debug(f"Tile bounds calculated for z={z},x={x},y={y}: ({lon_min},{lat_min},{lon_max},{lat_max})")
+        logger.debug(
+            f"Tile bounds calculated for z={z},x={x},y={y}: ({lon_min},{lat_min},{lon_max},{lat_max})"
+        )
         return lon_min, lat_min, lon_max, lat_max
 
     @property
-    def to_list(self) -> list[Tile]:
-        if self._cache is None:
+    def to_list(self) -> List[Tile]:
+        cache = list(self._cache)
+        if cache is None or len(cache) < 1:
             logger.debug("Building tile cache from to_list property")
             self._build_tile_cache()
-            self._update_min_max()
             if len(self) > self.SAFE_LIMIT:
-                logger.error(f"Tile count exceeds safe limit in to_list: {len(self)} > {self.SAFE_LIMIT}")
+                logger.error(
+                    f"Tile count exceeds safe limit in to_list: {len(self)} > {self.SAFE_LIMIT}"
+                )
                 raise ValueError("Too many tiles")
-        
         assert self._cache
-        return self._cache
+        return list(self._cache)
 
-    def _update_min_max(self):
-        assert self._cache
-        x = [t.x for t in self._cache]
-        y = [t.y for t in self._cache]
-        self.MAX_X, self.MIN_X = max(x), min(x)
-        self.MAX_Y, self.MIN_Y = max(y), min(y)
+    def tile_bbox_geojson(self, x: int, y: int, z: int) -> dict:
+        min_lon, min_lat, max_lon, max_lat = self.tile_bbox(x, y, z)
+        return {
+            "type": "Polygon",
+            "coordinates": [[
+                [min_lon, min_lat],
+                [min_lon, max_lat],
+                [max_lon, max_lat],
+                [max_lon, min_lat],
+                [min_lon, min_lat]
+            ]]
+        }
+
+    def tile_bbox(self, x: int, y: int, z: int) -> Tuple[float, float, float, float]:
+        """
+        Return bounding box of a Slippy Map tile as (min_lon, min_lat, max_lon, max_lat).
+        x, y are tile indices at zoom z.
+        """
+        n = 2.0 ** z
+        min_lon = x / n * 360.0 - 180.0
+        max_lon = (x + 1) / n * 360.0 - 180.0
+
+        def tile_y_to_lat(yt: float) -> float:
+            # convert fractional tile y to latitude in degrees
+            merc_y = math.pi * (1 - 2 * yt / n)
+            lat_rad = math.atan(math.sinh(merc_y))
+            return math.degrees(lat_rad)
+
+        max_lat = tile_y_to_lat(y)        # top edge (smaller y => larger lat)
+        min_lat = tile_y_to_lat(y + 1)    # bottom edge
+
+        return (min_lon, min_lat, max_lon, max_lat)
+
+    def _tiles_in_bounds(self, clip_to_shape=False) -> Iterator[Tile]:
+        
+        bbox = self.feature.bbox
+
+        def tile(lng, lat, zoom):
+            logger.debug(f"Creating new Tile; lat={lat}; lng={lng}")
+
+            x = lng / 360.0 + 0.5
+            sinlat = math.sin(math.radians(lat))
 
-        logger.info(f"TileCollection bounds: x=({self.MIN_X}, {self.MAX_X}) y=({self.MIN_Y}, {self.MAX_Y})")
+            try:
+                y = 0.5 - 0.25 * math.log((1.0 + sinlat) / (1.0 - sinlat)) / math.pi
+            except:
+                raise
+
+            Z2 = math.pow(2, zoom)
+
+            if x <= 0:
+                xtile = 0
+            elif x >= 1:
+                xtile = int(Z2 - 1)
+            else:
+                # To address loss of precision in round-tripping between tile
+                # and lng/lat, points within EPSILON of the right side of a tile
+                # are counted in the next tile over.
+                xtile = int(math.floor((x + EPSILON) * Z2))
+
+            if y <= 0:
+                ytile = 0
+            elif y >= 1:
+                ytile = int(Z2 - 1)
+            else:
+                ytile = int(math.floor((y + EPSILON) * Z2))
+
+            
+            return Box({"x": xtile, "y": ytile})
+
+        w, s, e, n = bbox.minx, bbox.miny, bbox.maxx, bbox.maxy
+        if s < -85.051129 or n > 85.051129:
+            logger.warning("Your geometry bounds exceed the Web Mercator's limits")
+            logger.info("Clipping bounds for Web Mercator's limits")
+
+            w = max(-180.0, w)
+            s = max(-85.051129, s)
+            e = min(180.0, e)
+            n = min(85.051129, n)
+
+        ul_tile = tile(w, n, self.zoom)
+        lr_tile = tile(e - LL_EPSILON, s + LL_EPSILON, self.zoom)
+        logger.debug(f"UpperLeft Tile=({ul_tile}); LowerRight Tile=({lr_tile})")
+
+        self._tile_count = 0
+        self.MAX_X, self.MIN_X = lr_tile.x, ul_tile.x
+        self.MAX_Y, self.MIN_Y = lr_tile.y, ul_tile.y
+        logger.info(
+            f"TileCollection bounds: x=({self.MIN_X}, {self.MAX_X}) y=({self.MIN_Y}, {self.MAX_Y})"
+        )
+
+        for i in range(ul_tile.x, lr_tile.x + 1):
+            for j in range(ul_tile.y, lr_tile.y + 1):
+                if clip_to_shape:
+                    tb = box(*self.tile_bbox(i,j,self.zoom))
+                    if not tb.intersects(self.feature.shape.geometry).any():
+                        logger.debug(f"Tile excluded: z={self.zoom}, x={i}, y={j}")
+                        continue
+                self._tile_count += 1
+                t = Tile(i, j, self.zoom)
+                t.position = self.MIN_X, self.MIN_Y
+                yield t
 
-        for i in range(len(self._cache)):
-            self._cache[i].position = self.MIN_X, self.MIN_Y
 
 class TilesByBBox(TileCollection):
-    
-    def _build_tile_cache(self) -> list[Tile]:
+
+    def _build_tile_cache(self) -> List[Tile]:
         logger.info(f"Building tiles by bounding box at zoom level {self.zoom}")
         bbox = self.feature.bbox
-        logger.debug(f"BBox coordinates: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}")
-        
-        self._cache = [
-            Tile(t.x, t.y, t.z)
-            for t in mercantile.tiles(
-                bbox.minx,
-                bbox.miny,
-                bbox.maxx,
-                bbox.maxy,
-                self.zoom,
-            )
-        ]
-        
-        logger.debug(f"Generated {len(self._cache)} tiles from bounding box")
+        logger.debug(
+            f"BBox coordinates: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}"
+        )
+
+        self._cache = list(self._tiles_in_bounds(True))
+        logger.debug(f"Generated {len(self)} tiles from bounding box")
         return self._cache
 
+
 class TilesByShape(TileCollection):
 
-    def _build_tile_cache(self) -> list[Tile]:
-        from shapely.geometry import box
+    def _build_tile_cache(self) -> List[Tile]:
 
         logger.info(f"Building tiles by shape intersection at zoom level {self.zoom}")
-        geometry = self.feature.shape
-        if hasattr(geometry, "geometry"):
-            geometry = geometry.geometry.unary_union
-            logger.debug("Converted GeoDataFrame geometry to unary_union")
-
-        tiles = []
-        bbox = self.feature.bbox
-        logger.debug(f"Checking tiles within bbox: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}")
-        
-        for t in mercantile.tiles(
-            bbox.minx,
-            bbox.miny,
-            bbox.maxx,
-            bbox.maxy,
-            self.zoom,
-        ):
-            tb = box(*self.tile_bounds(t.x, t.y, t.z))
-            if tb.intersects(geometry):
-                tiles.append(Tile(t.x, t.y, t.z))
         
-        self._cache = tiles
-        logger.info(f"Generated {len(tiles)} tiles from shape intersection")
-        return tiles
+        bbox = self.feature.bbox
+        logger.debug(
+            f"Checking tiles within bbox: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}"
+        )
+
+        self._cache = list(self._tiles_in_bounds(True))
+        logger.info(f"Generated {len(self)} tiles from shape intersection")
+        return self._cache

{tilegrab-1.1.0.dist-info → tilegrab-1.2.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilegrab
-Version: 1.1.0
+Version: 1.2.0b1
 Summary: Fast geospatial map tile downloader and mosaicker
 Author: Thiwanka Munasinghe
 License-Expression: MIT
@@ -14,7 +14,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
-Requires-Dist: mercantile
+Requires-Dist: rasterio
 Requires-Dist: pillow
 Requires-Dist: tqdm
 Requires-Dist: python-box

tilegrab-1.2.0b1.dist-info/RECORD

@@ -0,0 +1,15 @@
+tilegrab/__init__.py,sha256=unu6CU3corZS1SmNsFCi-o6od2C-yIzCfVm82ADJTXM,295
+tilegrab/__main__.py,sha256=wT62aXCuN7iwRPQoswnmeGiBS5Cou0CIBvMxbOTfvFs,33
+tilegrab/cli.py,sha256=RH787UzO4pGpjPMq_BHnTO_A9qhuJnurtvn2LG4sn4U,6395
+tilegrab/dataset.py,sha256=tmbvR7wd9NYWCPsDLo9SP0x0_3edyRURQHo-6EnEIAM,2623
+tilegrab/downloader.py,sha256=ge3o4PS0v3_npaiOvFmlNSx62VqL8nwjcefy4Jr_UQo,5120
+tilegrab/images.py,sha256=VUE9Wsswkl2wAzkQnwDtncgKVU-wl3xGWagmx3u6Dk8,9278
+tilegrab/logs.py,sha256=serS8_0bhxoTO0F03t-BDSdkMYR_eX78vI2y1sSVpUk,2151
+tilegrab/sources.py,sha256=GzldtFGndziw9NNB1YMG4WUrD0fTRET1FjGCfIMMDlQ,2188
+tilegrab/tiles.py,sha256=nCJL4tOKKQoZPJbGgDfL-I1DxYjo2Ajk69McvtAoEWM,8960
+tilegrab-1.2.0b1.dist-info/licenses/LICENSE,sha256=bcZProekTTcPtnEpRKB2i1kUJ6ujlaxBZchNWKeoXc8,1094
+tilegrab-1.2.0b1.dist-info/METADATA,sha256=UHVyRZO5L1yo1Upe7jQoig0KG4Af_p6gzv6cJAfl4AA,10197
+tilegrab-1.2.0b1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tilegrab-1.2.0b1.dist-info/entry_points.txt,sha256=z-WoKN8NnA5_ZsWXucSeq-r4TeEscu0xjWYu560uNTk,47
+tilegrab-1.2.0b1.dist-info/top_level.txt,sha256=lVio8bCk3r4Bu_INLgaj4PZCrhFY2UcxHjnFBdHwyPo,9
+tilegrab-1.2.0b1.dist-info/RECORD,,

tilegrab/mosaic.py

@@ -1,75 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List
-from PIL import Image
-import re
-import os
-
-from tilegrab.tiles import TileCollection
-
-
-class Mosaic:
-
-    def __init__(
-        self, directory: str = "saved_tiles", ext: str = ".png", recursive: bool = False
-    ):
-        self.directory = directory
-        self.ext = ext
-        self.recursive = recursive
-
-        self.image_col = self._get_images()
-        assert len(self.image_col) > 0
-
-        pat = re.compile(
-            r"^([0-9]+)_([0-9]+)_([0-9]+)\.[A-Za-z0-9]+$"
-        )
-        self.image_data = {}
-
-        for i in self.image_col:
-            m = pat.match(os.path.basename(str(i)))
-            if m:
-                first = m.group(1)
-                second = m.group(2)
-                third = m.group(3)
-
-                self.image_data[i] = [int(second), int(third), int(first)]
-
-        assert len(self.image_data.keys()) > 0
-
-        print(f"Processing {len(self.image_data.keys())} tiles...")
-
-    def _get_images(self) -> List[Path]:
-
-        directory = Path(self.directory)
-        ext = self.ext
-
-        if not ext.startswith("."):
-            ext = "." + self.ext
-
-        if self.recursive:
-            return [p for p in directory.rglob(f"*{ext}") if p.is_file()]
-        else:
-            return [p for p in directory.glob(f"*{ext}") if p.is_file()]
-
-    def merge(self, tiles: TileCollection, tile_size: int = 256):
-
-        img_w = int((tiles.MAX_X - tiles.MIN_X + 1) * tile_size)
-        img_h = int((tiles.MAX_Y - tiles.MIN_Y + 1) * tile_size)
-        print(f"Image size: {img_w}x{img_h}")
-
-        merged_image = Image.new("RGB", (img_w, img_h))
-
-        for img_path, img_id in self.image_data.items():
-            x, y, _ = img_id
-
-            print(x - tiles.MIN_X + 1, "x" ,y - tiles.MIN_Y + 1)
-
-            img = Image.open(img_path)
-            img.load()
-
-            px = int((x - tiles.MIN_X) * tile_size)
-            py = int((y - tiles.MIN_Y) * tile_size)
-
-            merged_image.paste(img, (px, py))
-
-        merged_image.save(os.path.join(self.directory, "merged_output.png"))

tilegrab-1.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-tilegrab/__init__.py,sha256=0L3afZyDycCUGuBO0w7DQ9fOd798dUyinbGsM77aQOg,289
-tilegrab/__main__.py,sha256=wT62aXCuN7iwRPQoswnmeGiBS5Cou0CIBvMxbOTfvFs,33
-tilegrab/cli.py,sha256=4AxEpxBhl8REUFAc7Dqa-bCxCo5oUNJGZ1Om3QnTHV0,7700
-tilegrab/dataset.py,sha256=dNZ52mTkX_FC4e-hKAdEsvL5JVeo-MXhhAHpxKjwyGE,2525
-tilegrab/downloader.py,sha256=ge3o4PS0v3_npaiOvFmlNSx62VqL8nwjcefy4Jr_UQo,5120
-tilegrab/images.py,sha256=rld-BLuGA8LPcq0QbGsVY48mbMRivvzxdyfAwVfe0dk,7466
-tilegrab/mosaic.py,sha256=H2-Mr2j9AmwSicPGwYE5z5t0wdAfj2m42J0G7IxE0zA,2191
-tilegrab/sources.py,sha256=GzldtFGndziw9NNB1YMG4WUrD0fTRET1FjGCfIMMDlQ,2188
-tilegrab/tiles.py,sha256=WEWv96fCeHlZs_Gxzg0m3wYAy_qsHfAwkCQHcWEFwf4,6137
-tilegrab-1.1.0.dist-info/licenses/LICENSE,sha256=bcZProekTTcPtnEpRKB2i1kUJ6ujlaxBZchNWKeoXc8,1094
-tilegrab-1.1.0.dist-info/METADATA,sha256=ddmKHnd5A9LaTsjOIxSics7kovf_AXKC92bN3rrhdYY,10197
-tilegrab-1.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-tilegrab-1.1.0.dist-info/entry_points.txt,sha256=z-WoKN8NnA5_ZsWXucSeq-r4TeEscu0xjWYu560uNTk,47
-tilegrab-1.1.0.dist-info/top_level.txt,sha256=lVio8bCk3r4Bu_INLgaj4PZCrhFY2UcxHjnFBdHwyPo,9
-tilegrab-1.1.0.dist-info/RECORD,,