viewtif 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

viewtif/tif_viewer.py

@@ -34,10 +34,12 @@ 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, QSlider, QLabel, 
+    QWidget, QStatusBar, QPushButton, QComboBox
 )
 from PySide6.QtGui import QImage, QPixmap, QPainter, QPen, QColor, QPainterPath
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QDateTime
 
 import matplotlib.cm as cm
 
@@ -52,53 +54,74 @@ 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.
+    
+    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):
     def __init__(self, *args, **kwargs):
+        import numpy as np
         super().__init__(*args, **kwargs)
         self.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, False)
         self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)
@@ -167,7 +190,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([
@@ -185,8 +209,149 @@ 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 = time_index
+                        
+                        # 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:
@@ -205,103 +370,147 @@ class TiffViewer(QMainWindow):
                 except subprocess.CalledProcessError as e:
                     print(f"[WARN] Could not inspect FileGDB: {e}")
                     sys.exit(0)
-
-            # --- Universal size check before loading ---
+                # --- 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...")
-
-                    try:
-                        from osgeo import gdal
-                        gdal.UseExceptions()
+                    ds = gdal.Open(tif_path)
+                    subs = ds.GetSubDatasets()
 
-                        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.")
 
-                        print(f"Found {len(subs)} subdatasets in {os.path.basename(tif_path)}:")
-                        for i, (_, desc) in enumerate(subs):
-                            print(f"[{i}] {desc}")
+                    print(f"Found {len(subs)} subdatasets in {os.path.basename(tif_path)}:")
+                    for i, (_, desc) in enumerate(subs):
+                        print(f"[{i}] {desc}")
 
-                        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)
+                    # Only list subsets if --subset not given
+                    if subset is None:
+                        print("\nUse --subset N to open a specific subdataset.")
+                        sys.exit(0)
 
-                        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")
+                    # 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.")
 
-                        # Assign
-                        self.data = arr
-                        self._transform = None
-                        self._crs = None
-                        self.band_count = arr.shape[2] if arr.ndim == 3 else 1
+                    # --- If user specified --band, start there ---
+                    if self.band and self.band <= self.band_count:
+                        self.band_index = self.band - 1
+                        print(f"Opening band {self.band}/{self.band_count}")
+                    else:
                         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:
@@ -345,16 +554,92 @@ 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)
+        
+        # Add time navigation controls at the top for NetCDF files
+        if hasattr(self, '_has_time_dim') and self._has_time_dim:
+            self.time_layout = QHBoxLayout()
+            self.time_layout.setContentsMargins(10, 5, 10, 5)
+            
+            # Navigation buttons
+            self.prev_button = QPushButton("<<")
+            self.prev_button.setToolTip("Previous time step")
+            self.prev_button.clicked.connect(self.prev_time_step)
+            self.prev_button.setFixedWidth(40)
+            
+            # Play/Pause button
+            self.play_button = QPushButton("▶")  # Play symbol
+            self.play_button.setToolTip("Play/Pause time animation")
+            self.play_button.clicked.connect(self.toggle_play_pause)
+            self.play_button.setFixedWidth(40)
+            self._is_playing = False
+            self._play_timer = None
+            
+            self.next_button = QPushButton(">>")
+            self.next_button.setToolTip("Next time step")
+            self.next_button.clicked.connect(self.next_time_step)
+            self.next_button.setFixedWidth(40)
+            
+            # Date/time label
+            self.time_label = QLabel()
+            self.time_label.setMinimumWidth(200)
+            
+            # Time slider
+            self.time_slider = QSlider(Qt.Orientation.Horizontal)
+            self.time_slider.setMinimum(0)
+            self.time_slider.setMaximum(len(self._time_values) - 1)
+            self.time_slider.setValue(self._time_index)
+            self.time_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+            self.time_slider.setTickInterval(max(1, len(self._time_values) // 10))
+            self.time_slider.valueChanged.connect(self.time_slider_changed)
+            
+            # Date time combo box
+            self.date_combo = QComboBox()
+            self.populate_date_combo()
+            self.date_combo.currentIndexChanged.connect(self.date_combo_changed)
+            self.date_combo.setFixedWidth(200)
+            
+            # Add controls to layout
+            self.time_layout.addWidget(self.prev_button)
+            self.time_layout.addWidget(self.play_button)
+            self.time_layout.addWidget(self.time_label)
+            self.time_layout.addWidget(self.time_slider, 1)  # 1 = stretch factor
+            self.time_layout.addWidget(self.next_button)
+            self.time_layout.addWidget(QLabel("Jump to:"))
+            self.time_layout.addWidget(self.date_combo)
+            
+            # Add time controls to main layout at the top
+            self.main_layout.addLayout(self.time_layout)
+            
+            # Update time label
+            self.update_time_label()
+        
         # 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
@@ -501,11 +786,237 @@ class TiffViewer(QMainWindow):
         elif self.rgb_mode and self.rgb:
             self.setWindowTitle(f"RGB {self.rgb} — {os.path.basename(self.tif_path)}")
         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)}"
