tilegrab 1.1.0__tar.gz → 1.2.0b1__tar.gz

{tilegrab-1.1.0 → tilegrab-1.2.0b1}/PKG-INFO

@@ -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.1.0 → tilegrab-1.2.0b1}/pyproject.toml

@@ -7,7 +7,7 @@ requires = [
 
 [project]
 name = "tilegrab"
-version = "1.1.0"
+version = "1.2.0b1"
 description = "Fast geospatial map tile downloader and mosaicker"
 readme = "README.md"
 authors = [
@@ -25,7 +25,7 @@ keywords = [
 
 dependencies = [
     "requests",
-    "mercantile",
+    "rasterio",
     "pillow",
     "tqdm",
     "python-box",

{tilegrab-1.1.0 → tilegrab-1.2.0b1}/src/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-1.1.0 → tilegrab-1.2.0b1}/src/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-1.1.0 → tilegrab-1.2.0b1}/src/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-1.1.0 → tilegrab-1.2.0b1}/src/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-1.2.0b1/src/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,
+    )