viewtif 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

viewtif/tif_viewer.py

@@ -1,14 +1,16 @@
 #!/usr/bin/env python3
 """
-TIFF Viewer (PySide6) — view GeoTIFF, NetCDF, and HDF datasets with shapefile overlays.
+TIFF Viewer (PySide6) – view GeoTIFF, NetCDF, HDF, and File Geodatabase with vector overlays.
 
 Features:
 - Open GeoTIFFs (single or multi-band)
 - Combine separate single-band TIFFs into RGB
 - Apply global 2–98% stretch for RGB
 - Display NetCDF/HDF subsets with consistent scaling
-- Overlay shapefiles automatically reprojected to raster CRS
+- Identify and display raster from File Geodatabase if any
+- Overlay vector files automatically reprojected to raster CRS
 - Navigate bands/time steps interactively
+- Remote file support: open files directly from HTTP/HTTPS URLs, S3, Google Cloud Storage, and Azure Blob Storage.
 
 Controls
   + / - : zoom in/out
@@ -16,7 +18,8 @@ Controls
   C / V : increase/decrease contrast (works in RGB and single-band)
   G / H : increase/decrease gamma    (works in RGB and single-band)
   M     : toggle colormap. Single-band: viridis/magma. NetCDF: RdBu_r/viridis/magma.
-  [ / ] : previous / next band (or time step) (single-band)
+  [ / ] : previous / next band (or time step)
+  B     : toggle basemap (Natural Earth country boundaries)
   R     : reset view
 
 Examples
@@ -28,8 +31,6 @@ Examples
 import sys
 import os
 import numpy as np
-import rasterio
-from rasterio.transform import Affine
 from PySide6.QtWidgets import (
     QApplication, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, 
     QScrollBar, QGraphicsPathItem, QVBoxLayout, QWidget, QStatusBar
@@ -37,42 +38,85 @@ from PySide6.QtWidgets import (
 from PySide6.QtGui import QImage, QPixmap, QPainter, QPen, QColor, QPainterPath
 from PySide6.QtCore import Qt
 
-import matplotlib.cm as cm
-import warnings
-warnings.filterwarnings("ignore", category=RuntimeWarning, module="shapely")
-warnings.filterwarnings("ignore", category=UserWarning, module="rasterio")
-warnings.filterwarnings("ignore", category=UserWarning, module="xarray")
-
-__version__ = "0.2.6"
+__version__ = "0.2.7"
+
+# Lazy-loaded heavy imports
+_rasterio = None
+_cm = None
+_gpd = None
+_shapely_geoms = None
+
+def _get_rasterio():
+    """Lazy-load rasterio (slow: ~0.5-1s)"""
+    global _rasterio
+    if _rasterio is None:
+        import rasterio
+        from rasterio.transform import Affine
+        import warnings
+        warnings.filterwarnings("ignore", category=UserWarning, module="rasterio")
+        warnings.filterwarnings("ignore", category=FutureWarning, module="osgeo")
+        _rasterio = rasterio
+        # Store Affine in the module for easy access
+        _rasterio.Affine = Affine
+    return _rasterio
+
+def _get_matplotlib_cm():
+    """Lazy-load matplotlib colormap (slow: ~0.3-0.5s)"""
+    global _cm
+    if _cm is None:
+        import matplotlib.cm as cm
+        _cm = cm
+    return _cm
+
+def _get_geopandas():
+    """Lazy-load geopandas (slow: ~1-2s)"""
+    global _gpd, _shapely_geoms
+    if _gpd is None:
+        try:
+            import geopandas as gpd
+            from shapely.geometry import (
+                LineString, MultiLineString, Polygon, MultiPolygon,
+                GeometryCollection, Point, MultiPoint
+            )
+            import warnings
+            warnings.filterwarnings("ignore", category=RuntimeWarning, module="shapely")
+            _gpd = gpd
+            _shapely_geoms = {
+                'LineString': LineString,
+                'MultiLineString': MultiLineString,
+                'Polygon': Polygon,
+                'MultiPolygon': MultiPolygon,
+                'GeometryCollection': GeometryCollection,
+                'Point': Point,
+                'MultiPoint': MultiPoint
+            }
+        except ImportError:
+            _gpd = None
+            _shapely_geoms = None
+    return _gpd, _shapely_geoms
 
-# Optional overlay deps
+# Check availability without importing
+HAVE_GEO = True  # Assume available, will be set False if import fails
 try:
-    import geopandas as gpd
-    from shapely.geometry import (
-        LineString, MultiLineString, Polygon, MultiPolygon,
-        GeometryCollection, Point, MultiPoint
-    )
-    HAVE_GEO = True
+    import importlib.util
+    HAVE_CARTOPY = importlib.util.find_spec("cartopy") is not None
 except Exception:
-    HAVE_GEO = False
+    HAVE_CARTOPY = False
 
 # Optional NetCDF deps (lazy-loaded when needed)
 HAVE_NETCDF = False
 xr = None
 pd = None
 
-# Optional cartopy deps for better map visualization (lazy-loaded when needed)
-# Check if cartopy is available but don't import yet
-try:
-    import importlib.util
-    HAVE_CARTOPY = importlib.util.find_spec("cartopy") is not None
-except Exception:
-    HAVE_CARTOPY = False
-
 def warn_if_large(tif_path, scale=1):
     """Warn and confirm before loading very large rasters (GeoTIFF, GDB, or HDF).    
     Uses GDAL if available, falls back to rasterio for standard formats.
     """
+    # Skip size check for URLs, S3, and remote paths (can't reliably check remote file size)
+    if tif_path and tif_path.startswith(("http://", "https://", "s3://", "/vsi")):
+        return
+    
+    rasterio = _get_rasterio()
     import os
     width = height = None
     size_mb = None
@@ -80,7 +124,6 @@ def warn_if_large(tif_path, scale=1):
     if tif_path and os.path.dirname(tif_path).endswith(".gdb"):
         tif_path = f"OpenFileGDB:{os.path.dirname(tif_path)}:{os.path.basename(tif_path)}"
 
-
     try:
         width, height = None, None
         
@@ -118,6 +161,7 @@ def warn_if_large(tif_path, scale=1):
                 if ans not in ("y", "yes"):
                     print("Cancelled.")
                     sys.exit(0)
+
     except Exception as e:
         print(f"[INFO] Could not pre-check raster size: {e}")
 
@@ -161,19 +205,20 @@ class RasterView(QGraphicsView):
 class TiffViewer(QMainWindow):
     def __init__(
         self,
-        tif_path: str | None,
-        scale: int = 1,
-        band: int = 1,
-        rgb: list[int] | None = None,
-        rgbfiles: list[str] | None = None,
-        shapefiles: list[str] | None = None,
-        shp_color: str = "cyan",
-        shp_width: float = 2,
-        subset: int | None = None,
-        vmin: float | None = None,
-        vmax: float | None = None,
-        cartopy: str = "on",
-        timestep: int | None = None,
+        tif_path,
+        scale=1,
+        band=1,
+        rgb=None,
+        rgbfiles=None,
+        shapefiles=None,
+        shp_color="cyan",
+        shp_width=2,
+        subset=None,
+        vmin=None,
+        vmax=None,
+        cartopy="on",
+        timestep=None,
+        nodata=None, 
     ):
         super().__init__()
 
@@ -185,13 +230,37 @@ class TiffViewer(QMainWindow):
         self._user_vmin = vmin
         self._user_vmax = vmax
         self.cartopy_mode = cartopy.lower()
+        self._nodata = nodata
 
         if not tif_path and not rgbfiles:
            print("Usage: viewtif <file.tif>")
            sys.exit(1)
 
+        # Check if file exists (skip for URLs)
+        if tif_path and not tif_path.startswith(("http://", "https://", "s3://", "/vsi")):
+            # Extract actual file path from GDAL format strings
+            check_path = tif_path
+            if tif_path.startswith("OpenFileGDB:"):
+                # OpenFileGDB:path.gdb:layer -> path.gdb
+                parts = tif_path.split(":")
+                if len(parts) >= 2:
+                    check_path = parts[1]
+            elif tif_path.startswith(("HDF4_EOS:", "HDF5:")):
+                # HDF format strings - extract file path
+                parts = tif_path.split(":")
+                if len(parts) >= 2:
+                    check_path = parts[1]
+            
+            if not os.path.exists(check_path):
+                print(f"[ERROR] File not found: {check_path}")
+                sys.exit(1)
+
+        # Load rasterio early since we'll need it
+        rasterio = _get_rasterio()
+        Affine = rasterio.Affine
+
         self._scale_arg = max(1, int(scale or 1))
-        self._transform: Affine | None = None
+        self._transform = None
         self._crs = None
 
         # Overlay config/state
@@ -199,12 +268,21 @@ class TiffViewer(QMainWindow):
         self._shp_color = shp_color
         self._shp_width = float(shp_width)
         self._overlay_items: list[QGraphicsPathItem] = []
+        
+        # Basemap state
+        self.base_gdf = None
+        self.basemap_items: list[QGraphicsPathItem] = []
 
         # --- Load data ---
         if rgbfiles:
+            # Check if all RGB files exist (skip for remote paths)
+            for f in rgbfiles:
+                if not f.startswith(("http://", "https://", "s3://", "/vsi")) and not os.path.exists(f):
+                    print(f"[ERROR] File not found: {f}")
+                    sys.exit(1)
+            
             red, green, blue = rgbfiles
-            import rasterio as rio_module
-            with rio_module.open(red) as r, rio_module.open(green) as g, rio_module.open(blue) as b:
+            with rasterio.open(red) as r, rasterio.open(green) as g, rasterio.open(blue) as b:
                 if (r.width, r.height) != (g.width, g.height) or (r.width, r.height) != (b.width, b.height):
                     raise ValueError("All RGB files must have the same dimensions.")
                 arr = np.stack([
@@ -212,13 +290,19 @@ class TiffViewer(QMainWindow):
                     g.read(1, out_shape=(g.height // self._scale_arg, g.width // self._scale_arg)),
                     b.read(1, out_shape=(b.height // self._scale_arg, b.width // self._scale_arg))
                 ], axis=-1).astype(np.float32)
+
+                # Apply nodata mask if specified
+                if self._nodata is not None:
+                    arr = np.where(arr == self._nodata, np.nan, arr)
+
                 self._transform = r.transform
                 self._crs = r.crs
 
             self.data = arr
             self.band_count = 3
-            self.rgb = [os.path.basename(red), os.path.basename(green), os.path.basename(blue)]
-            self.tif_path = self.tif_path or (os.path.commonprefix([red, green, blue]) or red)
+            # Extract filenames from paths (works for both local and remote)
+            self.rgb = [f.split('/')[-1] for f in [red, green, blue]]
+            self.tif_path = self.tif_path or red
 
         elif tif_path:
 
@@ -260,6 +344,8 @@ class TiffViewer(QMainWindow):
             if tif_path.lower().endswith((".nc", ".netcdf")):
                     try:
                         import xarray as xr
+                        import warnings
+                        warnings.filterwarnings("ignore", category=xr.SerializationWarning)
                     except ModuleNotFoundError:
                         print("NetCDF support requires extra dependencies.")
                         print("Install them with: pip install viewtif[netcdf]")
@@ -275,8 +361,12 @@ class TiffViewer(QMainWindow):
                     # Auto-select the first variable if there's only one and no subset specified
                     if len(data_vars) == 1 and subset is None:
                         subset = 0
-                    # Only list variables if --subset not given and multiple variables exist
+                    # List variables if --subset not given and multiple variables exist
                     elif subset is None:
+                        print(f"Found {len(data_vars)} variables in {os.path.basename(tif_path)}:")
+                        for i, var in enumerate(data_vars):
+                            print(f"[{i}] {var}")
+                        print("\nUse --subset N to open a specific variable.")
                         sys.exit(0)
                     
                     # Validate subset index
@@ -333,6 +423,24 @@ class TiffViewer(QMainWindow):
                     arr = var_data.values.astype(np.float32)
                     arr = np.squeeze(arr)
 
+                    # Check if variable has unsupported dimensions (e.g., vertical levels)
+                    spatial_dims = ['lat', 'lon', 'latitude', 'longitude', 'y', 'x']
+                    time_dims = ['time']
+
+                    # Count spatial and time dimensions
+                    spatial_count = sum(1 for d in var_data.dims if d in spatial_dims)
+                    time_count = sum(1 for d in var_data.dims if d in time_dims)
+                    total_dims = len(var_data.dims)
+
+                    # Valid: 2 spatial dims, or 1 time + 2 spatial dims
+                    is_valid = (total_dims == 2 and spatial_count == 2) or \
+                               (total_dims == 3 and time_count == 1 and spatial_count == 2)
+
+                    if not is_valid:
+                        print(f"[ERROR] Variable has unsupported dimensions: {list(var_data.dims)}")
+                        print(f"[INFO] viewtif only supports 2D (lat, lon) or 3D (time, lat, lon) NetCDF data")
+                        sys.exit(1)
+
                     # --------------------------------------------------------
                     # Apply timestep jump after base array is created
                     # --------------------------------------------------------
@@ -359,7 +467,6 @@ class TiffViewer(QMainWindow):
 
                     if "crs" in ds.variables:
                         try:
-                            import rasterio.crs
                             crs_var = ds.variables["crs"]
                             if hasattr(crs_var, "spatial_ref"):
                                 self._crs = rasterio.crs.CRS.from_wkt(crs_var.spatial_ref)
@@ -413,6 +520,21 @@ class TiffViewer(QMainWindow):
                     arr = sub_ds.ReadAsArray().astype(np.float32)
                     arr = np.squeeze(arr)
 
+                    # -------------------------------
+                    # Apply nodata masking (HDF)
+                    # -------------------------------
+                    if self._nodata is not None:
+                        arr[arr == self._nodata] = np.nan
+
+                    # Try dataset-provided nodata as well
+                    try:
+                        band = sub_ds.GetRasterBand(1)
+                        ds_nodata = band.GetNoDataValue()
+                        if ds_nodata is not None:
+                            arr[arr == ds_nodata] = np.nan
+                    except Exception:
+                        pass
+
                     if arr.ndim == 3:
                         # Convert from (bands, rows, cols) → (rows, cols, bands)
                         arr = np.transpose(arr, (1, 2, 0))
@@ -457,8 +579,7 @@ class TiffViewer(QMainWindow):
             # Regular TIFF
             # ---------------------------------------------------------------
             else:
-                import rasterio as rio_module
-                with rio_module.open(tif_path) as src:
+                with rasterio.open(tif_path) as src:
                     self._transform = src.transform
                     self._crs = src.crs
 
@@ -469,9 +590,16 @@ class TiffViewer(QMainWindow):
                         ]
                         
                         arr = np.stack(bands, axis=-1).astype(np.float32)
+                        
+                        # Apply user-specified nodata first
+                        if self._nodata is not None:
+                            arr[arr == self._nodata] = np.nan
+                        
+                        # Then apply file's nodata if present
                         nd = src.nodata
                         if nd is not None:
                             arr[arr == nd] = np.nan
+                        
                         self.data = arr
                         self.band_count = 3
                     else:
@@ -479,10 +607,18 @@ class TiffViewer(QMainWindow):
                             self.band,
                             out_shape=(src.height // self._scale_arg, src.width // self._scale_arg)
                         ).astype(np.float32)
+
+                        # Apply user-specified nodata first
+                        if self._nodata is not None:
+                            arr[arr == self._nodata] = np.nan
+
+                        # Then apply file's nodata if present
                         nd = src.nodata
                         if nd is not None:
                             arr[arr == nd] = np.nan
+
                         self.data = arr
+
                         self.band_count = src.count
 
                         if self.band_count == 1:
@@ -500,6 +636,7 @@ class TiffViewer(QMainWindow):
                             else:
                                 raise ValueError("No stats in file")
                         except Exception:
+                            # Always calculate from masked array for consistency
                             self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
                             if getattr(self, "_scale_arg", 1) > 1:
                                 print(f"[INFO] Value range (scaled): {self.vmin:.3f} -> {self.vmax:.3f}")
@@ -538,6 +675,7 @@ class TiffViewer(QMainWindow):
         
         # Status bar
         self.setStatusBar(QStatusBar())
+        self.statusBar().showMessage("Keys: +/- zoom | C/V contrast | G/H gamma | M colormap | [/] bands or timestep | B basemap | R reset")
         
         # Set central widget
         self.setCentralWidget(self.main_widget)
@@ -587,7 +725,7 @@ class TiffViewer(QMainWindow):
         #     self.view.centerOn(self.pixmap_item)
 
     # ---------------------------- Overlays ---------------------------- #
-    def _geo_to_pixel(self, x: float, y: float):
+    def _geo_to_pixel(self, x, y):
         """Map coords (raster CRS) -> image pixel coords (after downsampling)."""
         if self._transform is None:
             return None
@@ -595,11 +733,23 @@ class TiffViewer(QMainWindow):
         col, row = inv * (x, y)
         return (col / self._scale_arg, row / self._scale_arg)
 
-    def _geom_to_qpath(self, geom) -> QPainterPath | None:
+    def _geom_to_qpath(self, geom):
         """
         Convert shapely geom (in raster CRS) to QPainterPath in *image pixel* coords.
         Z/M tolerant: only X,Y are used. Draws Points as tiny segments.
         """
+        _, shapely_geoms = _get_geopandas()
+        if shapely_geoms is None:
+            return None
+        
+        LineString = shapely_geoms['LineString']
+        MultiLineString = shapely_geoms['MultiLineString']
+        Polygon = shapely_geoms['Polygon']
+        MultiPolygon = shapely_geoms['MultiPolygon']
+        GeometryCollection = shapely_geoms['GeometryCollection']
+        Point = shapely_geoms['Point']
+        MultiPoint = shapely_geoms['MultiPoint']
+        
         def _coords_to_path(coords, path: QPainterPath):
             first = True
             for c in coords:
@@ -668,8 +818,13 @@ class TiffViewer(QMainWindow):
         return None
 
     def _add_shapefile_overlays(self):
-        if not HAVE_GEO:
-            print("[WARN] geopandas/shapely not available; --shapefile ignored.")
+        gpd, _ = _get_geopandas() 
+        if gpd is None:
+            global HAVE_GEO
+            HAVE_GEO = False
+            print("[WARN] --shapefile requires geopandas and shapely.")
+            print("       Install them with: pip install viewtif[geo]")
+            print("       Proceeding without shapefile overlay.")
             return
         if self._crs is None or self._transform is None:
             print("[WARN] raster lacks CRS/transform; cannot place overlays.")
@@ -680,8 +835,12 @@ class TiffViewer(QMainWindow):
         pen.setCosmetic(True)  # constant on-screen width
 
         for shp_path in self._shapefiles:
+            if not os.path.exists(shp_path):
+                print(f"[WARN] File not found: {shp_path}")
+                continue
             try:
                 gdf = gpd.read_file(shp_path)
+
                 if gdf.empty:
                     continue
 
@@ -706,6 +865,206 @@ class TiffViewer(QMainWindow):
             except Exception as e:
                 print(f"[WARN] Failed to draw overlay {os.path.basename(shp_path)}: {e}")
 
+    # ---------------------------- Basemap ---------------------------- #
+    def _load_basemap(self):
+        """Load Natural Earth basemap with timeout to avoid blocking."""
+        gpd, _ = _get_geopandas()
+        if gpd is None:
+            print("[WARN] geopandas not available; cannot load basemap.")
+            return
+        
+        # Basemap not supported for NetCDF files
+        if hasattr(self, "_nc_var_name"):
+            print("[INFO] Basemap not supported for NetCDF files (cartopy used).")
+            return
+        
+        if self._crs is None:
+            print("[WARN] Raster lacks CRS; cannot load basemap.")
+            return
+        
+        # Get CRS info
+        crs_string = str(self._crs).upper()
+        
+        # Try to get EPSG code
+        crs_code = None
+        try:
+            crs_code = self._crs.to_epsg()
+        except Exception:
+            pass
+        
+        if crs_code is None:
+            import re
+            epsg_match = re.search(r'EPSG:(\d+)', crs_string)
+            if epsg_match:
+                crs_code = int(epsg_match.group(1))
+        
+        # Block UTM zones (known to cause artifacts)
+        if crs_code and (32600 <= crs_code <= 32660 or 32700 <= crs_code <= 32760):
+            self._show_disabled_message(crs_code)
+            self.base_gdf = None
+            return
+        
+        # Check if suitable for basemap
+        is_geographic = False
+        try:
+            is_geographic = self._crs.is_geographic
+        except Exception:
+            is_geographic = 'GEOGCS' in crs_string or 'GEOG' in crs_string
+        
+        # Good projected CRS
+        good_crs = [4326, 3857, 3395, 4269, 4267]
+        is_approved = crs_code in good_crs if crs_code else False
+        
+        # Equal-area projections (work well with basemap)
+        equal_area_keywords = ['ALBERS', 'EQUAL_AREA', 'LAMBERT_AZIMUTHAL_EQUAL_AREA']
+        is_equal_area = any(kw in crs_string for kw in equal_area_keywords)
+        
+        # Allow if: geographic OR approved OR equal-area
+        if not (is_geographic or is_approved or is_equal_area):
+            self._show_disabled_message(crs_code)
+            self.base_gdf = None
+            return
+        
+        # Load basemap
+        import requests
+        from io import BytesIO
+        
+        url = "https://naturalearth.s3.amazonaws.com/110m_cultural/ne_110m_admin_0_countries.zip"
+        print("[INFO] Loading basemap (timeout 3s)...")
+        
+        try:
+            resp = requests.get(url, timeout=3)
+            resp.raise_for_status()
+        except requests.exceptions.Timeout:
+            print("[WARN] Basemap download timed out (slow connection).")
+            self.base_gdf = None
+            return
+        except requests.exceptions.ConnectionError:
+            print("[WARN] Basemap not loaded (no internet connection).")
+            self.base_gdf = None
+            return
+        except Exception as e:
+            print(f"[WARN] Basemap download failed: {e}")
+            self.base_gdf = None
+            return
+        
+        try:
+            zip_bytes = BytesIO(resp.content)
+            gdf = gpd.read_file(zip_bytes)
+            
+            # Reproject to raster CRS
+            if gdf.crs != self._crs:
+                gdf = gdf.to_crs(self._crs)
+            
+            self.base_gdf = gdf
+            # print("[INFO] Basemap loaded successfully")
+            
+        except Exception as e:
+            print(f"[WARN] Basemap processing failed: {e}")
+            self.base_gdf = None
+            return
+    
+    def _show_disabled_message(self, crs_code):
+        """Show location info when basemap is disabled."""
+        rasterio = _get_rasterio()
+        try:
+            if self._transform is not None:
+                h, w = self.data.shape[:2] if self.data.ndim == 2 else self.data.shape[:2]
+                from rasterio.warp import transform_bounds
+                west, south, east, north = transform_bounds(
+                    self._crs, 'EPSG:4326',
+                    self._transform.c,
+                    self._transform.f + self._transform.e * h,
+                    self._transform.c + self._transform.a * w,
+                    self._transform.f
+                )
+                center_lon = (west + east) / 2
+                center_lat = (south + north) / 2
+                
+                # Get continent info
+                continent_info = ""
+                country_info = ""
+                try:
+                    import requests
+                    from io import BytesIO
+                    gpd, shapely_geoms = _get_geopandas()
+                    if gpd is None or shapely_geoms is None:
+                        raise ImportError("geopandas/shapely not available")
+                    Point = shapely_geoms['Point']
+                    
+                    url = "https://naturalearth.s3.amazonaws.com/110m_cultural/ne_110m_admin_0_countries.zip"
+                    resp = requests.get(url, timeout=3)
+                    resp.raise_for_status()
+                    
+                    zip_bytes = BytesIO(resp.content)
+                    gdf = gpd.read_file(zip_bytes)
+                    center_point = Point(center_lon, center_lat)
+                    
+                    if 'CONTINENT' in gdf.columns:
+                        containing = gdf[gdf.contains(center_point)]
+                        if not containing.empty:
+                            continent_info = containing.iloc[0]['CONTINENT']
+                            country_info = containing.iloc[0].get('NAME', 'unknown')
+                        else:
+                            import warnings
+                            warnings.filterwarnings("ignore", message="Geometry is in a geographic CRS")
+                            gdf['dist'] = gdf.distance(center_point)
+                            nearest = gdf.loc[gdf['dist'].idxmin()]
+                            continent_info = nearest['CONTINENT']
+                            country_info = f"near {nearest.get('NAME', 'unknown')}"
+                except Exception:
+                    pass
+                
+                if continent_info and country_info:
+                    print(f"[INFO] Location: {continent_info}, {country_info} ({center_lat:.4f}°, {center_lon:.4f}°)")
+                else:
+                    print(f"[INFO] Location: {center_lat:.4f}°, {center_lon:.4f}°")
+                print(f"[INFO] Basemap disabled for this projection (CRS: {crs_code or 'unknown'})")
+                print("[INFO] Add your own boundaries with --shapefile <vector_file>")
+        except Exception:
+            print(f"[INFO] Basemap disabled for this projection (CRS: {crs_code or 'unknown'})")
+            print("[INFO] Add your own boundaries with --shapefile <vector_file>")
+
+    def _draw_basemap(self):
+        """Draw basemap using the loaded Natural Earth data."""
+        if self.base_gdf is None:
+            return
+        
+        # Determine pen color based on theme
+        palette = QApplication.palette()
+        bg = palette.window().color()
+        brightness = (bg.red() * 299 + bg.green() * 587 + bg.blue() * 114) / 1000
+        pen = QPen(QColor(255, 255, 255) if brightness < 128 else QColor(80, 80, 80))
+        pen.setWidthF(0.5)
+        pen.setCosmetic(True)
+        
+        # Clear existing basemap items
+        for it in self.basemap_items:
+            self.scene.removeItem(it)
+        self.basemap_items.clear()
+        
+        # Draw each geometry using pixel transformation
+        for geom in self.base_gdf.geometry:
+            if geom is None or geom.is_empty:
+                continue
+            
+            # Fix invalid geometries after reprojection
+            if not geom.is_valid:
+                try:
+                    geom = geom.buffer(0)
+                except Exception:
+                    continue
+            
+            qpath = self._geom_to_qpath(geom)
+            if qpath is None or qpath.isEmpty():
+                continue
+            
+            item = QGraphicsPathItem(qpath)
+            item.setPen(pen)
+            item.setZValue(-100)  # Draw behind raster
+            self.scene.addItem(item)
+            self.basemap_items.append(item)
+
     # ----------------------- Title / Rendering ----------------------- #
     def update_title(self):
         """Add band before the title."""
@@ -852,6 +1211,11 @@ class TiffViewer(QMainWindow):
         return time_str
 
     def _render_rgb(self):
+        import warnings
+        warnings.filterwarnings("ignore", message="invalid value encountered in cast")
+
+        cm = _get_matplotlib_cm()
+        
         if self.rgb_mode:
             arr = self.data
             finite = np.isfinite(arr)
@@ -880,11 +1244,18 @@ class TiffViewer(QMainWindow):
 
     def _render_cartopy_map(self, data):
         """ Use cartopy for better visualization"""
+        import warnings
+        warnings.filterwarnings("ignore", category=RuntimeWarning, module="shapely")
+        warnings.filterwarnings("ignore", message="invalid value encountered in create_collection")
+        warnings.filterwarnings("ignore", message="All-NaN slice encountered")
+
         import matplotlib.pyplot as plt
         from matplotlib.backends.backend_agg import FigureCanvasAgg
         import cartopy.crs as ccrs
         import cartopy.feature as cfeature
         
+        cm = _get_matplotlib_cm()
+        
         # Create a new figure with cartopy projection
         fig = plt.figure(figsize=(12, 8), dpi=100)
         ax = plt.axes(projection=ccrs.PlateCarree())
@@ -902,7 +1273,13 @@ class TiffViewer(QMainWindow):
         # Apply contrast and gamma adjustments
         finite = np.isfinite(data)
         norm_data = np.zeros_like(data, dtype=np.float32)
-        vmin, vmax = np.nanmin(data), np.nanmax(data)
+        
+        # Check if we have any valid data
+        if not np.any(finite):
+            vmin, vmax = 0, 1  # Use dummy values for all-NaN data
+        else:
+            vmin, vmax = np.nanmin(data), np.nanmax(data)
+        
         rng = max(vmax - vmin, 1e-12)
         
         if np.any(finite):
@@ -1053,26 +1430,44 @@ class TiffViewer(QMainWindow):
             rgb = self._render_cartopy_map(a)
         elif rgb is None:
             # Standard grayscale rendering for single-band data
+            cm = _get_matplotlib_cm()
             finite = np.isfinite(a)
 
-            # Respect user-specified limits
-            vmin = self._user_vmin if self._user_vmin is not None else np.nanmin(a)
-            vmax = self._user_vmax if self._user_vmax is not None else np.nanmax(a)
-            
-            rng = max(vmax - vmin, 1e-12)
+            # Check if we have any valid data
+            if not np.any(finite):
+                vmin = vmax = 0
+                rng = 1e-12
+                norm = np.zeros_like(a, dtype=np.float32)
+            else:
+                # Respect user-specified limits or calculate from valid pixels only
+                if self._user_vmin is not None:
+                    vmin = self._user_vmin
+                else:
+                    valid_pixels = a[finite]
+                    vmin = np.percentile(valid_pixels, 2)  # 2nd percentile
+                
+                if self._user_vmax is not None:
+                    vmax = self._user_vmax
+                else:
+                    valid_pixels = a[finite]
+                    vmax = np.percentile(valid_pixels, 98)  # 98th percentile
+                
+                rng = max(vmax - vmin, 1e-12)
 
-            norm = np.zeros_like(a, dtype=np.float32)
-            if np.any(finite):
-                norm[finite] = (a[finite] - vmin) / rng
-            norm = np.clip(norm, 0, 1)
-            norm = np.power(norm * self.contrast, self.gamma)
+                norm = np.zeros_like(a, dtype=np.float32)
+                if np.any(finite):
+                    norm[finite] = (a[finite] - vmin) / rng
+                norm = np.clip(norm, 0, 1)
+                norm = np.power(norm * self.contrast, self.gamma)
+            
             cmap = getattr(cm, self.cmap_name, cm.viridis)
             rgb = (cmap(norm)[..., :3] * 255).astype(np.uint8)
         else:
             # True RGB mode (unchanged)
             rgb = self._render_rgb()
 
-        h, w, _ = rgb.shape
+
+        h, w = rgb.shape[:2]  # for both 2D and 3D
         self._last_rgb = rgb
 
         qimg = QImage(rgb.data, w, h, 3 * w, QImage.Format.Format_RGB888)
@@ -1085,27 +1480,33 @@ class TiffViewer(QMainWindow):
             self.scene.addItem(self.pixmap_item)
         else:
             self.pixmap_item.setPixmap(pix)
-
     # ----------------------- Single-band switching ------------------- #
     def load_band(self, band_num: int):
         if self.rgb_mode:
             return
 
+        rasterio = _get_rasterio()
         tif_path = self.tif_path
       
         if tif_path and os.path.dirname(self.tif_path).endswith(".gdb"):
             tif_path = f"OpenFileGDB:{os.path.dirname(self.tif_path)}:{os.path.basename(self.tif_path)}"
 
-        import rasterio as rio_module
-        with rio_module.open(tif_path) as src:
+        with rasterio.open(tif_path) as src:
             self.band = band_num
             arr = src.read(self.band).astype(np.float32)
+
+            # Apply user-specified nodata first
+            if self._nodata is not None:
+                arr[arr == self._nodata] = np.nan
+            
+            # Then apply file's nodata if present
             nd = src.nodata
             if nd is not None:
                 arr[arr == nd] = np.nan
             self.data = arr
-            
+
             self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
+            print(f"[INFO] Value range: {self.vmin:.3f} -> {self.vmax:.3f}")
         self.update_pixmap()
         self.update_title()
 
@@ -1129,15 +1530,31 @@ class TiffViewer(QMainWindow):
         elif k in (Qt.Key.Key_Down, Qt.Key.Key_S):
             vsb.setValue(vsb.value() + self.pan_step)
 
-        # Contrast / Gamma now work in both modes
+        # Contrast / Gamma
         elif k == Qt.Key.Key_C:
-            self.contrast *= 1.1; self.update_pixmap()
+            if hasattr(self, "_nc_var_name") and self.cartopy_mode == "on" and getattr(self, "_use_cartopy", False):
+                print("[INFO] Contrast adjustment disabled with cartopy rendering")
+                print("[INFO] Use --vmin/--vmax flags, or reopen with --cartopy off")
+            else:
+                self.contrast *= 1.1; self.update_pixmap()
         elif k == Qt.Key.Key_V:
-            self.contrast /= 1.1; self.update_pixmap()
+            if hasattr(self, "_nc_var_name") and self.cartopy_mode == "on" and getattr(self, "_use_cartopy", False):
+                print("[INFO] Contrast adjustment disabled with cartopy rendering")
+                print("[INFO] Use --vmin/--vmax flags, or reopen with --cartopy off")
+            else:
+                self.contrast /= 1.1; self.update_pixmap()
         elif k == Qt.Key.Key_G:
-            self.gamma *= 1.1; self.update_pixmap()
+            if hasattr(self, "_nc_var_name") and self.cartopy_mode == "on" and getattr(self, "_use_cartopy", False):
+                print("[INFO] Gamma adjustment disabled with cartopy rendering")
+                print("[INFO] Use --vmin/--vmax flags, or reopen with --cartopy off")
+            else:
+                self.gamma *= 1.1; self.update_pixmap()
         elif k == Qt.Key.Key_H:
-            self.gamma /= 1.1; self.update_pixmap()
+            if hasattr(self, "_nc_var_name") and self.cartopy_mode == "on" and getattr(self, "_use_cartopy", False):
+                print("[INFO] Gamma adjustment disabled with cartopy rendering")
+                print("[INFO] Use --vmin/--vmax flags, or reopen with --cartopy off")
+            else:
+                self.gamma /= 1.1; self.update_pixmap()
 
         # Colormap toggle (single-band only)
         elif not self.rgb_mode and k == Qt.Key.Key_M:
@@ -1157,8 +1574,15 @@ class TiffViewer(QMainWindow):
             if hasattr(self, "band_index"):  # HDF/NetCDF mode
                 self.band_index = (self.band_index + 1) % self.band_count
                 self.data = self.get_current_frame()
+                
+                # Recalculate and print value range for new band
+                if self._user_vmin is None and self._user_vmax is None:
+                    self.vmin, self.vmax = np.nanmin(self.data), np.nanmax(self.data)
+                    print(f"[INFO] Value range: {self.vmin:.3f} -> {self.vmax:.3f}")
+                
                 self.update_pixmap()
                 self.update_title()
+
             elif not self.rgb_mode:  # GeoTIFF single-band mode
                 new_band = self.band + 1 if self.band < self.band_count else 1
                 self.load_band(new_band)
@@ -1167,28 +1591,37 @@ class TiffViewer(QMainWindow):
             if hasattr(self, "band_index"):  # HDF/NetCDF mode
                 self.band_index = (self.band_index - 1) % self.band_count
                 self.data = self.get_current_frame()
+                
+                # Recalculate and print value range for new band
+                if self._user_vmin is None and self._user_vmax is None:
+                    self.vmin, self.vmax = np.nanmin(self.data), np.nanmax(self.data)
+                    print(f"[INFO] Value range: {self.vmin:.3f} -> {self.vmax:.3f}")
+                
                 self.update_pixmap()
                 self.update_title()
+
             elif not self.rgb_mode:  # GeoTIFF single-band mode
                 new_band = self.band - 1 if self.band > 1 else self.band_count
                 self.load_band(new_band)
                 
-        # NetCDF time/dimension navigation with Page Up/Down
-        elif k == Qt.Key.Key_PageUp:
-            if hasattr(self, '_has_time_dim') and self._has_time_dim:
-                try:
-                    # Call the next_time_step method
-                    self.next_time_step()
-                except Exception as e:
-                    print(f"Error handling PageUp: {e}")
+        # Basemap toggle
+        elif k == Qt.Key.Key_B:
+            if self.basemap_items:
+                # Basemap currently visible
+                for it in self.basemap_items:
+                    self.scene.removeItem(it)
+                self.basemap_items.clear()
+                print("[INFO] Basemap removed")
+            else:
+                # Basemap not visible - load and display it
+                if self.base_gdf is None:
+                    self._load_basemap()
                 
-        elif k == Qt.Key.Key_PageDown:
-            if hasattr(self, '_has_time_dim') and self._has_time_dim:
-                try:
-                    # Call the prev_time_step method
-                    self.prev_time_step()
-                except Exception as e:
-                    print(f"Error handling PageDown: {e}")
+                if self.base_gdf is not None:
+                    self._draw_basemap()
+                    print("[INFO] Basemap displayed")
+                # else:
+                #     print("[INFO] Basemap not available")
 
         elif k == Qt.Key.Key_R:
             self.contrast = 1.0
@@ -1214,7 +1647,8 @@ def run_viewer(
     vmin=None,
     vmax=None,
     cartopy="on",
-    timestep=None
+    timestep=None,
+    nodata=None,
 ):
 
     """Launch the TiffViewer app"""
@@ -1233,6 +1667,7 @@ def run_viewer(
         vmax=vmax,
         cartopy=cartopy,
         timestep=timestep,
+        nodata=nodata,
     )
     win.show()
     sys.exit(app.exec())
@@ -1243,12 +1678,12 @@ import click
 @click.version_option(__version__, prog_name="viewtif")
 @click.argument("tif_path", required=False)
 @click.option("--band", default=1, show_default=True, type=int, help="Band number to display")
-@click.option("--scale", default=1.0, show_default=True, type=int, help="Scale factor for display")
+@click.option("--scale", default=1, show_default=True, type=int, help="Downsample by factor N (e.g., --scale 5 loads 1/25 of pixels)")
 @click.option("--rgb", nargs=3, type=int, help="Three band numbers for RGB, e.g. --rgb 4 3 2")
 @click.option("--rgbfiles", nargs=3, type=str, help="Three single-band TIFFs for RGB, e.g. --rgbfiles B4.tif B3.tif B2.tif")
-@click.option("--shapefile", multiple=True, type=str, help="One or more shapefiles to overlay")
-@click.option("--shp-color", default="cyan", show_default=True, help="Overlay color (name or #RRGGBB).")
-@click.option("--shp-width", default=1.0, show_default=True, type=float, help="Overlay line width (screen pixels).")
+@click.option("--shapefile", multiple=True, type=str, help="Vector overlay file(s) (shapefile, GeoJSON, etc.)")
+@click.option("--shp-color", default="cyan", show_default=True, help="Vector overlay color (name or #RRGGBB).")
+@click.option("--shp-width", default=1.0, show_default=True, type=float, help="Vector overlay line width (screen pixels).")
 @click.option("--subset", default=None, type=int, help="Open specific subdataset index in .hdf/.h5 file or variable in NetCDF file")
 @click.option("--vmin", type=float, default=None, help="Manual minimum display value")
 @click.option("--vmax", type=float, default=None, help="Manual maximum display value")
@@ -1265,9 +1700,14 @@ import click
     show_default=True,
     help="Use cartopy for NetCDF geospatial rendering."
 )
+@click.option(
+    "--qgis",
+    is_flag=True,
+    help="Open in QGIS directly (skips viewer)"
+)
+@click.option("--nodata", type=float, default=None, help="Nodata value to mask (e.g., -9999)")
 
-
-def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width, subset, vmin, vmax, cartopy, timestep):
+def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width, subset, vmin, vmax, cartopy, timestep, qgis, nodata):    
     """Lightweight GeoTIFF, NetCDF, and HDF viewer."""
     # --- Warn early if shapefile requested but geopandas missing ---
     if shapefile and not HAVE_GEO:
@@ -1276,6 +1716,320 @@ def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width,
             "       Install them with: pip install viewtif[geo]\n"
             "       Proceeding without shapefile overlay."
         )
+    # Check if vector files exist before launching viewer
+    if shapefile:
+        for shp_path in shapefile:
+            if not os.path.exists(shp_path):
+                print(f"[ERROR] Vector file not found: {shp_path}")
+                sys.exit(1)
+
+# --- Handle --qgis: check QGIS availability first, then export ---
+    if qgis:
+        import uuid
+        import tempfile
+        
+        # Load rasterio early for QGIS export
+        rasterio = _get_rasterio()
+        Affine = rasterio.Affine
+
+        if not tif_path:
+            print("[ERROR] --qgis requires a file path")
+            sys.exit(1)
+        
+        # Check if QGIS is available BEFORE exporting
+        qgis_path = None
+        
+        if sys.platform == "darwin":
+            candidates = [
+                "/Applications/QGIS.app",
+                "/Applications/QGIS-LTR.app",
+            ]
+            for app in candidates:
+                if os.path.exists(app):
+                    qgis_path = app
+                    break
+        
+        elif sys.platform.startswith("win"):
+            candidates = [
+                r"C:\Program Files\QGIS 3.34.0\bin\qgis-bin.exe",
+                r"C:\Program Files\QGIS 3.32.0\bin\qgis-bin.exe",
+                r"C:\OSGeo4W64\bin\qgis-bin.exe",
+            ]
+            for exe in candidates:
+                if os.path.exists(exe):
+                    qgis_path = exe
+                    break
+            
+            # Try system PATH
+            if not qgis_path:
+                import shutil
+                if shutil.which("qgis"):
+                    qgis_path = "qgis"
+        
+        else:  # Linux
+            import shutil
+            if shutil.which("qgis"):
+                qgis_path = "qgis"
+            else:
+                linux_candidates = [
+                    "/usr/bin/qgis",
+                    "/usr/local/bin/qgis",
+                    "/snap/bin/qgis",
+                ]
+                for exe in linux_candidates:
+                    if os.path.exists(exe):
+                        qgis_path = exe
+                        break
+        
+        # If QGIS not found, exit early
+        if not qgis_path:
+            print("[ERROR] QGIS not found on your system")
+            print("[INFO] Install QGIS or specify the path manually")
+            sys.exit(1)
+        
+        # Warn if --shapefile was provided (it will be ignored)
+        ignored_flags = []
+        if shapefile:
+            ignored_flags.append("--shapefile")
+        if scale and scale != 1:
+            ignored_flags.append("--scale")
+        if vmin is not None or vmax is not None:
+            ignored_flags.append("--vmin/--vmax")
+        if band and band != 1:
+            ignored_flags.append("--band")
+        
+        if ignored_flags:
+            print(f"[INFO] {', '.join(ignored_flags)} ignored when using --qgis")
+        
+        # QGIS found - proceed with export
+        # Handle GDAL format strings (e.g., "OpenFileGDB:path.gdb:layer")
+        if ":" in tif_path and tif_path.startswith(("OpenFileGDB:", "HDF4_EOS:", "HDF5:")):
+            parts = tif_path.split(":")
+            if len(parts) >= 2:
+                file_part = parts[1]
+                ext = os.path.splitext(file_part.lower())[1]
+            else:
+                ext = ""
+        else:
+            ext = os.path.splitext(tif_path.lower())[1]
+        
+        # Skip local file check for remote paths
+        is_remote = tif_path.startswith(("http://", "https://", "s3://", "/vsi"))
+        
+        # Check if NetCDF - not supported for --qgis
+        if ext in (".nc", ".netcdf"):
+            print("[ERROR] --qgis is not supported for NetCDF files")
+            sys.exit(1)
+        
+        tmp_file_path = None
+        random_part = uuid.uuid4().hex[:6]
+        
+        try:
+            # For regular GeoTIFFs, check if remote or local
+            if ext in (".tif", ".tiff"):
+                if is_remote:
+                    # Remote GeoTIFFs need to be downloaded first
+                    print(f"[INFO] Downloading remote GeoTIFF for QGIS...")
+                    base = tif_path.split('/')[-1].replace('.tif', '').replace('.tiff', '')
+                    tmp_file_path = os.path.join(tempfile.gettempdir(), f"{base}_{random_part}.tif")
+                    
+                    # Download using rasterio
+                    with rasterio.open(tif_path) as src:
+                        data = src.read()
+
+                        # --- FORCE clean display-friendly GeoTIFF ---
+                        profile = {
+                            "driver": "GTiff",
+                            "height": src.height,
+                            "width": src.width,
+                            "count": src.count,
+                            "dtype": data.dtype,
+                            "crs": src.crs,
+                            "transform": src.transform,
+                            "compress": "LZW",          # safe default
+                            "interleave": "PIXEL",
+                        }
+
+                        with rasterio.open(tmp_file_path, "w", **profile) as dst:
+                            dst.write(data)
+
+                    print(f"[INFO] Download complete")
+                else:
+                    # Local GeoTIFF - use directly
+                    tmp_file_path = tif_path
+            
+            # For File Geodatabase (.gdb), export to temporary GeoTIFF
+            elif ext == ".gdb":
+                try:
+                    from osgeo import gdal
+                except ImportError:
+                    print("[ERROR] This file requires full GDAL support.")
+                    sys.exit(1)
+                
+                if not tif_path.startswith("OpenFileGDB:"):
+                    print("[ERROR] File Geodatabase requires layer specification for --qgis")
+                    print("[INFO] You provided: " + tif_path)
+                    print("[INFO] First run without --qgis to see available raster layers:")
+                    print(f'[INFO]   viewtif {tif_path}')
+                    print("[INFO] Then use the GDAL format with layer name:")
+                    print(f'[INFO]   viewtif "OpenFileGDB:{tif_path}:LAYERNAME" --qgis')
+                    sys.exit(1)
+                
+                parts = tif_path.split(":")
+                if len(parts) < 3 or not parts[2].strip():
+                    print("[ERROR] Layer name is missing in the path")
+                    print("[INFO] You provided: " + tif_path)
+                    print("[INFO] Correct format: OpenFileGDB:path/to/file.gdb:LAYERNAME")
+                    print("[INFO] Example: viewtif \"OpenFileGDB:Wetlands.gdb:Wetlands\" --qgis")
+                    sys.exit(1)
+                
+                layer_name = parts[2]
+
+                print(f"[INFO] Exporting {layer_name} to temporary GeoTIFF...")
+                
+                try:
+                    ds = gdal.Open(tif_path)
+                    if ds is None:
+                        print(f"[ERROR] Could not open layer '{layer_name}' in geodatabase")
+                        print("[INFO] Possible reasons:")
+                        print("        - Layer name is incorrect")
+                        print("        - Layer is not a raster (vector layers not supported with --qgis)")
+                        print("        - GDAL cannot access the file")
+                        print(f"[INFO] Run without --qgis to see available raster layers:")
+                        gdb_path = parts[1]
+                        print(f"[INFO]   viewtif {gdb_path}")
+                        sys.exit(1)
+                    
+                    arr = ds.ReadAsArray().astype(np.float32)
+                    arr = np.squeeze(arr)
+                    
+                    base = os.path.splitext(os.path.basename(parts[1]))[0]
+                    tmp_file_path = os.path.join(tempfile.gettempdir(), f"{base}_{layer_name}_{random_part}.tif")
+                    
+                    print(f"[INFO] Writing {arr.shape[0]}×{arr.shape[1]} raster...")
+
+                    geotransform = ds.GetGeoTransform()
+                    projection = ds.GetProjection()
+                    
+                    with rasterio.open(
+                        tmp_file_path, 'w',
+                        driver='GTiff',
+                        height=arr.shape[0],
+                        width=arr.shape[1],
+                        count=1,
+                        dtype=arr.dtype,
+                        compress='lzw',
+                        transform=Affine.from_gdal(*geotransform) if geotransform else None,
+                        crs=projection if projection else None
+                    ) as dst:
+                        dst.write(arr, 1)
+                    
+                    print(f"[INFO] Export complete")
+
+                except Exception as e:
+                    print(f"[ERROR] Failed to export .gdb raster: {e}")
+                    sys.exit(1)
+
+            # For HDF, export to temporary GeoTIFF
+            elif ext in (".hdf", ".h5", ".hdf5"):
+                if subset is None:
+                    print("[ERROR] HDF file requires --subset N")
+                    print("[INFO] First run without --qgis to see available subdatasets")
+                    sys.exit(1)
+                
+                try:
+                    from osgeo import gdal
+                except ImportError:
+                    print("[ERROR] This file requires full GDAL support.")
+                    sys.exit(1)
+                
+                ds = gdal.Open(tif_path)
+                subs = ds.GetSubDatasets()
+                
+                if subset < 0 or subset >= len(subs):
+                    print(f"[ERROR] Invalid subset index {subset}. Valid range: 0–{len(subs)-1}")
+                    sys.exit(1)
+                
+                base = os.path.splitext(os.path.basename(tif_path))[0]
+                tmp_file_path = os.path.join(tempfile.gettempdir(), f"{base}_subset{subset}_{random_part}.tif")
+
+                print(f"[INFO] Exporting HDF subdataset to temporary GeoTIFF...")
+                
+                sub_name, _ = subs[subset]
+                sub_ds = gdal.Open(sub_name)
+                
+                if sub_ds is None:
+                    print(f"[ERROR] Could not open HDF subdataset {subset}")
+                    sys.exit(1)
+                
+                arr = sub_ds.ReadAsArray().astype(np.float32)
+                arr = np.squeeze(arr)
+
+                print(f"[INFO] Writing {arr.shape[0]}×{arr.shape[1]} raster...")
+
+                # Try to get geotransform and projection
+                geotransform = sub_ds.GetGeoTransform()
+                projection = sub_ds.GetProjection()
+                
+                # Build kwargs for rasterio
+                write_kwargs = {
+                    'driver': 'GTiff',
+                    'height': arr.shape[0],
+                    'width': arr.shape[1],
+                    'count': 1,
+                    'dtype': arr.dtype,
+                    'compress': 'lzw'
+                }
+                
+                # Only add transform/crs if they exist AND are valid
+                if geotransform and geotransform != (0.0, 1.0, 0.0, 0.0, 0.0, 1.0):
+                    write_kwargs['transform'] = Affine.from_gdal(*geotransform)
+                
+                if projection and projection.strip():
+                    write_kwargs['crs'] = projection
+                
+                # Warn if missing georeferencing
+                if 'crs' not in write_kwargs:
+                    print("[WARN] HDF subdataset has no CRS - exported image will lack georeferencing")
+                
+                with rasterio.open(tmp_file_path, 'w', **write_kwargs) as dst:
+                    dst.write(arr, 1)
+
+                print(f"[INFO] Export complete")
+            
+            else:
+                print(f"[ERROR] --qgis only supports GeoTIFF (.tif), HDF (.hdf, .h5, .hdf5), and File Geodatabase (.gdb)")
+                print(f"[INFO] File extension '{ext}' is not supported")
+                sys.exit(1)
+            
+            # Check if QGIS is already running
+            qgis_running = False
+            if sys.platform == "darwin":
+                import subprocess
+                result = subprocess.run(['pgrep', '-f', 'QGIS'], capture_output=True)
+                qgis_running = result.returncode == 0
+            
+            # Launch QGIS (works whether already running or not)
+            if sys.platform == "darwin":
+                os.system(f'open -a "{qgis_path}" "{tmp_file_path}"')
+            elif sys.platform.startswith("win"):
+                os.system(f'start "" "{qgis_path}" "{tmp_file_path}"')
+            else:
+                os.system(f'"{qgis_path}" "{tmp_file_path}" &')
+            
+            # Info message
+            if ext in (".tif", ".tiff"):
+                print(f"[INFO] Opened in QGIS")
+            else:
+                print(f"[INFO] Opened in QGIS")
+                # print(f"[INFO] Temp file: {tmp_file_path}")
+                # print(f"[INFO] (Will be cleaned on system reboot)")
+        
+        except Exception as e:
+            print(f"[ERROR] Failed to export for QGIS: {e}")
+            sys.exit(1)
+        
+        return
 
     run_viewer(
         tif_path,
@@ -1291,6 +2045,7 @@ def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width,
         vmax=vmax,
         cartopy=cartopy,
         timestep=timestep,
+        nodata=nodata,
     )
 
 if __name__ == "__main__":