viewtif 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

viewtif/tif_viewer.py

@@ -1,16 +1,14 @@
 #!/usr/bin/env python3
 """
-TIFF Viewer (PySide6) — RGB (2–98% global stretch) + Shapefile overlays
+TIFF Viewer (PySide6) — view GeoTIFF, NetCDF, and HDF datasets with shapefile overlays.
 
-Features
+Features:
 - Open GeoTIFFs (single or multi-band)
-- Combine separate single-band TIFFs into RGB (--rgbfiles R.tif G.tif B.tif)
-- QGIS-like RGB display using global 2–98 percentile stretch
-- Single-band view with contrast/gamma + colormap toggle (viridis <-> magma)
-- Pan & zoom
-- Switch bands with [ and ] (single-band)
-- Overlay one or more shapefiles reprojected to raster CRS
-- Z/M tolerant: ignores Z or M coords in shapefiles
+- 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
+- Navigate bands/time steps interactively
 
 Controls
   + / - : zoom in/out
@@ -18,7 +16,7 @@ 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 (viridis <-> magma) — single-band only
-  [ / ] : previous / next band (single-band)
+  [ / ] : previous / next band (or time step) (single-band)
   R     : reset view
 
 Examples
@@ -34,7 +32,8 @@ import numpy as np
 import rasterio
 from rasterio.transform import Affine
 from PySide6.QtWidgets import (
-    QApplication, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, QScrollBar, QGraphicsPathItem
+    QApplication, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, 
+    QScrollBar, QGraphicsPathItem, QVBoxLayout, QHBoxLayout, QWidget, QStatusBar
 )
 from PySide6.QtGui import QImage, QPixmap, QPainter, QPen, QColor, QPainterPath
 from PySide6.QtCore import Qt
@@ -43,7 +42,7 @@ import matplotlib.cm as cm
 import warnings
 warnings.filterwarnings("ignore", category=RuntimeWarning, module="shapely")
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 # Optional overlay deps
 try:
@@ -56,49 +55,70 @@ try:
 except Exception:
     HAVE_GEO = 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).
-    Works even if GDAL is not installed.
+    """Warn and confirm before loading very large rasters (GeoTIFF, GDB, or HDF).    
+    Uses GDAL if available, falls back to rasterio for standard formats.
     """
     import os
     width = height = None
     size_mb = None
 
-    # Try GDAL if available
+    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:
-        from osgeo import gdal
-        gdal.UseExceptions()
-        info = gdal.Info(tif_path, format="json")
-        width, height = info.get("size", [0, 0])
-    except ImportError:
-        # Fallback if GDAL not installed
+        width, height = None, None
+        
+        # Try GDAL first (supports more formats including GDB, HDF)
         try:
-            import rasterio
-            with rasterio.open(tif_path) as src:
-                width, height = src.width, src.height
-        except Exception:
-            print("[WARN] Could not estimate raster size (no GDAL/rasterio). Skipping size check.")
-            return
+            from osgeo import gdal
+            gdal.UseExceptions()
+            info = gdal.Info(tif_path, format="json")
+            width, height = info.get("size", [0, 0])
+        except ImportError:
+            # GDAL not available, try rasterio for standard formats
+            try:
+                with rasterio.open(tif_path) as src:
+                    width = src.width
+                    height = src.height
+            except Exception:
+                # If rasterio also fails, skip the check
+                print(f"[INFO] Could not determine raster dimensions for size check.")
+                return
+        
+        if width and height:
+            total_pixels = (width * height) / (scale ** 2)  # account for downsampling
+            size_mb = None
+            if os.path.exists(tif_path):
+                size_mb = os.path.getsize(tif_path) / (1024 ** 2)
+
+            # Only warn if the *effective* pixels remain large
+            if total_pixels > 20_000_000 and scale <= 5:
+                print(
+                    f"[WARN] Large raster detected ({width}×{height}, ~{total_pixels/1e6:.1f}M effective pixels"
+                    + (f", ~{size_mb:.1f} MB" if size_mb else "")
+                    + "). Loading may freeze. Consider rerunning with --scale (e.g. --scale 10)."
+                )
+                ans = input("Proceed anyway? [y/N]: ").strip().lower()
+                if ans not in ("y", "yes"):
+                    print("Cancelled.")
+                    sys.exit(0)
     except Exception as e:
-        print(f"[WARN] Could not pre-check raster size with GDAL: {e}")
-        return
-
-    # File size
-    if os.path.exists(tif_path):
-        size_mb = os.path.getsize(tif_path) / (1024 ** 2)
-
-    total_pixels = (width * height) / (scale ** 2)
-    if total_pixels > 20_000_000 and scale <= 5:
-        msg = (
-            f"[WARN] Large raster detected ({width}×{height}, ~{total_pixels/1e6:.1f}M pixels"
-            + (f", ~{size_mb:.1f} MB" if size_mb else "")
-            + "). Loading may freeze. Consider --scale (e.g. --scale 10)."
-        )
-        print(msg)
-        ans = input("Proceed anyway? [y/N]: ").strip().lower()
-        if ans not in ("y", "yes"):
-            print("Cancelled.")
-            sys.exit(0)
+        print(f"[INFO] Could not pre-check raster size: {e}")
 
 # -------------------------- QGraphicsView tweaks -------------------------- #
 class RasterView(QGraphicsView):
@@ -171,7 +191,8 @@ class TiffViewer(QMainWindow):
         # --- Load data ---
         if rgbfiles:
             red, green, blue = rgbfiles
-            with rasterio.open(red) as r, rasterio.open(green) as g, rasterio.open(blue) as b:
+            import rasterio as rio_module
+            with rio_module.open(red) as r, rio_module.open(green) as g, rio_module.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([
@@ -189,8 +210,154 @@ class TiffViewer(QMainWindow):
             self.tif_path = self.tif_path or (os.path.commonprefix([red, green, blue]) or red)
 
         elif tif_path:
+            # --------------------- Detect NetCDF --------------------- #
+            if tif_path and tif_path.lower().endswith((".nc", ".netcdf")):
+                try:
+                    # Lazy-load NetCDF dependencies
+                    import xarray as xr
+                    import pandas as pd
+                    
+                    # Open the NetCDF file
+                    ds = xr.open_dataset(tif_path)
+                    
+                    # List variables, filtering out boundary variables (ending with _bnds)
+                    all_vars = list(ds.data_vars)
+                    data_vars = [var for var in all_vars if not var.endswith('_bnds')]
+                    
+                    # 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
+                    elif subset is None:
+                        sys.exit(0)
+                    
+                    # Validate subset index
+                    if subset < 0 or subset >= len(data_vars):
+                        raise ValueError(f"Invalid variable index {subset}. Valid range: 0–{len(data_vars)-1}")
+                    
+                    # Get the selected variable from filtered data_vars
+                    var_name = data_vars[subset]
+                    var_data = ds[var_name]
+                    
+                    # Store original dataset and variable information for better visualization
+                    self._nc_dataset = ds
+                    self._nc_var_name = var_name
+                    self._nc_var_data = var_data
+                    
+                    # Get coordinate info if available
+                    self._has_geo_coords = False
+                    if 'lon' in ds.coords and 'lat' in ds.coords:
+                        self._has_geo_coords = True
+                        self._lon_data = ds.lon.values
+                        self._lat_data = ds.lat.values
+                    elif 'longitude' in ds.coords and 'latitude' in ds.coords:
+                        self._has_geo_coords = True
+                        self._lon_data = ds.longitude.values
+                        self._lat_data = ds.latitude.values
+                    
+                    # Handle time or other index dimension if present
+                    self._has_time_dim = False
+                    self._time_dim_name = None
+                    time_index = 0
+                    
+                    # Look for a time dimension first
+                    if 'time' in var_data.dims:
+                        self._has_time_dim = True
+                        self._time_dim_name = 'time'
+                        self._time_values = ds['time'].values
+                        self._time_index = 0
+                        print(f"NetCDF time dimension detected: {len(self._time_values)} steps")
+
+                        self.band_count = var_data.sizes['time']
+                        self.band_index = 0
+                        self._time_dim_name = 'time'
+
+                        # Try to format time values for better display
+                        time_units = getattr(ds.time, 'units', None)
+                        time_calendar = getattr(ds.time, 'calendar', 'standard')
+                        
+                        # Select first time step by default
+                        var_data = var_data.isel(time=time_index)
+                    
+                    # If no time dimension but variable has multiple dimensions, 
+                    # use the first non-spatial dimension as a "time" dimension
+                    elif len(var_data.dims) > 2:
+                        # Try to find a dimension that's not lat/lon
+                        spatial_dims = ['lat', 'lon', 'latitude', 'longitude', 'y', 'x']
+                        for dim in var_data.dims:
+                            if dim not in spatial_dims:
+                                self._has_time_dim = True
+                                self._time_dim_name = dim
+                                self._time_values = ds[dim].values
+                                self._time_index = time_index
+                                
+                                # Select first index by default
+                                var_data = var_data.isel({dim: time_index})
+                                break
+                    
+                    # Convert to numpy array
+                    arr = var_data.values.astype(np.float32)
+                    
+                    # Process array based on dimensions
+                    if arr.ndim > 2:
+                        # Keep only lat/lon dimensions for 3D+ arrays
+                        arr = np.squeeze(arr)
+                    
+                    # --- Downsample large arrays for responsiveness ---
+                    if arr.ndim >= 2:
+                        h, w = arr.shape[:2]
+                        if h * w > 4_000_000:
+                            step = max(2, int((h * w / 4_000_000) ** 0.5))
+                            if arr.ndim == 2:
+                                arr = arr[::step, ::step]
+                            else:
+                                arr = arr[::step, ::step, :]
+                    
+                    # --- Final assignments ---
+                    self.data = arr
+                    
+                    # Try to extract CRS from CF conventions
+                    self._transform = None
+                    self._crs = None
+                    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)
+                        except Exception as e:
+                            print(f"Could not parse CRS: {e}")
+                    
+                    # Set band info
+                    if arr.ndim == 3:
+                        self.band_count = arr.shape[2]
+                    else:
+                        self.band_count = 1
+                    
+                    self.band_index = 0
+                    self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
+                    
+                    # --- If user specified --band, start there ---
+                    if self.band and self.band <= self.band_count:
+                        self.band_index = self.band - 1
+                    
+                    # Enable cartopy visualization if available
+                    self._use_cartopy = HAVE_CARTOPY and self._has_geo_coords
+                    
+                except ImportError as e:
+                    if "xarray" in str(e) or "netCDF4" in str(e):
+                        raise RuntimeError(
+                            f"NetCDF support requires additional dependencies.\n"
+                            f"Install them with: pip install viewtif[netcdf]\n"
+                            f"Original error: {str(e)}"
+                        )
+                    else:
+                        raise RuntimeError(f"Error reading NetCDF file: {str(e)}")
+                except Exception as e:
+                    raise RuntimeError(f"Error reading NetCDF file: {str(e)}")
+            
             # ---------------- Handle File Geodatabase (.gdb) ---------------- #
-            if tif_path.lower().endswith(".gdb") and ":" not in tif_path:
+            if tif_path and tif_path.lower().endswith(".gdb") and ":" not in tif_path:
                 import re, subprocess
                 gdb_path = tif_path  # use full path to .gdb
                 try:
@@ -212,100 +379,141 @@ class TiffViewer(QMainWindow):
 
             # --- Universal size check before loading ---
             warn_if_large(tif_path, scale=self._scale_arg)
-
+            
+            if False:  # Placeholder for previous if condition
+                pass
             # --------------------- Detect HDF/HDF5 --------------------- #
-            if tif_path.lower().endswith((".hdf", ".h5", ".hdf5")):
+            elif tif_path and tif_path.lower().endswith((".hdf", ".h5", ".hdf5")):
                 try:
-                    # Try reading directly with Rasterio first (works for simple HDF layouts)
-                    with rasterio.open(tif_path) as src:
-                        print(f"Opened HDF with rasterio: {os.path.basename(tif_path)}")
-                        arr = src.read().astype(np.float32)
-                        arr = np.squeeze(arr)
-                        if arr.ndim == 3:
-                            arr = np.transpose(arr, (1, 2, 0))
-                        elif arr.ndim == 2:
-                            print("Single-band dataset.")
-                        self.data = arr
-                        self._transform = src.transform
-                        self._crs = src.crs
-                        self.band_count = arr.shape[2] if arr.ndim == 3 else 1
-                        self.band_index = 0
-                        self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
-                        return  # ✅ Skip GDAL path if Rasterio succeeded
+                    # Try GDAL first (best support for HDF subdatasets)
+                    from osgeo import gdal
+                    gdal.UseExceptions()
 
-                except Exception as e:
-                    print(f"Rasterio could not open HDF directly: {e}")
-                    print("Falling back to GDAL...")
+                    ds = gdal.Open(tif_path)
+                    subs = ds.GetSubDatasets()
 
-                    try:
-                        from osgeo import gdal
-                        gdal.UseExceptions()
-
-                        ds = gdal.Open(tif_path)
-                        subs = ds.GetSubDatasets()
-                        if not subs:
-                            raise ValueError("No subdatasets found in HDF/HDF5 file.")
+                    if not subs:
+                        raise ValueError("No subdatasets found in HDF/HDF5 file.")
 
+                    # Only list subsets if --subset not given
+                    if subset is None:
                         print(f"Found {len(subs)} subdatasets in {os.path.basename(tif_path)}:")
                         for i, (_, desc) in enumerate(subs):
                             print(f"[{i}] {desc}")
+                        print("\nUse --subset N to open a specific subdataset.")
+                        sys.exit(0)
 
-                        if subset is None:
-                            print("\nUse --subset N to open a specific subdataset.")
-                            sys.exit(0)
-
-                        if subset < 0 or subset >= len(subs):
-                            raise ValueError(f"Invalid subset index {subset}. Valid range: 0–{len(subs)-1}")
-
-                        sub_name, desc = subs[subset]
-                        print(f"\nOpening subdataset [{subset}]: {desc}")
-                        sub_ds = gdal.Open(sub_name)
-
-                        arr = sub_ds.ReadAsArray().astype(np.float32)
-                        arr = np.squeeze(arr)
-                        if arr.ndim == 3:
-                            arr = np.transpose(arr, (1, 2, 0))
-                        elif arr.ndim == 2:
-                            print("Single-band dataset.")
-                        else:
-                            raise ValueError(f"Unexpected array shape {arr.shape}")
-
-                        # Downsample large arrays for responsiveness
-                        h, w = arr.shape[:2]
-                        if h * w > 4_000_000:
-                            step = max(2, int((h * w / 4_000_000) ** 0.5))
-                            arr = arr[::step, ::step] if arr.ndim == 2 else arr[::step, ::step, :]
-                            print(f"⚠️ Large dataset preview: downsampled by {step}x")
-
-                        # Assign
-                        self.data = arr
-                        self._transform = None
-                        self._crs = None
-                        self.band_count = arr.shape[2] if arr.ndim == 3 else 1
-                        self.band_index = 0
-                        self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
-
-                        if self.band_count > 1:
-                            print(f"This subdataset has {self.band_count} bands — switch with [ and ] keys.")
-                        else:
-                            print("This subdataset has 1 band.")
+                    # Validate subset index
+                    if subset < 0 or subset >= len(subs):
+                        raise ValueError(f"Invalid subset index {subset}. Valid range: 0–{len(subs)-1}")
+
+                    sub_name, desc = subs[subset]
+                    print(f"\nOpening subdataset [{subset}]: {desc}")
+                    sub_ds = gdal.Open(sub_name)
+
+                    # --- Read once ---
+                    arr = sub_ds.ReadAsArray().astype(np.float32)
+                    #print(f"Raw array shape from GDAL: {arr.shape} (ndim={arr.ndim})")
+
+                    # --- Normalize shape ---
+                    arr = np.squeeze(arr)
+                    if arr.ndim == 3:
+                        # Convert from (bands, rows, cols) → (rows, cols, bands)
+                        arr = np.transpose(arr, (1, 2, 0))
+                        #print(f"Transposed to {arr.shape} (rows, cols, bands)")
+                    elif arr.ndim == 2:
+                        print("Single-band dataset.")
+                    else:
+                        raise ValueError(f"Unexpected array shape {arr.shape}")
+
+                    # --- Downsample large arrays for responsiveness ---
+                    h, w = arr.shape[:2]
+                    if h * w > 4_000_000:
+                        step = max(2, int((h * w / 4_000_000) ** 0.5))
+                        arr = arr[::step, ::step] if arr.ndim == 2 else arr[::step, ::step, :]
+
+                    # --- Final assignments ---
+                    self.data = arr
+                    self._transform = None
+                    self._crs = None
+                    self.band_count = arr.shape[2] if arr.ndim == 3 else 1
+                    self.band_index = 0
+                    self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
+
+                    if self.band_count > 1:
+                        print(f"This subdataset has {self.band_count} bands — switch with [ and ] keys.")
+                    else:
+                        print("This subdataset has 1 band.")
 
                         if self.band and self.band <= self.band_count:
                             self.band_index = self.band - 1
                             print(f"Opening band {self.band}/{self.band_count}")
 
-                    except ImportError:
+                except ImportError:
+                    # GDAL not available, try rasterio as fallback for NetCDF
+                    print("[INFO] GDAL not available, attempting to read HDF/NetCDF with rasterio...")
+                    try:
+                        import rasterio as rio
+                        with rio.open(tif_path) as src:
+                            print(f"[INFO] NetCDF file opened via rasterio")
+                            print(f"[INFO] Data shape: {src.height} x {src.width} x {src.count} bands")
+                            
+                            if src.count == 0:
+                                raise ValueError("No bands found in NetCDF file.")
+                            
+                            # Determine which band(s) to read
+                            if self.band and self.band <= src.count:
+                                band_indices = [self.band]
+                                print(f"Opening band {self.band}/{src.count}")
+                            elif rgb and all(b <= src.count for b in rgb):
+                                band_indices = rgb
+                                print(f"Opening bands {rgb} as RGB")
+                            else:
+                                band_indices = list(range(1, min(src.count + 1, 4)))  # Read up to 3 bands
+                                print(f"Opening bands {band_indices}")
+                            
+                            # Read selected bands
+                            bands = []
+                            for b in band_indices:
+                                band_data = src.read(b, out_shape=(src.height // self._scale_arg, src.width // self._scale_arg))
+                                bands.append(band_data)
+                            
+                            # Stack into array
+                            arr = np.stack(bands, axis=-1).astype(np.float32) if len(bands) > 1 else bands[0].astype(np.float32)
+                            
+                            # Handle no-data values
+                            nd = src.nodata
+                            if nd is not None:
+                                if arr.ndim == 3:
+                                    arr[arr == nd] = np.nan
+                                else:
+                                    arr[arr == nd] = np.nan
+                            
+                            # Final assignments
+                            self.data = arr
+                            self._transform = src.transform
+                            self._crs = src.crs
+                            self.band_count = arr.shape[2] if arr.ndim == 3 else 1
+                            self.band_index = 0
+                            self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
+                            
+                            if self.band_count > 1:
+                                print(f"Loaded {self.band_count} bands — switch with [ and ] keys.")
+                            else:
+                                print("Loaded 1 band.")
+                    except Exception as e:
                         raise RuntimeError(
-                            "HDF/HDF5 support requires GDAL (Python bindings).\n"
-                            "Install it first (e.g., brew install gdal && pip install GDAL)"
+                            f"Failed to read HDF/NetCDF file: {e}\n"
+                            "For full HDF support, install GDAL: pip install GDAL"
                         )
 
             # --------------------- Regular GeoTIFF --------------------- #
             else:
-                if os.path.dirname(tif_path).endswith(".gdb"):
+                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)}"
 
-                with rasterio.open(tif_path) as src:
+                import rasterio as rio_module
+                with rio_module.open(tif_path) as src:
                     self._transform = src.transform
                     self._crs = src.crs
                     if rgb is not None:
@@ -349,19 +557,39 @@ class TiffViewer(QMainWindow):
         self.gamma = 1.0
 
         # Colormap (single-band)
-        self.cmap_name = "viridis"
-        self.alt_cmap_name = "magma"  # toggle with M in single-band
+        # For NetCDF temperature data, have three colormaps in rotation
+        if tif_path and tif_path.lower().endswith(('.nc', '.netcdf')):
+            self.cmap_names = ["RdBu_r", "viridis", "magma"]  # three colormaps for NetCDF
+            self.cmap_index = 0  # start with RdBu_r
+            self.cmap_name = self.cmap_names[self.cmap_index]
+        else:
+            self.cmap_name = "viridis"
+            self.alt_cmap_name = "magma"  # toggle with M in single-band
 
         self.zoom_step = 1.2
         self.pan_step = 80
 
+        # Create main widget and layout
+        self.main_widget = QWidget()
+        self.main_layout = QVBoxLayout(self.main_widget)
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.main_layout.setSpacing(0)
+        
         # Scene + view
         self.scene = QGraphicsScene(self)
         self.view = RasterView(self.scene, self)
-        self.setCentralWidget(self.view)
+        self.main_layout.addWidget(self.view)
+        
+        # Status bar
+        self.setStatusBar(QStatusBar())
+        
+        # Set central widget
+        self.setCentralWidget(self.main_widget)
 
         self.pixmap_item = None
         self._last_rgb = None
+
+        # --- Initial render ---
         self.update_pixmap()
 
         # Overlays (if any)
@@ -499,17 +727,246 @@ class TiffViewer(QMainWindow):
 
     # ----------------------- Title / Rendering ----------------------- #
     def update_title(self):
-        if self.rgbfiles:
-            names = [os.path.basename(n) for n in self.rgbfiles]
-            self.setWindowTitle(f"RGB ({', '.join(names)})")
-        elif self.rgb_mode and self.rgb:
-            self.setWindowTitle(f"RGB {self.rgb} — {os.path.basename(self.tif_path)}")
+        """Show correct title for GeoTIFF or NetCDF time series."""
+        import os
+
+        if hasattr(self, "_has_time_dim") and self._has_time_dim:
+            nc_name = getattr(self, "_nc_var_name", "")
+            file_name = os.path.basename(self.tif_path)
+            title = f"Time step {self.band_index + 1}/{self.band_count} — {file_name}"
+
         elif hasattr(self, "band_index"):
-            self.setWindowTitle(
-                f"Band {self.band_index + 1}/{self.band_count} — {os.path.basename(self.tif_path)}"
-            )
+            title = f"Band {self.band_index + 1}/{self.band_count} — {os.path.basename(self.tif_path)}"
+
+        elif self.rgb_mode and self.rgb:
+            # title = f"RGB {self.rgb} — {os.path.basename(self.tif_path)}"
+            title = f"RGB {self.rgb}"
+
         else:
-            self.setWindowTitle(f"Band {self.band}/{self.band_count} — {os.path.basename(self.tif_path)}")
+            title = os.path.basename(self.tif_path)
+
+        print(f"Title: {title}")
+        self.setWindowTitle(title)
+
+    def _normalize_lat_lon(self, frame):
+        """Flip frame only if data and lat orientation disagree."""
+        import numpy as np
+
+        if not hasattr(self, "_lat_data"):
+            return frame
+
+        lats = self._lat_data
+
+        # 1D latitude case
+        if np.ndim(lats) == 1:
+            lat_ascending = lats[0] < lats[-1]
+
+            # If first pixel row corresponds to northernmost lat → do nothing
+            # If first pixel row corresponds to southernmost lat → flip to make north at top
+            # We'll assume data[0, :] corresponds to lats[0]
+            if lat_ascending:
+                print("[DEBUG] Flipping latitude orientation (lat ascending, data starts south)")
+                frame = np.flipud(frame)
+#             else:
+#                 print("[DEBUG] No flip (lat descending, already north-up)")
+            return frame
+
+        # 2D latitude grid (rare case)
+        elif np.ndim(lats) == 2:
+            first_col = lats[:, 0]
+            lat_ascending = first_col[0] < first_col[-1]
+            if lat_ascending:
+                print("[DEBUG] Flipping latitude orientation (2D grid ascending)")
+                frame = np.flipud(frame)
+#             else:
+#                 print("[DEBUG] No flip (2D grid already north-up)")
+            return frame
+
+        return frame
+
+    def _apply_scale_if_needed(self, frame):
+        """Downsample frame and lat/lon consistently if --scale > 1."""
+        if not hasattr(self, "_scale_arg") or self._scale_arg <= 1:
+            return frame
+
+        step = int(self._scale_arg)
+        print(f"[DEBUG] Applying scale factor {step} to current frame")
+
+        # Downsample the frame
+        frame = frame[::step, ::step]
+
+        # Also downsample lat/lon for this viewer instance if not already
+        if hasattr(self, "_lat_data") and np.ndim(self._lat_data) == 1 and len(self._lat_data) > frame.shape[0]:
+            self._lat_data = self._lat_data[::step]
+        if hasattr(self, "_lon_data") and np.ndim(self._lon_data) == 1 and len(self._lon_data) > frame.shape[1]:
+            self._lon_data = self._lon_data[::step]
+
+        return frame
+
+    def get_current_frame(self):
+        """Return the current time/band frame as a NumPy array (2D)."""
+        frame = None
+
+        if hasattr(self, '_time_dim_name') and hasattr(self, '_nc_var_data'):
+            # Select frame using band_index
+            try:
+                frame = self._nc_var_data.isel({self._time_dim_name: self.band_index})
+            except Exception:
+                # Already numpy or index error fallback
+                frame = self._nc_var_data
+
+        elif isinstance(self.data, np.ndarray):
+            frame = self.data
+
+        # Normalize lat orientation if needed
+        frame = self._normalize_lat_lon(frame)
+        frame = self._apply_scale_if_needed(frame)
+        # Convert to numpy if it's still an xarray
+        if hasattr(frame, "values"):
+            frame = frame.values
+
+        # Apply same scaling factor (if any)
+        if hasattr(self, "_scale_arg") and self._scale_arg > 1:
+            step = int(self._scale_arg)
+
+        return frame.astype(np.float32)
+        
+    def format_time_value(self, time_value):
+        """Format a time value into a user-friendly string"""
+        # Default is the string representation
+        time_str = str(time_value)
+        
+        try:
+            # Handle numpy datetime64
+            if hasattr(time_value, 'dtype') and np.issubdtype(time_value.dtype, np.datetime64):
+                # Lazy-load pandas for timestamp conversion
+                import pandas as pd
+                # Convert to Python datetime if possible
+                dt = pd.Timestamp(time_value).to_pydatetime()
+                time_str = dt.strftime('%Y-%m-%d %H:%M:%S')
+            # Handle native Python datetime
+            elif hasattr(time_value, 'strftime'):
+                time_str = time_value.strftime('%Y-%m-%d %H:%M:%S')
+            # Handle cftime datetime-like objects used in some NetCDF files
+            elif hasattr(time_value, 'isoformat'):
+                time_str = time_value.isoformat().replace('T', ' ')
+        except Exception:
+            # Fall back to string representation
+            pass
+            
+        return time_str
+            
+    # def update_time_label(self):
+    #     """Update the time label with the current time value"""
+    #     if hasattr(self, '_has_time_dim') and self._has_time_dim:
+    #         try:
+    #             time_value = self._time_values[self._time_index]
+    #             time_str = self.format_time_value(time_value)
+                
+    #             # Update time label if it exists
+    #             if hasattr(self, 'time_label'):
+    #                 self.time_label.setText(f"Time: {time_str}")
+                
+    #             # Create a progress bar style display of time position
+    #             total = len(self._time_values)
+    #             position = self._time_index + 1
+    #             bar_width = 20  # Width of the progress bar
+    #             filled = int(bar_width * position / total)
+    #             bar = "[" + "#" * filled + "-" * (bar_width - filled) + "]"
+                
+    #             # Show time info in status bar
+    #             step_info = f"Time step: {position}/{total} {bar} {self.format_time_value(self._time_values[self._time_index])}"
+                
+    #             # Update status bar if it exists
+    #             if hasattr(self, 'statusBar') and callable(self.statusBar):
+    #                 self.statusBar().showMessage(step_info)
+    #             else:
+    #                 print(step_info)
+    #         except Exception as e:
+    #             print(f"Error updating time label: {e}")
+            
+    # def toggle_play_pause(self):
+    #     """Toggle play/pause animation of time steps"""
+    #     if self._is_playing:
+    #         self.stop_animation()
+    #     else:
+    #         self.start_animation()
+    
+    # def start_animation(self):
+    #     """Start the time animation"""
+    #     from PySide6.QtCore import QTimer
+        
+    #     if not hasattr(self, '_play_timer') or self._play_timer is None:
+    #         self._play_timer = QTimer(self)
+    #         self._play_timer.timeout.connect(self.animation_step)
+        
+    #     # Set animation speed (milliseconds between frames)
+    #     animation_speed = 500  # 0.5 seconds between frames
+    #     self._play_timer.start(animation_speed)
+        
+    #     self._is_playing = True
+    #     self.play_button.setText("⏸")  # Pause symbol
+    #     self.play_button.setToolTip("Pause animation")
+    
+    # def stop_animation(self):
+    #     """Stop the time animation"""
+    #     if hasattr(self, '_play_timer') and self._play_timer is not None:
+    #         self._play_timer.stop()
+        
+    #     self._is_playing = False
+    #     self.play_button.setText("▶")  # Play symbol
+    #     self.play_button.setToolTip("Play animation")
+    
+    # def animation_step(self):
+    #     """Advance one frame in the animation"""
+    #     # Go to next time step
+    #     next_time = (self._time_index + 1) % len(self._time_values)
+    #     self.time_slider.setValue(next_time)
+    
+    # def closeEvent(self, event):
+    #     """Clean up resources when the window is closed"""
+    #     # Stop animation timer if it's running
+    #     if hasattr(self, '_is_playing') and self._is_playing:
+    #         self.stop_animation()
+        
+    #     # Call the parent class closeEvent
+    #     super().closeEvent(event)
+            
+    # def populate_date_combo(self):
+    #     """Populate the date combo box with time values"""
+    #     if hasattr(self, '_has_time_dim') and self._has_time_dim and hasattr(self, 'date_combo'):
+    #         try:
+    #             self.date_combo.clear()
+                
+    #             # Add a reasonable subset of dates if there are too many
+    #             max_items = 100  # Maximum number of items to show in dropdown
+                
+    #             if len(self._time_values) <= max_items:
+    #                 # Add all time values
+    #                 for i, time_value in enumerate(self._time_values):
+    #                     time_str = self.format_time_value(time_value)
+    #                     self.date_combo.addItem(time_str, i)
+    #             else:
+    #                 # Add a subset of time values
+    #                 step = len(self._time_values) // max_items
+                    
+    #                 # Always include first and last
+    #                 indices = list(range(0, len(self._time_values), step))
+    #                 if (len(self._time_values) - 1) not in indices:
+    #                     indices.append(len(self._time_values) - 1)
+                    
+    #                 for i in indices:
+    #                     time_str = self.format_time_value(self._time_values[i])
+    #                     self.date_combo.addItem(f"{time_str} [{i+1}/{len(self._time_values)}]", i)
+    #         except Exception as e:
+    #             print(f"Error populating date combo: {e}")
+                    
+    # def date_combo_changed(self, index):
+    #     """Handle date combo box selection change"""
+    #     if index >= 0:
+    #         time_index = self.date_combo.itemData(index)
+    #         if time_index is not None:
+    #             self.time_slider.setValue(time_index)
 
     def _render_rgb(self):
         if self.rgb_mode:
@@ -538,6 +995,126 @@ class TiffViewer(QMainWindow):
             rgb = (cmap(norm)[..., :3] * 255).astype(np.uint8)
             return rgb
 
+    def _render_cartopy_map(self, data):
+        """Render a NetCDF variable with cartopy for better geographic visualization"""
+        import matplotlib.pyplot as plt
+        from matplotlib.backends.backend_agg import FigureCanvasAgg
+        import cartopy.crs as ccrs
+        import cartopy.feature as cfeature
+        
+        # Create a new figure with cartopy projection
+        fig = plt.figure(figsize=(12, 8), dpi=100)
+        ax = plt.axes(projection=ccrs.PlateCarree())
+        
+        # Get coordinates
+        lons = self._lon_data
+        lats = self._lat_data
+        
+        # Create contour plot
+        levels = 20
+        if hasattr(plt.cm, self.cmap_name):
+            cmap = getattr(plt.cm, self.cmap_name)
+        else:
+            cmap = getattr(cm, self.cmap_name, cm.viridis)
+        
+        # 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)
+        rng = max(vmax - vmin, 1e-12)
+        
+        if np.any(finite):
+            norm_data[finite] = (data[finite] - vmin) / rng
+        
+        norm_data = np.clip(norm_data * self.contrast, 0.0, 1.0)
+        norm_data = np.power(norm_data, self.gamma)
+        norm_data = norm_data * rng + vmin
+        
+        # Downsample coordinates to match downsampled data shape
+        # --- Align coordinates with data shape (no stepping assumptions) ---
+        # Downsample coordinates to match downsampled data shape
+        data_height, data_width = data.shape[:2]
+        lat_samples = len(lats)
+        lon_samples = len(lons)
+
+        lat_step = max(1, lat_samples // data_height)
+        lon_step = max(1, lon_samples // data_width)
+
+         # Downsample coordinate arrays to match data
+        lats_downsampled = lats[::lat_step][:data_height]
+        lons_downsampled = lons[::lon_step][:data_width]
+
+        # --- Synchronize latitude orientation with normalized data ---
+        if np.ndim(lats) == 1 and lats[0] < lats[-1]:
+            print("[DEBUG] Lat ascending → flip lats_downsampled to match flipped data")
+            lats_downsampled = lats_downsampled[::-1]
+        elif np.ndim(lats) == 2:
+            first_col = lats[:, 0]
+            if first_col[0] < first_col[-1]:
+                print("[DEBUG] 2D lat grid ascending → flip lats_downsampled vertically")
+                lats_downsampled = np.flipud(lats_downsampled)
+
+        # Convert 0–360 longitude to −180–180 if needed
+        if lons_downsampled.max() > 180:
+            lons_downsampled = ((lons_downsampled + 180) % 360) - 180
+
+
+        # --- Build meshgrid AFTER any flip ---
+        lon_grid, lat_grid = np.meshgrid(lons_downsampled, lats_downsampled, indexing="xy")
+
+        # Use pcolormesh (more stable than contourf for gridded data)
+        img = ax.pcolormesh(
+            lon_grid, lat_grid, data,
+            transform=ccrs.PlateCarree(),
+            cmap=cmap,
+            shading="auto"
+        )
+
+        # Set extent from the 1D vectors (already flipped if needed)
+        ax.set_extent(
+            [lons_downsampled.min(), lons_downsampled.max(),
+            lats_downsampled.min(), lats_downsampled.max()],
+            crs=ccrs.PlateCarree()
+        )
+
+        # Add map features
+        ax.coastlines(resolution="50m", linewidth=0.5)
+        ax.add_feature(cfeature.BORDERS, linestyle=":", linewidth=0.5)
+        ax.add_feature(cfeature.STATES, linestyle="-", linewidth=0.3, alpha=0.5)
+        ax.gridlines(draw_labels=True, alpha=0.3)
+
+        # --- Add dynamic title ---
+        title = os.path.basename(self.tif_path)
+        if hasattr(self, "_has_time_dim") and self._has_time_dim:
+            # Use current band_index as proxy for time_index
+            try:
+                current_time = self._time_values[self.band_index]
+                time_str = self.format_time_value(current_time) if hasattr(self, "format_time_value") else str(current_time)
+                ax.set_title(f"{title}\n{time_str}", fontsize=10)
+            except Exception as e:
+                ax.set_title(f"{title}\n(time step {self.band_index + 1})", fontsize=10)
+        else:
+            ax.set_title(title, fontsize=10)
+
+        # Add colorbar
+        plt.colorbar(img, ax=ax, shrink=0.6)
+        plt.tight_layout()
+
+        
+        # Convert matplotlib figure to image
+        canvas = FigureCanvasAgg(fig)
+        canvas.draw()
+        width, height = fig.canvas.get_width_height()
+        rgba = np.frombuffer(canvas.buffer_rgba(), dtype=np.uint8).reshape(height, width, 4)
+        
+        # Extract RGB and ensure it's C-contiguous for QImage
+        rgb = np.ascontiguousarray(rgba[:, :, :3])
+        
+        # Close figure to prevent memory leak
+        plt.close(fig)
+        
+        return rgb
+        
     def update_pixmap(self):
         # --- Select display data ---
         if hasattr(self, "band_index"):
@@ -558,13 +1135,23 @@ class TiffViewer(QMainWindow):
         # ----------------------------
 
         # --- Render image ---
-        if rgb is None:
-            # Grayscale rendering for single-band (scientific) data
+        # Check if we should use cartopy for NetCDF visualization
+        use_cartopy = False
+        if hasattr(self, '_use_cartopy') and self._use_cartopy and HAVE_CARTOPY:
+            if hasattr(self, '_has_geo_coords') and self._has_geo_coords:
+                use_cartopy = True
+                
+        if use_cartopy:
+            # Render with cartopy for better geographic visualization
+            rgb = self._render_cartopy_map(a)
+        elif rgb is None:
+            # Standard grayscale rendering for single-band (scientific) data
             finite = np.isfinite(a)
-            rng = max(np.nanmax(a) - np.nanmin(a), 1e-12)
+            vmin, vmax = np.nanmin(a), np.nanmax(a)
+            rng = max(vmax - vmin, 1e-12)
             norm = np.zeros_like(a, dtype=np.float32)
             if np.any(finite):
-                norm[finite] = (a[finite] - np.nanmin(a)) / rng
+                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)
@@ -592,10 +1179,11 @@ class TiffViewer(QMainWindow):
 
         tif_path = self.tif_path
       
-        if os.path.dirname(self.tif_path).endswith(".gdb"):
+        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)}"
 
-        with rasterio.open(tif_path) as src:
+        import rasterio as rio_module
+        with rio_module.open(tif_path) as src:
             self.band = band_num
             arr = src.read(self.band).astype(np.float32)
             nd = src.nodata
@@ -638,13 +1226,21 @@ class TiffViewer(QMainWindow):
 
         # Colormap toggle (single-band only)
         elif not self.rgb_mode and k == Qt.Key.Key_M:
-            self.cmap_name, self.alt_cmap_name = self.alt_cmap_name, self.cmap_name
+            # For NetCDF files, cycle through three colormaps
+            if hasattr(self, 'cmap_names'):
+                self.cmap_index = (self.cmap_index + 1) % len(self.cmap_names)
+                self.cmap_name = self.cmap_names[self.cmap_index]
+                print(f"Colormap: {self.cmap_name}")
+            # For other files, toggle between two colormaps
+            else:
+                self.cmap_name, self.alt_cmap_name = self.alt_cmap_name, self.cmap_name
             self.update_pixmap()
 
         # Band switch
         elif k == Qt.Key.Key_BracketRight:
             if hasattr(self, "band_index"):  # HDF/NetCDF mode
                 self.band_index = (self.band_index + 1) % self.band_count
+                self.data = self.get_current_frame()
                 self.update_pixmap()
                 self.update_title()
             elif not self.rgb_mode:  # GeoTIFF single-band mode
@@ -654,11 +1250,29 @@ class TiffViewer(QMainWindow):
         elif k == Qt.Key.Key_BracketLeft:
             if hasattr(self, "band_index"):  # HDF/NetCDF mode
                 self.band_index = (self.band_index - 1) % self.band_count
+                self.data = self.get_current_frame()
                 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}")
+                
+        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}")
 
         elif k == Qt.Key.Key_R:
             self.contrast = 1.0
@@ -670,36 +1284,7 @@ class TiffViewer(QMainWindow):
             super().keyPressEvent(ev)
 
 
-# --------------------------------- Legacy argparse CLI (not used by default) ----------------------------------- #
-def legacy_argparse_main():
-    parser = argparse.ArgumentParser(description="TIFF viewer with RGB (2–98%) & shapefile overlays")
-    parser.add_argument("tif_path", nargs="?", help="Path to TIFF (optional if --rgbfiles is used)")
-    parser.add_argument("--scale", type=int, default=1, help="Downsample factor (1=full, 10=10x smaller)")
-    parser.add_argument("--band", type=int, default=1, help="Band number (ignored if --rgb/--rgbfiles used)")
-    parser.add_argument("--rgb", nargs=3, type=int, help="Three band numbers for RGB, e.g. --rgb 4 3 2")
-    parser.add_argument("--rgbfiles", nargs=3, help="Three single-band TIFFs for RGB, e.g. --rgbfiles B4.tif B3.tif B2.tif")
-    parser.add_argument("--shapefile", nargs="+", help="One or more shapefiles to overlay")
-    parser.add_argument("--shp-color", default="cyan", help="Overlay color (name or #RRGGBB). Default: cyan")
-    parser.add_argument("--shp-width", type=float, default=1.5, help="Overlay line width (screen pixels). Default: 1.5")
-    args = parser.parse_args()
-
-    from PySide6.QtCore import Qt
-    QApplication.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling, True)
-    app = QApplication(sys.argv)
-    win = TiffViewer(
-        args.tif_path,
-        scale=args.scale,
-        band=args.band,
-        rgb=args.rgb,
-        rgbfiles=args.rgbfiles,
-        shapefiles=args.shapefile,
-        shp_color=args.shp_color,
-        shp_width=args.shp_width,
-    )
-    win.show()
-    sys.exit(app.exec())
-
-
+# --------------------------------- CLI ----------------------------------- #
 def run_viewer(
     tif_path,
     scale=None,
@@ -714,7 +1299,7 @@ def run_viewer(
 
     """Launch the TiffViewer app"""
     from PySide6.QtCore import Qt
-    QApplication.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling, True)
+#     QApplication.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling, True)
     app = QApplication(sys.argv)
     win = TiffViewer(
         tif_path,
@@ -733,7 +1318,7 @@ def run_viewer(
 import click
 
 @click.command()
-@click.version_option("0.2.1", prog_name="viewtif")
+@click.version_option("0.2.2", 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")
@@ -742,10 +1327,9 @@ import click
 @click.option("--shapefile", multiple=True, type=str, help="One or more shapefiles to overlay")
 @click.option("--shp-color", default="white", 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("--subset", default=None, type=int, help="Open specific subdataset index in .hdf/.h5 file")
-
+@click.option("--subset", default=None, type=int, help="Open specific subdataset index in .hdf/.h5 file or variable in NetCDF file")
 def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width, subset):
-    """Lightweight GeoTIFF viewer."""
+    """Lightweight GeoTIFF, NetCDF, and HDF viewer."""
     # --- Warn early if shapefile requested but geopandas missing ---
     if shapefile and not HAVE_GEO:
         print(
@@ -767,5 +1351,4 @@ def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width,
     )
 
 if __name__ == "__main__":
-    main()
-
+    main()

{viewtif-0.2.1.dist-info → viewtif-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viewtif
-Version: 0.2.1
+Version: 0.2.2
 Summary: Lightweight GeoTIFF, NetCDF, HDF/HDF5, and Esri File Geodatabase (.gdb) viewer with optional shapefile overlay. NetCDF and cartopy support available via pip install viewtif[netcdf].
 Project-URL: Homepage, https://github.com/nkeikon/tifviewer
 Project-URL: Source, https://github.com/nkeikon/tifviewer
@@ -16,12 +16,16 @@ Requires-Dist: rasterio>=1.3
 Provides-Extra: geo
 Requires-Dist: geopandas>=0.13; extra == 'geo'
 Requires-Dist: shapely>=2.0; extra == 'geo'
+Provides-Extra: netcdf
+Requires-Dist: cartopy>=0.22; extra == 'netcdf'
+Requires-Dist: netcdf4>=1.6; extra == 'netcdf'
+Requires-Dist: pandas>=2.0; extra == 'netcdf'
+Requires-Dist: xarray>=2023.1; extra == 'netcdf'
 Description-Content-Type: text/markdown
 
 # viewtif
 [![Downloads](https://static.pepy.tech/badge/viewtif)](https://pepy.tech/project/viewtif)
 [![PyPI version](https://img.shields.io/pypi/v/viewtif)](https://pypi.org/project/viewtif/)
-[![Python versions](https://img.shields.io/pypi/pyversions/viewtif)](https://pypi.org/project/viewtif/)
 
 A lightweight GeoTIFF viewer for quick visualization directly from the command line.  
 
@@ -53,6 +57,11 @@ pip install GDAL
 ```
 > **Note:** GDAL is required to open `.hdf`, .`h5`, and `.hdf5` files. If it’s missing, viewtif will display: `RuntimeError: HDF support requires GDAL.`
 
+#### NetCDF support 
+```bash
+brew install  "viewtif[netcdf]"
+```
+> **Note:** For enhanced geographic visualization with map projections, coastlines, and borders, install with cartopy: `pip install "viewtif[netcdf]"` (cartopy is included in the netcdf extra). If cartopy is not available, netCDF files will still display with standard RGB rendering.
 ## Quick Start
 ```bash
 # View a GeoTIFF
@@ -84,14 +93,11 @@ viewtif AG100.v003.33.-107.0001.h5 --subset 1 --band 3
 `[WARN] raster lacks CRS/transform; cannot place overlays.`
 
 ### Update in v1.0.7: File Geodatabase (.gdb) support
-`viewtif` can now open raster datasets stored inside Esri File Geodatabases (`.gdb`).
-When you open a .gdb directly, `viewtif` will list available raster datasets first, then you can choose one to view.
+`viewtif` can now open raster datasets stored inside Esri File Geodatabases (`.gdb`). When you open a .gdb directly, `viewtif`` will list available raster datasets first, then you can choose one to view.
 
 Most Rasterio installations already include the OpenFileGDB driver, so .gdb datasets often open without installing GDAL manually.
 
-If you encounter:
-RuntimeError: GDB support requires GDAL,
-install GDAL as shown above to enable the driver. 
+If you encounter: RuntimeError: GDB support requires GDAL, install GDAL as shown above to enable the driver.
 
 ```bash
 # List available raster datasets
@@ -107,6 +113,19 @@ As of v1.0.7, `viewtif` automatically checks the raster size before loading.
 If the dataset is very large (e.g., >20 million pixels), it will pause and warn that loading may freeze your system.  
 You can proceed manually or rerun with the `--scale` option for a smaller, faster preview.
 
+### Update in v0.2.2: NetCDF support with optional cartopy visualization
+`viewtif` now supports NetCDF (`.nc`) files with xarray and optional cartopy geographic visualization.
+
+#### Installation with NetCDF support
+```bash
+pip install "viewtif[netcdf]"
+```
+
+#### Examples
+```bash
+viewtif data.nc
+```
+
 ## Controls
 | Key                  | Action                                  |
 | -------------------- | --------------------------------------- |
@@ -142,4 +161,4 @@ This project is released under the MIT License.
 
 ## Contributors
 - [@HarshShinde0](https://github.com/HarshShinde0) — added mouse-wheel and trackpad zoom support; added NetCDF support with [@nkeikon](https://github.com/nkeikon) 
-- [@p-vdp](https://github.com/p-vdp) — added File Geodatabase (.gdb) raster support
+- [@p-vdp](https://github.com/p-vdp) — added File Geodatabase (.gdb) raster support

viewtif-0.2.2.dist-info/RECORD

@@ -0,0 +1,5 @@
+viewtif/tif_viewer.py,sha256=egk8LkdTtbV77no4IUd_bHwpU7b0oCNE9z6qxpkOKa0,57343
+viewtif-0.2.2.dist-info/METADATA,sha256=_7BJ66mI4kZzwSwTSG6fwWr5fe-USNzbGESpZvcNW7M,7280
+viewtif-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+viewtif-0.2.2.dist-info/entry_points.txt,sha256=NVEjlRyJ7R7hFPOVsZJio3Hl0VqlX7_oVfA7819XvHM,52
+viewtif-0.2.2.dist-info/RECORD,,

viewtif-0.2.1.dist-info/RECORD

@@ -1,5 +0,0 @@
-viewtif/tif_viewer.py,sha256=cHu62pMpvYFZD4MNhpsOme6AYD2eNAsd13FGmaxVSd8,31075
-viewtif-0.2.1.dist-info/METADATA,sha256=EveWboZK5lTOaAXyzFCs6O5zaebSkdKCb9Al1Av_br4,6522
-viewtif-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-viewtif-0.2.1.dist-info/entry_points.txt,sha256=NVEjlRyJ7R7hFPOVsZJio3Hl0VqlX7_oVfA7819XvHM,52
-viewtif-0.2.1.dist-info/RECORD,,