+            if hasattr(self, '_has_time_dim') and self._has_time_dim:
+                time_str = self.format_time_value(self._time_values[self._time_index])
+                if len(time_str) > 15:  # Truncate if too long for title
+                    time_str = time_str[:15]
+                
+                # Use generic label for non-time dimensions
+                if self._time_dim_name and self._time_dim_name != 'time':
+                    title += f" - {self._time_dim_name}: {time_str} ({self._time_index + 1}/{len(self._time_values)})"
+                else:
+                    title += f" - {time_str}"
+            self.setWindowTitle(title)
         else:
             self.setWindowTitle(f"Band {self.band}/{self.band_count} — {os.path.basename(self.tif_path)}")
+            
+    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 time_slider_changed(self, value):
+        """Handle time slider value change"""
+        if hasattr(self, '_has_time_dim') and self._has_time_dim:
+            self._time_index = value
+            
+            # Update data for new time step
+            if self._time_dim_name:
+                # Use the named dimension (time or other index)
+                var_data = self._nc_var_data.isel({self._time_dim_name: self._time_index})
+            else:
+                # Fallback to 'time' dimension
+                var_data = self._nc_var_data.isel(time=self._time_index)
+                
+            self.data = var_data.values.astype(np.float32)
+            
+            # Find and select the matching date in the combo box (if it exists)
+            if hasattr(self, 'date_combo'):
+                try:
+                    for i in range(self.date_combo.count()):
+                        if self.date_combo.itemData(i) == value:
+                            self.date_combo.blockSignals(True)  # Block signals to avoid recursion
+                            self.date_combo.setCurrentIndex(i)
+                            self.date_combo.blockSignals(False)
+                            break
+                except Exception as e:
+                    print(f"Error updating combo box: {e}")
+            
+            # Update UI
+            self.update_time_label()
+            self.update_pixmap()
+            self.update_title()
+            
+    def next_time_step(self):
+        """Go to the next time step"""
+        if hasattr(self, '_has_time_dim') and self._has_time_dim:
+            try:
+                next_time = (self._time_index + 1) % len(self._time_values)
+                if hasattr(self, 'time_slider'):
+                    self.time_slider.setValue(next_time)
+                else:
+                    # Direct update if slider doesn't exist
+                    self._time_index = next_time
+                    self.update_time_data()
+            except Exception as e:
+                print(f"Error going to next time step: {e}")
+            
+    def prev_time_step(self):
+        """Go to the previous time step"""
+        if hasattr(self, '_has_time_dim') and self._has_time_dim:
+            try:
+                prev_time = (self._time_index - 1) % len(self._time_values)
+                if hasattr(self, 'time_slider'):
+                    self.time_slider.setValue(prev_time)
+                else:
+                    # Direct update if slider doesn't exist
+                    self._time_index = prev_time
+                    self.update_time_data()
+            except Exception as e:
+                print(f"Error going to previous time step: {e}")
+                
+    def update_time_data(self):
+        """Update data for the current time index"""
+        try:
+            # Update data for current time step
+            if self._time_dim_name:
+                # Use the named dimension (time or other index)
+                var_data = self._nc_var_data.isel({self._time_dim_name: self._time_index})
+            else:
+                # Fallback to 'time' dimension
+                var_data = self._nc_var_data.isel(time=self._time_index)
+                
+            self.data = var_data.values.astype(np.float32)
+            
+            # Update UI
+            self.update_time_label()
+            self.update_pixmap()
+            self.update_title()
+        except Exception as e:
+            print(f"Error updating time data: {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:
@@ -514,7 +1025,8 @@ class TiffViewer(QMainWindow):
             rgb = np.zeros_like(arr)
             if np.any(finite):
                 # Global 2–98 percentile stretch across all bands (QGIS-like)
-                global_min, global_max = np.nanpercentile(arr, (2, 98))
+                global_min = np.nanpercentile(arr, 2)
+                global_max = np.nanpercentile(arr, 98)
                 rng = max(global_max - global_min, 1e-12)
                 norm = np.clip((arr - global_min) / rng, 0, 1)
                 rgb = np.clip(norm * self.contrast, 0, 1)
@@ -534,6 +1046,104 @@ 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
+        # data shape is (lat_samples, lon_samples) after downsampling
+        data_height, data_width = data.shape[:2]
+        lat_samples = len(lats)
+        lon_samples = len(lons)
+        
+        # Calculate downsampling step if needed
+        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]
+        
+        # Convert 0-360 longitude to -180 to 180 if needed
+        if lons_downsampled.max() > 180:
+            lons_downsampled = ((lons_downsampled + 180) % 360) - 180
+        
+        # Create 2D meshgrid for proper coordinate alignment with cartopy
+        lon_grid, lat_grid = np.meshgrid(lons_downsampled, lats_downsampled, indexing='xy')
+        
+        # Create the plot with 2D meshgrid for proper coordinate alignment
+        contour = ax.contourf(lon_grid, lat_grid, data, 
+                            transform=ccrs.PlateCarree(),
+                            levels=levels, cmap=cmap)
+        
+        # Set map extent based on actual downsampled coordinates
+        lon_min, lon_max = lons_downsampled.min(), lons_downsampled.max()
+        lat_min, lat_max = lats_downsampled.min(), lats_downsampled.max()
+        ax.set_extent([lon_min, lon_max, lat_min, lat_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 title with variable name and time if available
+        title = f"{self._nc_var_name}"
+        if hasattr(self, '_has_time_dim') and self._has_time_dim:
+            time_str = str(self._time_values[self._time_index])
+            title += f"\n{time_str}"
+        ax.set_title(title)
+        
+        # Add colorbar
+        plt.colorbar(contour, 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"):
@@ -554,13 +1164,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)
@@ -588,10 +1208,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
@@ -634,7 +1255,14 @@ 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
@@ -655,6 +1283,23 @@ class TiffViewer(QMainWindow):
             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
@@ -666,8 +1311,8 @@ class TiffViewer(QMainWindow):
             super().keyPressEvent(ev)
 
 
-# --------------------------------- Legacy argparse CLI (not used by default) ----------------------------------- #
-def legacy_argparse_main():
+# --------------------------------- CLI ----------------------------------- #
+def 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)")
@@ -679,8 +1324,6 @@ def legacy_argparse_main():
     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,
@@ -705,12 +1348,9 @@ def run_viewer(
     shapefile=None,
     shp_color=None,
     shp_width=None,
-    subset=None
+    subset=None,
 ):
-
     """Launch the TiffViewer app"""
-    from PySide6.QtCore import Qt
-    QApplication.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling, True)
     app = QApplication(sys.argv)
     win = TiffViewer(
         tif_path,
@@ -721,7 +1361,7 @@ def run_viewer(
         shapefiles=shapefile,
         shp_color=shp_color,
         shp_width=shp_width,
-        subset=subset
+        subset=subset,
     )
     win.show()
     sys.exit(app.exec())
@@ -729,19 +1369,18 @@ def run_viewer(
 import click
 
 @click.command()
-@click.version_option("0.1.10", prog_name="viewtif")
+@click.version_option("0.2.0", 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.0, show_default=True, type=float, help="Scale factor for display")
 @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="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(
@@ -759,9 +1398,8 @@ def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width,
         shapefile=shapefile,
         shp_color=shp_color,
         shp_width=shp_width,
-        subset=subset
+        subset=subset,
     )
 
 if __name__ == "__main__":
-    main()
-
+    main()

{viewtif-0.1.10.dist-info → viewtif-0.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: viewtif
-Version: 0.1.10
-Summary: Lightweight GeoTIFF, HDF/HDF5, and Esri File Geodatabase (.gdb) viewer with shapefile overlay and large-raster safeguard.
+Version: 0.2.0
+Summary: Lightweight GeoTIFF, NetCDF, HDF/HDF5, and Esri File Geodatabase (.gdb) viewer with optional shapefile overlay and geographic visualization. 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
 Project-URL: Issues, https://github.com/nkeikon/tifviewer/issues
@@ -16,21 +16,25 @@ 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.  
 
 You can visualize single-band GeoTIFFs, RGB composites, and shapefile overlays in a simple Qt-based window.
 
 ---
-Latest stable release: v0.1.9 (PyPI)
 
-Development branch: v0.2.0-dev (experimental, not released)
+**Latest stable release:** [v0.1.9 on PyPI](https://pypi.org/project/viewtif/)  
+**Latest development:** main branch ([v0.2.0, experimental](https://github.com/nkeikon/viewtif))
 
 ---
 
@@ -92,7 +96,7 @@ viewtif AG100.v003.33.-107.0001.h5 --subset 1 --band 3
 
 ### Update in v1.0.7: File Geodatabase (.gdb) support
 `viewtif` can now open raster datasets stored inside Esri File Geodatabases (`.gdb`), using the GDAL `OpenFileGDB` driver.  
-When you open a .gdb directly, `viewtif` will list available raster datasets first, then you can choose one to view.
+When you open a .gdb directly, `viewtif`` will list available raster datasets first, then you can choose one to view.
 
 ```bash
 # List available raster datasets
@@ -108,6 +112,26 @@ 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.0: NetCDF support with optional cartopy visualization
+`viewtif` now supports NetCDF (`.nc`) files with xarray and optional cartopy geographic visualization. NetCDF support is optional to keep the base installation lightweight.
+
+#### Installation with NetCDF support
+```bash
+pip install "viewtif[netcdf]"
+```
+
+#### Examples
+```bash
+viewtif data.nc
+```
+
+> **Note:** NetCDF support is optional. If xarray or netCDF4 is missing, viewtif will display:  
+> `NetCDF support requires additional dependencies. Install them with: pip install viewtif[netcdf]`
+> 
+> **Cartopy visualization:** 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.
+
 ## Controls
 | Key                  | Action                                  |
 | -------------------- | --------------------------------------- |

viewtif-0.2.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+viewtif/tif_viewer.py,sha256=zaIQ-u77jz2D1G5fDas0oR878dm1foNLUUKfdf5pTTU,60858
+viewtif-0.2.0.dist-info/METADATA,sha256=APFk7tPPzcaaziAj_73Q0Y9pWitfFihx_x0Tamw7fxU,7497
+viewtif-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+viewtif-0.2.0.dist-info/entry_points.txt,sha256=NVEjlRyJ7R7hFPOVsZJio3Hl0VqlX7_oVfA7819XvHM,52
+viewtif-0.2.0.dist-info/RECORD,,

viewtif-0.1.10.dist-info/RECORD

@@ -1,5 +0,0 @@
-viewtif/tif_viewer.py,sha256=6mTylUguRn56QaJDZiNLSVPyqNWTDW_HKRRoa9eqjKY,30960
-viewtif-0.1.10.dist-info/METADATA,sha256=OTaQUPKmNLiL-L6Pvp5Sin3--KP6s3-MsNWQ7uJKWSk,6338
-viewtif-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-viewtif-0.1.10.dist-info/entry_points.txt,sha256=NVEjlRyJ7R7hFPOVsZJio3Hl0VqlX7_oVfA7819XvHM,52
-viewtif-0.1.10.dist-info/RECORD,,