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

viewtif/tif_viewer.py

@@ -34,14 +34,16 @@ import numpy as np
 import rasterio
 from rasterio.transform import Affine
 from PySide6.QtWidgets import (
-    QApplication, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, 
-    QScrollBar, QGraphicsPathItem, QVBoxLayout, QHBoxLayout, QSlider, QLabel, 
-    QWidget, QStatusBar, QPushButton, QComboBox
+    QApplication, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, QScrollBar, QGraphicsPathItem
 )
 from PySide6.QtGui import QImage, QPixmap, QPainter, QPen, QColor, QPainterPath
-from PySide6.QtCore import Qt, QDateTime
+from PySide6.QtCore import Qt
 
 import matplotlib.cm as cm
+import warnings
+warnings.filterwarnings("ignore", category=RuntimeWarning, module="shapely")
+
+__version__ = "0.2.1"
 
 # Optional overlay deps
 try:
@@ -54,74 +56,53 @@ 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).
-    
-    Uses GDAL if available, falls back to rasterio for standard formats.
+    Works even if GDAL is not installed.
     """
     import os
+    width = height = None
+    size_mb = None
 
-    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 GDAL if available
     try:
-        width, height = None, None
-        
-        # Try GDAL first (supports more formats including GDB, HDF)
+        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
         try:
-            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)
+            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
     except Exception as e:
-        print(f"[INFO] Could not pre-check raster size: {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)
 
 # -------------------------- 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)
@@ -190,8 +171,7 @@ class TiffViewer(QMainWindow):
         # --- Load data ---
         if rgbfiles:
             red, green, blue = rgbfiles
-            import rasterio as rio_module
-            with rio_module.open(red) as r, rio_module.open(green) as g, rio_module.open(blue) as b:
+            with rasterio.open(red) as r, rasterio.open(green) as g, rasterio.open(blue) as b:
                 if (r.width, r.height) != (g.width, g.height) or (r.width, r.height) != (b.width, b.height):
                     raise ValueError("All RGB files must have the same dimensions.")
                 arr = np.stack([
@@ -209,149 +189,8 @@ 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 and tif_path.lower().endswith(".gdb") and ":" not in tif_path:
+            if tif_path.lower().endswith(".gdb") and ":" not in tif_path:
                 import re, subprocess
                 gdb_path = tif_path  # use full path to .gdb
                 try:
@@ -370,147 +209,103 @@ 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 --------------------- #
-            elif tif_path and tif_path.lower().endswith((".hdf", ".h5", ".hdf5")):
+            if tif_path.lower().endswith((".hdf", ".h5", ".hdf5")):
                 try:
-                    # Try GDAL first (best support for HDF subdatasets)
-                    from osgeo import gdal
-                    gdal.UseExceptions()
+                    # 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
 
-                    ds = gdal.Open(tif_path)
-                    subs = ds.GetSubDatasets()
+                except Exception as e:
+                    print(f"Rasterio could not open HDF directly: {e}")
+                    print("Falling back to GDAL...")
 
-                    if not subs:
-                        raise ValueError("No subdatasets found in HDF/HDF5 file.")
+                    try:
+                        from osgeo import gdal
+                        gdal.UseExceptions()
 
-                    print(f"Found {len(subs)} subdatasets in {os.path.basename(tif_path)}:")
-                    for i, (_, desc) in enumerate(subs):
-                        print(f"[{i}] {desc}")
+                        ds = gdal.Open(tif_path)
+                        subs = ds.GetSubDatasets()
+                        if not subs:
+                            raise ValueError("No subdatasets found in HDF/HDF5 file.")
 
-                    # Only list subsets if --subset not given
-                    if subset is None:
-                        print("\nUse --subset N to open a specific subdataset.")
-                        sys.exit(0)
+                        print(f"Found {len(subs)} subdatasets in {os.path.basename(tif_path)}:")
+                        for i, (_, desc) in enumerate(subs):
+                            print(f"[{i}] {desc}")
 
-                    # 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 subset is None:
+                            print("\nUse --subset N to open a specific subdataset.")
+                            sys.exit(0)
 
-                    # --- 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:
+                        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)
 
-                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:
+                        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:
                         raise RuntimeError(
-                            f"Failed to read HDF/NetCDF file: {e}\n"
-                            "For full HDF support, install GDAL: pip install GDAL"
+                            "HDF/HDF5 support requires GDAL (Python bindings).\n"
+                            "Install it first (e.g., brew install gdal && pip install GDAL)"
                         )
 
             # --------------------- Regular GeoTIFF --------------------- #
             else:
-                if tif_path and os.path.dirname(tif_path).endswith(".gdb"):
+                if os.path.dirname(tif_path).endswith(".gdb"):
                     tif_path = f"OpenFileGDB:{os.path.dirname(tif_path)}:{os.path.basename(tif_path)}"
 
-                import rasterio as rio_module
-                with rio_module.open(tif_path) as src:
+                with rasterio.open(tif_path) as src:
                     self._transform = src.transform
                     self._crs = src.crs
                     if rgb is not None:
@@ -554,92 +349,16 @@ class TiffViewer(QMainWindow):
         self.gamma = 1.0
 
         # Colormap (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.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.main_layout.addWidget(self.view)
-        
-        # Status bar
-        self.setStatusBar(QStatusBar())
-        
-        # Set central widget
-        self.setCentralWidget(self.main_widget)
+        self.setCentralWidget(self.view)
 
         self.pixmap_item = None
         self._last_rgb = None
@@ -786,237 +505,11 @@ 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"):
-            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)
+            self.setWindowTitle(
+                f"Band {self.band_index + 1}/{self.band_count} — {os.path.basename(self.tif_path)}"
+            )
         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:
@@ -1025,8 +518,7 @@ class TiffViewer(QMainWindow):
             rgb = np.zeros_like(arr)
             if np.any(finite):
                 # Global 2–98 percentile stretch across all bands (QGIS-like)
-                global_min = np.nanpercentile(arr, 2)
-                global_max = np.nanpercentile(arr, 98)
+                global_min, global_max = np.nanpercentile(arr, (2, 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)
@@ -1046,104 +538,6 @@ 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"):
@@ -1164,23 +558,13 @@ class TiffViewer(QMainWindow):
         # ----------------------------
 
         # --- Render image ---
-        # 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
+        if rgb is None:
+            # Grayscale rendering for single-band (scientific) data
             finite = np.isfinite(a)
-            vmin, vmax = np.nanmin(a), np.nanmax(a)
-            rng = max(vmax - vmin, 1e-12)
+            rng = max(np.nanmax(a) - np.nanmin(a), 1e-12)
             norm = np.zeros_like(a, dtype=np.float32)
             if np.any(finite):
-                norm[finite] = (a[finite] - vmin) / rng
+                norm[finite] = (a[finite] - np.nanmin(a)) / rng
             norm = np.clip(norm, 0, 1)
             norm = np.power(norm * self.contrast, self.gamma)
             cmap = getattr(cm, self.cmap_name, cm.viridis)
@@ -1208,11 +592,10 @@ class TiffViewer(QMainWindow):
 
         tif_path = self.tif_path
       
-        if tif_path and os.path.dirname(self.tif_path).endswith(".gdb"):
+        if os.path.dirname(self.tif_path).endswith(".gdb"):
             tif_path = f"OpenFileGDB:{os.path.dirname(self.tif_path)}:{os.path.basename(self.tif_path)}"
 
-        import rasterio as rio_module
-        with rio_module.open(tif_path) as src:
+        with rasterio.open(tif_path) as src:
             self.band = band_num
             arr = src.read(self.band).astype(np.float32)
             nd = src.nodata
@@ -1255,14 +638,7 @@ class TiffViewer(QMainWindow):
 
         # Colormap toggle (single-band only)
         elif not self.rgb_mode and k == Qt.Key.Key_M:
-            # 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.cmap_name, self.alt_cmap_name = self.alt_cmap_name, self.cmap_name
             self.update_pixmap()
 
         # Band switch
@@ -1283,23 +659,6 @@ 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
@@ -1311,8 +670,8 @@ class TiffViewer(QMainWindow):
             super().keyPressEvent(ev)
 
 
-# --------------------------------- CLI ----------------------------------- #
-def main():
+# --------------------------------- 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)")
@@ -1324,6 +683,8 @@ def 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,
@@ -1348,9 +709,12 @@ 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,
@@ -1361,7 +725,7 @@ def run_viewer(
         shapefiles=shapefile,
         shp_color=shp_color,
         shp_width=shp_width,
-        subset=subset,
+        subset=subset
     )
     win.show()
     sys.exit(app.exec())
@@ -1369,18 +733,19 @@ def run_viewer(
 import click
 
 @click.command()
-@click.version_option("0.2.0", prog_name="viewtif")
+@click.version_option("0.2.1", 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=float, help="Scale factor for display")
+@click.option("--scale", default=1.0, show_default=True, type=int, 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 or variable in NetCDF file")
+@click.option("--subset", default=None, type=int, help="Open specific subdataset index in .hdf/.h5 file")
+
 def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width, subset):
-    """Lightweight GeoTIFF, NetCDF, and HDF viewer."""
+    """Lightweight GeoTIFF viewer."""
     # --- Warn early if shapefile requested but geopandas missing ---
     if shapefile and not HAVE_GEO:
         print(
@@ -1398,8 +763,9 @@ 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.2.0.dist-info → viewtif-0.2.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: viewtif
-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].
+Version: 0.2.1
+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
 Project-URL: Issues, https://github.com/nkeikon/tifviewer/issues
@@ -16,27 +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.  
 
-You can visualize single-band GeoTIFFs, RGB composites, and shapefile overlays in a simple Qt-based window.
-
----
-
-**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))
-
----
+You can visualize single-band GeoTIFFs, RGB composites, HDF, NetCDF files and shapefile overlays in a simple Qt-based window.
 
 ## Installation
 
@@ -56,7 +45,7 @@ pip install "viewtif[geo]"
 > **Note:** For macOS(zsh) users:
 > Make sure to include the quotes, or zsh will interpret it as a pattern.
 
-#### HDF/HDF5 support
+#### HDF/HDF5 support 
 ```bash
 brew install gdal     # macOS
 sudo apt install gdal-bin python3-gdal  # Linux
@@ -95,8 +84,14 @@ 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`), 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.
+`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. 
 
 ```bash
 # List available raster datasets
@@ -105,33 +100,13 @@ viewtif /path/to/geodatabase.gdb
 # Open a specific raster
 viewtif "OpenFileGDB:/path/to/geodatabase.gdb:RasterName"
 ```
-> **Note:** Requires GDAL 3.7 or later with the OpenFileGDB driver enabled. If multiple raster datasets are present, viewtif lists them all and shows how to open each. The .gdb path and raster name must be separated by a colon (:).
+> **Note:** If multiple raster datasets are present, viewtif lists them all and shows how to open each. The .gdb path and raster name must be separated by a colon (:).
 
 ### Update in v1.0.7: Large raster safeguard
 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                                  |
 | -------------------- | --------------------------------------- |
@@ -140,12 +115,12 @@ viewtif data.nc
 | `C` / `V`            | Increase / decrease contrast            |
 | `G` / `H`            | Increase / decrease gamma               |
 | `M`                  | Toggle colormap (`viridis` ↔ `magma`)   |
-| `[` / `]`            | Previous / next band (single-band only) |
+| `[` / `]`            | Previous / next band (or time step)     |
 | `R`                  | Reset view                              |
 
 ## Features
 - Command-line driven GeoTIFF viewer.
-- Supports single-band, RGB composite, and HDF/HDF5 subdatasets.
+- Supports single-band, RGB composite, HDF/HDF5 subdatasets, and NetCDF.
 - Optional shapefile overlay for geographic context.
 - Adjustable contrast, gamma, and colormap.
 - Fast preview using rasterio and PySide6.
@@ -166,5 +141,5 @@ Longenecker, Jake; Lee, Christine; Hulley, Glynn; Cawse-Nicholson, Kerry; Purkis
 This project is released under the MIT License.
 
 ## Contributors
-- [@HarshShinde0](https://github.com/HarshShinde0) — added mouse-wheel and trackpad zoom support
+- [@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

viewtif-0.2.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+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,,

viewtif-0.2.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-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,,