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

viewtif/tif_viewer.py

@@ -15,7 +15,7 @@ Controls
   Arrow keys or WASD : pan
   C / V : increase/decrease contrast (works in RGB and single-band)
   G / H : increase/decrease gamma    (works in RGB and single-band)
-  M     : toggle colormap (viridis <-> magma) — single-band only
+  M     : toggle colormap. Single-band: viridis/magma. NetCDF: RdBu_r/viridis/magma.
   [ / ] : previous / next band (or time step) (single-band)
   R     : reset view
 
@@ -27,13 +27,12 @@ Examples
 
 import sys
 import os
-import argparse
 import numpy as np
 import rasterio
 from rasterio.transform import Affine
 from PySide6.QtWidgets import (
     QApplication, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, 
-    QScrollBar, QGraphicsPathItem, QVBoxLayout, QHBoxLayout, QWidget, QStatusBar
+    QScrollBar, QGraphicsPathItem, QVBoxLayout, QWidget, QStatusBar
 )
 from PySide6.QtGui import QImage, QPixmap, QPainter, QPen, QColor, QPainterPath
 from PySide6.QtCore import Qt
@@ -41,8 +40,10 @@ from PySide6.QtCore import Qt
 import matplotlib.cm as cm
 import warnings
 warnings.filterwarnings("ignore", category=RuntimeWarning, module="shapely")
+warnings.filterwarnings("ignore", category=UserWarning, module="rasterio")
+warnings.filterwarnings("ignore", category=UserWarning, module="xarray")
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"
 
 # Optional overlay deps
 try:
@@ -166,9 +167,13 @@ class TiffViewer(QMainWindow):
         rgb: list[int] | None = None,
         rgbfiles: list[str] | None = None,
         shapefiles: list[str] | None = None,
-        shp_color: str = "white",
+        shp_color: str = "cyan",
         shp_width: float = 2,
         subset: int | None = None,
+        vmin: float | None = None,
+        vmax: float | None = None,
+        cartopy: str = "on",
+        timestep: int | None = None,
     ):
         super().__init__()
 
@@ -177,6 +182,13 @@ class TiffViewer(QMainWindow):
         self.band = int(band)
         self.rgb = rgb
         self.rgbfiles = rgbfiles
+        self._user_vmin = vmin
+        self._user_vmax = vmax
+        self.cartopy_mode = cartopy.lower()
+
+        if not tif_path and not rgbfiles:
+           print("Usage: viewtif <file.tif>")
+           sys.exit(1)
 
         self._scale_arg = max(1, int(scale or 1))
         self._transform: Affine | None = None
@@ -206,20 +218,53 @@ class TiffViewer(QMainWindow):
             self.data = arr
             self.band_count = 3
             self.rgb = [os.path.basename(red), os.path.basename(green), os.path.basename(blue)]
-            # Use common prefix for title if tif_path not passed
             self.tif_path = self.tif_path or (os.path.commonprefix([red, green, blue]) or red)
 
         elif tif_path:
-            # --- Warn for large files before loading ---
-            warn_if_large(tif_path, scale=self._scale_arg)
 
-            # --------------------- Detect NetCDF --------------------- #
-            if tif_path and tif_path.lower().endswith((".nc", ".netcdf")):
+            # ---------------- Handle File Geodatabase (.gdb) ---------------- #
+            if tif_path.lower().endswith(".gdb") and ":" not in tif_path:
+                
+                import re, subprocess
+                gdb_path = tif_path
+
                 try:
-                    # Lazy-load NetCDF dependencies
-                    import xarray as xr
-                    import pandas as pd
-                    
+                    out = subprocess.check_output(
+                        ["gdalinfo", "-norat", gdb_path],
+                        text=True
+                    )
+                    rasters = re.findall(r"RASTER_DATASET=(\S+)", out)
+
+                    if not rasters:
+                        print(f"[WARN] No raster datasets found in {os.path.basename(gdb_path)}.")
+                        sys.exit(0)
+
+                    print(f"Found {len(rasters)} raster dataset{'s' if len(rasters) > 1 else ''}:")
+                    for i, r in enumerate(rasters):
+                        print(f"[{i}] {r}")
+
+                    print("\nUse one of these names to open. For example, to open the first raster:")
+                    print(f'viewtif "OpenFileGDB:{gdb_path}:{rasters[0]}"')
+                    sys.exit(0)
+
+                except (subprocess.CalledProcessError, FileNotFoundError) as e:
+                    print("[ERROR] This file requires full GDAL support.")
+                    sys.exit(1)
+
+            # Warn for large files
+            warn_if_large(tif_path, scale=self._scale_arg)
+
+            # ---------------------------------------------------------------
+            # Detect NetCDF
+            # ---------------------------------------------------------------
+            if tif_path.lower().endswith((".nc", ".netcdf")):
+                    try:
+                        import xarray as xr
+                    except ModuleNotFoundError:
+                        print("NetCDF support requires extra dependencies.")
+                        print("Install them with: pip install viewtif[netcdf]")
+                        sys.exit(0)
+
                     # Open the NetCDF file
                     ds = xr.open_dataset(tif_path)
                     
@@ -249,11 +294,11 @@ class TiffViewer(QMainWindow):
                     
                     # Get coordinate info if available
                     self._has_geo_coords = False
-                    if 'lon' in ds.coords and 'lat' in ds.coords:
+                    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:
+                    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
@@ -261,29 +306,18 @@ class TiffViewer(QMainWindow):
                     # 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_dim_name = "time"
+                        self._time_values = ds["time"].values
                         self._time_index = 0
                         print(f"NetCDF time dimension detected: {len(self._time_values)} steps")
-
-                        self.band_count = var_data.sizes['time']
+                        self.band_count = var_data.sizes["time"]
                         self.band_index = 0
-                        self._time_dim_name = 'time'
+                        var_data = var_data.isel(time=0)
 
-                        # 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']
@@ -292,111 +326,73 @@ class TiffViewer(QMainWindow):
                                 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})
+                                self._time_index = 0
+                                var_data = var_data.isel({dim: 0})
                                 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 ---
+                    arr = np.squeeze(arr)
+
+                    # --------------------------------------------------------
+                    # Apply timestep jump after base array is created
+                    # --------------------------------------------------------
+                    if timestep is not None and self._has_time_dim:
+                        ts = max(1, min(timestep, self.band_count))
+                        self.band_index = ts - 1
+                        print(f"[INFO] Jumping to timestep {ts}/{self.band_count}")
+
+                        # Replace arr with the correct slice
+                        frame = self._nc_var_data.isel({self._time_dim_name: self.band_index})
+                        arr = np.squeeze(frame.values.astype(np.float32))
+
                     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 ---
+                            arr = arr[::step, ::step]
+
                     self.data = arr
                     
                     # Try to extract CRS from CF conventions
                     self._transform = None
                     self._crs = None
-                    if 'crs' in ds.variables:
+
+                    if "crs" in ds.variables:
                         try:
                             import rasterio.crs
-                            crs_var = ds.variables['crs']
-                            if hasattr(crs_var, 'spatial_ref'):
+                            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:
+
+                    # Preserve time dimension if detected earlier
+                    if not self._has_time_dim:
                         self.band_count = 1
-                    
-                    self.band_index = 0
+                        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
+
+                    if self._user_vmin is not None:
+                        self.vmin = self._user_vmin
+                    if self._user_vmax is not None:
+                        self.vmax = self._user_vmax
+
                     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:
-                import re, subprocess
-                gdb_path = tif_path  # use full path to .gdb
-                try:
-                    out = subprocess.check_output(["gdalinfo", "-norat", gdb_path], text=True)
-                    rasters = re.findall(r"RASTER_DATASET=(\S+)", out)
-                    if not rasters:
-                        print(f"[WARN] No raster datasets found in {os.path.basename(gdb_path)}.")
-                        sys.exit(0)
-                    else:
-                        print(f"Found {len(rasters)} raster dataset{'s' if len(rasters) > 1 else ''}:")
-                        for i, r in enumerate(rasters):
-                            print(f"[{i}] {r}")
-                        print("\nUse one of these names to open. For example, to open the first raster:")
-                        print(f'viewtif "OpenFileGDB:{gdb_path}:{rasters[0]}"')
-                        sys.exit(0)
-                except subprocess.CalledProcessError as e:
-                    print(f"[WARN] Could not inspect FileGDB: {e}")
-                    sys.exit(0)
 
-            # # --- 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")):
+            # ---------------------------------------------------------------
+            # Detect HDF or HDF5
+            # ---------------------------------------------------------------
+            elif tif_path.lower().endswith((".hdf", ".h5", ".hdf5")):
                 try:
-                    # Try GDAL first (best support for HDF subdatasets)
                     from osgeo import gdal
-                    gdal.UseExceptions()
+                    # gdal.UseExceptions()
 
                     ds = gdal.Open(tif_path)
                     subs = ds.GetSubDatasets()
 
                     if not subs:
-                        raise ValueError("No subdatasets found in HDF/HDF5 file.")
+                        raise ValueError("No subdatasets found in HDF file.")
 
                     # Only list subsets if --subset not given
                     if subset is None:
@@ -408,18 +404,15 @@ class TiffViewer(QMainWindow):
 
                     # Validate subset index
                     if subset < 0 or subset >= len(subs):
-                        raise ValueError(f"Invalid subset index {subset}. Valid range: 0–{len(subs)-1}")
+                        raise ValueError(f"Invalid subset index {subset}.")
 
                     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))
@@ -435,93 +428,46 @@ class TiffViewer(QMainWindow):
                         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 getattr(self, "_scale_arg", 1) > 1:
+                        print(f"[INFO] Value range (scaled): {self.vmin:.3f} -> {self.vmax:.3f}")
+                    else:
+                        print(f"[INFO] Value range: {self.vmin:.3f} -> {self.vmax:.3f}")
 
-                    if self.band_count > 1:
-                        print(f"This subdataset has {self.band_count} bands — switch with [ and ] keys.")
+                except ImportError as e:
+                    if "osgeo" in str(e):
+                        print("[ERROR] This file requires full GDAL support.")
+                        # print("Install GDAL with:")
+                        # print("  conda install -c conda-forge gdal")
+                        sys.exit(1)
                     else:
-                        print("This subdataset has 1 band.")
+                        print(f"Error reading HDF file: {e}")
+                        sys.exit(1)
 
-                        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 Exception as e:
+                    print(f"Error reading HDF file: {e}")
+                    sys.exit(1)
 
-                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(
-                            f"Failed to read HDF/NetCDF file: {e}\n"
-                            "For full HDF support, install GDAL: pip install GDAL"
-                        )
-
-            # --------------------- Regular GeoTIFF --------------------- #
+            # ---------------------------------------------------------------
+            # Regular TIFF
+            # ---------------------------------------------------------------
             else:
-                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)}"
-
                 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:
-                        bands = [src.read(b, out_shape=(src.height // self._scale_arg, src.width // self._scale_arg))
-                                for b in rgb]
+                        bands = [
+                            src.read(b, out_shape=(src.height // self._scale_arg, src.width // self._scale_arg))
+                            for b in rgb
+                        ]
+                        
                         arr = np.stack(bands, axis=-1).astype(np.float32)
                         nd = src.nodata
                         if nd is not None:
@@ -539,7 +485,14 @@ class TiffViewer(QMainWindow):
                         self.data = arr
                         self.band_count = src.count
 
-                        # single-band display range (fast stats or fallback)
+                        if self.band_count == 1:
+                            print("[INFO] This TIFF has 1 band.")
+                        else:
+                            print(
+                                f"[INFO] This TIFF has {self.band_count} bands. "
+                                "Use [ and ] to switch bands, or use --rgb R G B."
+                            )
+
                         try:
                             stats = src.stats(self.band)
                             if stats and stats.min is not None and stats.max is not None:
@@ -548,9 +501,10 @@ class TiffViewer(QMainWindow):
                                 raise ValueError("No stats in file")
                         except Exception:
                             self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
-
-        else:
-            raise ValueError("Provide a TIFF path or --rgbfiles.")
+                            if getattr(self, "_scale_arg", 1) > 1:
+                                print(f"[INFO] Value range (scaled): {self.vmin:.3f} -> {self.vmax:.3f}")
+                            else:
+                                print(f"[INFO] Value range: {self.vmin:.3f} -> {self.vmax:.3f}")
 
         # Window title
         self.update_title()
@@ -560,7 +514,6 @@ 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
@@ -593,7 +546,9 @@ class TiffViewer(QMainWindow):
         self._last_rgb = None
 
         # --- Initial render ---
+        self._suppress_scale_print = True # Need for NetCDF
         self.update_pixmap()
+        self._suppress_scale_print = False # Need for NetCDF
 
         # Overlays (if any)
         if self._shapefiles:
@@ -604,9 +559,32 @@ class TiffViewer(QMainWindow):
         if self.pixmap_item is not None:
             rect = self.pixmap_item.boundingRect()
             self.scene.setSceneRect(rect)
+
+            # Fit first
             self.view.fitInView(self.pixmap_item, Qt.AspectRatioMode.KeepAspectRatioByExpanding)
-            self.view.scale(5, 5)
+
+            # ----------------------------
+            # NetCDF needs a different scaling (appears smaller)
+            # ----------------------------
+            if hasattr(self, "_nc_var_name"):
+                # NetCDF view adjustment
+                self.view.scale(11.0, 11.0)
+            else:
+                # Default behavior for TIFF/HDF imagery
+                self.view.scale(7.0, 7.0)
+
             self.view.centerOn(self.pixmap_item)
+            
+        # Previous version below
+        # # --- Initial render ---
+        # self.update_pixmap()
+        # self.resize(1200, 800) 
+        # if self.pixmap_item is not None:
+        #     rect = self.pixmap_item.boundingRect()
+        #     self.scene.setSceneRect(rect)
+        #     self.view.fitInView(self.pixmap_item, Qt.AspectRatioMode.KeepAspectRatioByExpanding)
+        #     self.view.scale(5, 5)
+        #     self.view.centerOn(self.pixmap_item)
 
     # ---------------------------- Overlays ---------------------------- #
     def _geo_to_pixel(self, x: float, y: float):
@@ -730,23 +708,40 @@ class TiffViewer(QMainWindow):
 
     # ----------------------- Title / Rendering ----------------------- #
     def update_title(self):
-        """Show correct title for GeoTIFF or NetCDF time series."""
+        """Add band before the title."""
         import os
+        file_name = os.path.basename(self.tif_path)
 
         if hasattr(self, "_has_time_dim") and self._has_time_dim:
-            nc_name = getattr(self, "_nc_var_name", "")
-            file_name = os.path.basename(self.tif_path)
+            # nc_name = getattr(self, "_nc_var_name", "")
+            
             title = f"Time step {self.band_index + 1}/{self.band_count} — {file_name}"
+            
 
         elif hasattr(self, "band_index"):
-            title = 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} — {file_name}"
+
+        elif self.rgb_mode:
+           
+            # Case 1: --rgbfiles → filenames
+            if self.rgbfiles:
+                files = [os.path.basename(p) for p in self.rgbfiles]
+                title = f"RGB ({files[0]}, {files[1]}, {files[2]})"
+
+            # Case 2: --rgb → band numbers
+            elif self.rgb:
+                r, g, b = self.rgb
+                title = f"RGB ({r}, {g}, {b}) — {file_name}"
+
+            else:
+                title = f"RGB — {file_name}"
 
-        elif self.rgb_mode and self.rgb:
-            # title = f"RGB {self.rgb} — {os.path.basename(self.tif_path)}"
-            title = f"RGB {self.rgb}"
+        elif not self.rgb_mode:
+            # TIFF uses self.band
+            title = f"Band {self.band}/{self.band_count} — {file_name}"
 
         else:
-            title = os.path.basename(self.tif_path)
+            title = {file_name}
 
         print(f"Title: {title}")
         self.setWindowTitle(title)
@@ -793,7 +788,8 @@ class TiffViewer(QMainWindow):
             return frame
 
         step = int(self._scale_arg)
-        print(f"Applying scale factor {step} to current frame")
+        if not hasattr(self, "_suppress_scale_print"):
+            print(f"Applying scale factor {self._scale_arg} to current frame")
 
         # Downsample the frame
         frame = frame[::step, ::step]
@@ -828,10 +824,6 @@ class TiffViewer(QMainWindow):
         if hasattr(frame, "values"):
             frame = frame.values
 
-        # Apply same scaling factor (if any)
-        if hasattr(self, "_scale_arg") and self._scale_arg > 1:
-            step = int(self._scale_arg)
-
         return frame.astype(np.float32)
         
     def format_time_value(self, time_value):
@@ -858,118 +850,6 @@ class TiffViewer(QMainWindow):
             pass
             
         return time_str
-            
-    # def update_time_label(self):
-    #     """Update the time label with the current time value"""
-    #     if hasattr(self, '_has_time_dim') and self._has_time_dim:
-    #         try:
-    #             time_value = self._time_values[self._time_index]
-    #             time_str = self.format_time_value(time_value)
-                
-    #             # Update time label if it exists
-    #             if hasattr(self, 'time_label'):
-    #                 self.time_label.setText(f"Time: {time_str}")
-                
-    #             # Create a progress bar style display of time position
-    #             total = len(self._time_values)
-    #             position = self._time_index + 1
-    #             bar_width = 20  # Width of the progress bar
-    #             filled = int(bar_width * position / total)
-    #             bar = "[" + "#" * filled + "-" * (bar_width - filled) + "]"
-                
-    #             # Show time info in status bar
-    #             step_info = f"Time step: {position}/{total} {bar} {self.format_time_value(self._time_values[self._time_index])}"
-                
-    #             # Update status bar if it exists
-    #             if hasattr(self, 'statusBar') and callable(self.statusBar):
-    #                 self.statusBar().showMessage(step_info)
-    #             else:
-    #                 print(step_info)
-    #         except Exception as e:
-    #             print(f"Error updating time label: {e}")
-            
-    # def toggle_play_pause(self):
-    #     """Toggle play/pause animation of time steps"""
-    #     if self._is_playing:
-    #         self.stop_animation()
-    #     else:
-    #         self.start_animation()
-    
-    # def start_animation(self):
-    #     """Start the time animation"""
-    #     from PySide6.QtCore import QTimer
-        
-    #     if not hasattr(self, '_play_timer') or self._play_timer is None:
-    #         self._play_timer = QTimer(self)
-    #         self._play_timer.timeout.connect(self.animation_step)
-        
-    #     # Set animation speed (milliseconds between frames)
-    #     animation_speed = 500  # 0.5 seconds between frames
-    #     self._play_timer.start(animation_speed)
-        
-    #     self._is_playing = True
-    #     self.play_button.setText("⏸")  # Pause symbol
-    #     self.play_button.setToolTip("Pause animation")
-    
-    # def stop_animation(self):
-    #     """Stop the time animation"""
-    #     if hasattr(self, '_play_timer') and self._play_timer is not None:
-    #         self._play_timer.stop()
-        
-    #     self._is_playing = False
-    #     self.play_button.setText("▶")  # Play symbol
-    #     self.play_button.setToolTip("Play animation")
-    
-    # def animation_step(self):
-    #     """Advance one frame in the animation"""
-    #     # Go to next time step
-    #     next_time = (self._time_index + 1) % len(self._time_values)
-    #     self.time_slider.setValue(next_time)
-    
-    # def closeEvent(self, event):
-    #     """Clean up resources when the window is closed"""
-    #     # Stop animation timer if it's running
-    #     if hasattr(self, '_is_playing') and self._is_playing:
-    #         self.stop_animation()
-        
-    #     # Call the parent class closeEvent
-    #     super().closeEvent(event)
-            
-    # def populate_date_combo(self):
-    #     """Populate the date combo box with time values"""
-    #     if hasattr(self, '_has_time_dim') and self._has_time_dim and hasattr(self, 'date_combo'):
-    #         try:
-    #             self.date_combo.clear()
-                
-    #             # Add a reasonable subset of dates if there are too many
-    #             max_items = 100  # Maximum number of items to show in dropdown
-                
-    #             if len(self._time_values) <= max_items:
-    #                 # Add all time values
-    #                 for i, time_value in enumerate(self._time_values):
-    #                     time_str = self.format_time_value(time_value)
-    #                     self.date_combo.addItem(time_str, i)
-    #             else:
-    #                 # Add a subset of time values
-    #                 step = len(self._time_values) // max_items
-                    
-    #                 # Always include first and last
-    #                 indices = list(range(0, len(self._time_values), step))
-    #                 if (len(self._time_values) - 1) not in indices:
-    #                     indices.append(len(self._time_values) - 1)
-                    
-    #                 for i in indices:
-    #                     time_str = self.format_time_value(self._time_values[i])
-    #                     self.date_combo.addItem(f"{time_str} [{i+1}/{len(self._time_values)}]", i)
-    #         except Exception as e:
-    #             print(f"Error populating date combo: {e}")
-                    
-    # def date_combo_changed(self, index):
-    #     """Handle date combo box selection change"""
-    #     if index >= 0:
-    #         time_index = self.date_combo.itemData(index)
-    #         if time_index is not None:
-    #             self.time_slider.setValue(time_index)
 
     def _render_rgb(self):
         if self.rgb_mode:
@@ -999,7 +879,7 @@ class TiffViewer(QMainWindow):
             return rgb
 
     def _render_cartopy_map(self, data):
-        """Render a NetCDF variable with cartopy for better geographic visualization"""
+        """ Use cartopy for better visualization"""
         import matplotlib.pyplot as plt
         from matplotlib.backends.backend_agg import FigureCanvasAgg
         import cartopy.crs as ccrs
@@ -1014,7 +894,6 @@ class TiffViewer(QMainWindow):
         lats = self._lat_data
         
         # Create contour plot
-        levels = 20
         if hasattr(plt.cm, self.cmap_name):
             cmap = getattr(plt.cm, self.cmap_name)
         else:
@@ -1033,8 +912,6 @@ class TiffViewer(QMainWindow):
         norm_data = np.power(norm_data, self.gamma)
         norm_data = norm_data * rng + vmin
         
-        # Downsample coordinates to match downsampled data shape
-        # --- Align coordinates with data shape (no stepping assumptions) ---
         # Downsample coordinates to match downsampled data shape
         data_height, data_width = data.shape[:2]
         lat_samples = len(lats)
@@ -1057,27 +934,37 @@ class TiffViewer(QMainWindow):
                 # print("[DEBUG] 2D lat grid ascending → flip lats_downsampled vertically")
                 lats_downsampled = np.flipud(lats_downsampled)
 
-        # Convert 0–360 longitude to −180–180 if needed
-        if lons_downsampled.max() > 180:
-            lons_downsampled = ((lons_downsampled + 180) % 360) - 180
+        # ---- Fix longitude and sort correctly ----
+        lons_ds = lons_downsampled.copy()
 
+        # Convert 0–360 → -180–180 only once
+        if lons_ds.max() > 180:
+            lons_ds = ((lons_ds + 180) % 360) - 180
 
-        # --- Build meshgrid AFTER any flip ---
-        lon_grid, lat_grid = np.meshgrid(lons_downsampled, lats_downsampled, indexing="xy")
+        # Sort and reorder data
+        sort_idx = np.argsort(lons_ds)
+        lons_ds = lons_ds[sort_idx]
+        data = data[:, sort_idx]
 
-        # Use pcolormesh (more stable than contourf for gridded data)
-        img = ax.pcolormesh(
-            lon_grid, lat_grid, data,
-            transform=ccrs.PlateCarree(),
-            cmap=cmap,
-            shading="auto"
+        extent = (
+            float(lons_ds[0]),
+            float(lons_ds[-1]),
+            float(lats_downsampled[-1]),
+            float(lats_downsampled[0])
         )
 
-        # Set extent from the 1D vectors (already flipped if needed)
-        ax.set_extent(
-            [lons_downsampled.min(), lons_downsampled.max(),
-            lats_downsampled.min(), lats_downsampled.max()],
-            crs=ccrs.PlateCarree()
+        vmin = self.vmin if self._user_vmin is not None else np.nanmin(data)
+        vmax = self.vmax if self._user_vmax is not None else np.nanmax(data)
+ 
+ # Changed from pcolormesh to imshow to prevent artefacts when used with cartopy
+        img = ax.imshow(
+            data,
+            extent=extent,
+            transform=ccrs.PlateCarree(),
+            cmap=cmap,
+            interpolation="nearest",
+            vmin=vmin,
+            vmax=vmax
         )
 
         # Add map features
@@ -1115,43 +1002,65 @@ class TiffViewer(QMainWindow):
         
         # Close figure to prevent memory leak
         plt.close(fig)
+        del fig
         
         return rgb
-        
+    
     def update_pixmap(self):
-        # --- Select display data ---
-        if hasattr(self, "band_index"):
-            # HDF or scientific multi-band
-            if self.data.ndim == 3:
-                a = self.data[:, :, self.band_index]
-            else:
-                a = self.data
-            rgb = None
+    # ------------------------------------------------------------------
+    # Select respective data (a = single-band 2D, rgb = RGB array)
+    # ------------------------------------------------------------------
+
+        rgb = None  # ensure defined
+
+        # Case 1: RGB override (GeoTIFF or RGB-files)
+        if self.rgb_mode:
+            rgb = self.data
+            a = None
+
+        # Case 2: Scientific multi-band (NetCDF/HDF)
+        elif hasattr(self, "band_index"):
+            # Always get consistent per-frame 2D data
+            a = self.get_current_frame()
+
+        # Case 3: Regular GeoTIFF single-band
         else:
-            # Regular GeoTIFF (could be RGB or single-band)
-            if self.rgb_mode:  # user explicitly passed --rgb or --rgbtiles
-                rgb = self.data
-                a = None
-            else:
-                a = self.data
-                rgb = None
-        # ----------------------------
+            rgb = None
+            a = self.data
 
         # --- Render image ---
-        # Check if we should use cartopy for NetCDF visualization
+        # Cartopy is only relevant for NetCDF
         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 hasattr(self, "_nc_var_name"):
+            use_cartopy = (
+                self.cartopy_mode == "on"
+                and HAVE_CARTOPY
+                and getattr(self, "_use_cartopy", False)
+                and getattr(self, "_has_geo_coords", False)
+            )
+
+            # Inform user when cartopy was requested but cannot be used
+            if self.cartopy_mode == "on" and not use_cartopy:
+                if not HAVE_CARTOPY:
+                    print("[INFO] Cartopy not installed — using standard scientific rendering.")
+                elif not getattr(self, "_use_cartopy", False):
+                    print("[INFO] This file lacks geospatial coordinates — cartopy disabled.")
+                elif not getattr(self, "_has_geo_coords", False):
+                    print("[INFO] No lat/lon coordinates found — cartopy disabled.")
+
         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
+            # Standard grayscale rendering for single-band data
             finite = np.isfinite(a)
-            vmin, vmax = np.nanmin(a), np.nanmax(a)
+
+            # Respect user-specified limits
+            vmin = self._user_vmin if self._user_vmin is not None else np.nanmin(a)
+            vmax = self._user_vmax if self._user_vmax is not None else np.nanmax(a)
+            
             rng = max(vmax - vmin, 1e-12)
+
             norm = np.zeros_like(a, dtype=np.float32)
             if np.any(finite):
                 norm[finite] = (a[finite] - vmin) / rng
@@ -1162,13 +1071,15 @@ class TiffViewer(QMainWindow):
         else:
             # True RGB mode (unchanged)
             rgb = self._render_rgb()
-        # ----------------------
 
         h, w, _ = rgb.shape
         self._last_rgb = rgb
+
         qimg = QImage(rgb.data, w, h, 3 * w, QImage.Format.Format_RGB888)
         pix = QPixmap.fromImage(qimg)
+        
         if self.pixmap_item is None:
+            
             self.pixmap_item = QGraphicsPixmapItem(pix)
             self.pixmap_item.setZValue(0.0)
             self.scene.addItem(self.pixmap_item)
@@ -1193,6 +1104,7 @@ class TiffViewer(QMainWindow):
             if nd is not None:
                 arr[arr == nd] = np.nan
             self.data = arr
+            
             self.vmin, self.vmax = np.nanmin(arr), np.nanmax(arr)
         self.update_pixmap()
         self.update_title()
@@ -1237,6 +1149,7 @@ class TiffViewer(QMainWindow):
             # For other files, toggle between two colormaps
             else:
                 self.cmap_name, self.alt_cmap_name = self.alt_cmap_name, self.cmap_name
+                print(f"Colormap: {self.cmap_name}")
             self.update_pixmap()
 
         # Band switch
@@ -1297,12 +1210,14 @@ def run_viewer(
     shapefile=None,
     shp_color=None,
     shp_width=None,
-    subset=None
+    subset=None,    
+    vmin=None,
+    vmax=None,
+    cartopy="on",
+    timestep=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,
@@ -1313,7 +1228,11 @@ def run_viewer(
         shapefiles=shapefile,
         shp_color=shp_color,
         shp_width=shp_width,
-        subset=subset
+        subset=subset,
+        vmin=vmin,
+        vmax=vmax,
+        cartopy=cartopy,
+        timestep=timestep,
     )
     win.show()
     sys.exit(app.exec())
@@ -1321,17 +1240,34 @@ def run_viewer(
 import click
 
 @click.command()
-@click.version_option("0.2.4", prog_name="viewtif")
+@click.version_option(__version__, prog_name="viewtif")
 @click.argument("tif_path", required=False)
 @click.option("--band", default=1, show_default=True, type=int, help="Band number to display")
 @click.option("--scale", default=1.0, show_default=True, type=int, help="Scale factor for display")
 @click.option("--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-color", default="cyan", show_default=True, help="Overlay color (name or #RRGGBB).")
 @click.option("--shp-width", default=1.0, show_default=True, type=float, help="Overlay line width (screen pixels).")
 @click.option("--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):
+@click.option("--vmin", type=float, default=None, help="Manual minimum display value")
+@click.option("--vmax", type=float, default=None, help="Manual maximum display value")
+@click.option(
+    "--timestep",
+    type=int,
+    default=None,
+    help="For NetCDF files, jump directly to a specific time index (1-based)."
+)
+@click.option(
+    "--cartopy",
+    type=click.Choice(["on", "off"], case_sensitive=False),
+    default="on",
+    show_default=True,
+    help="Use cartopy for NetCDF geospatial rendering."
+)
+
+
+def main(tif_path, band, scale, rgb, rgbfiles, shapefile, shp_color, shp_width, subset, vmin, vmax, cartopy, timestep):
     """Lightweight GeoTIFF, NetCDF, and HDF viewer."""
     # --- Warn early if shapefile requested but geopandas missing ---
     if shapefile and not HAVE_GEO:
@@ -1350,7 +1286,11 @@ 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,
+        vmin=vmin,
+        vmax=vmax,
+        cartopy=cartopy,
+        timestep=timestep,
     )
 
 if __name__ == "__main__":

{viewtif-0.2.4.dist-info → viewtif-0.2.6.dist-info}/METADATA

@@ -1,13 +1,14 @@
 Metadata-Version: 2.4
 Name: viewtif
-Version: 0.2.4
+Version: 0.2.6
 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
 Author: Keiko Nomura
 License: MIT
-Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Python: >=3.10
 Requires-Dist: click>=8.1
 Requires-Dist: matplotlib>=3.7
 Requires-Dist: numpy>=1.23
@@ -26,6 +27,7 @@ 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 version](https://img.shields.io/badge/python-%3E%3D3.10-blue.svg)](https://pypi.org/project/viewtif/)
 
 A lightweight GeoTIFF viewer for quick visualization directly from the command line.  
 
@@ -36,7 +38,7 @@ You can visualize single-band GeoTIFFs, RGB composites, HDF, NetCDF files and sh
 ```bash
 pip install viewtif
 ```
-> **Note:** On Linux, you may need python3-tk, libqt5gui5, or PySide6 dependencies.
+> **Note:** Requires Python 3.10 or higher. On Linux, you may need python3-tk, libqt5gui5, or PySide6 dependencies.
 > 
 >`viewtif` requires a graphical display environment.  
 > It may not run properly on headless systems (e.g., HPC compute nodes or remote servers without X11 forwarding).
@@ -49,19 +51,20 @@ 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 
+#### NetCDF support 
+```bash
+pip install  "viewtif[netcdf]"
+```
+> **Note:** For enhanced geographic visualization with map projections, coastlines, and borders, install with cartopy: `pip install "viewtif[netcdf]"` (cartopy is included in the netcdf extra). If cartopy is not available, netCDF files will still display with standard rendering.
+
+#### HDF/HDF5 & FileGDB support 
+GDAL is required to open `.hdf`, .`h5`, `.hdf5`, and `.gdb` files. 
 ```bash
 brew install gdal     # macOS
 sudo apt install gdal-bin python3-gdal  # Linux
 pip install GDAL
 ```
-> **Note:** GDAL is required to open `.hdf`, .`h5`, and `.hdf5` files. If it’s missing, viewtif will display: `RuntimeError: HDF support requires GDAL.`
 
-#### NetCDF support 
-```bash
-brew install  "viewtif[netcdf]"
-```
-> **Note:** For enhanced geographic visualization with map projections, coastlines, and borders, install with cartopy: `pip install "viewtif[netcdf]"` (cartopy is included in the netcdf extra). If cartopy is not available, netCDF files will still display with standard RGB rendering.
 ## Quick Start
 ```bash
 # View a GeoTIFF
@@ -73,9 +76,16 @@ viewtif --rgbfiles \
   HLS_B03.tif \
   HLS_B02.tif
 
+# View an RGB composite from a multi-band file
+viewtif rgb.tif --rgb 4 3 2
+
 # View with shapefile overlay
 viewtif ECOSTRESS_LST.tif \
   --shapefile Zip_Codes.shp
+
+# Change the color and width
+viewtif ECOSTRESS_LST.tif \
+  --shapefile Zip_Codes.shp --shp-color red --shp-width 2
 ```
 ### Update in v1.0.6: HDF/HDF5 support
 `viewtif` can open `.hdf`, `.h5`, and `.hdf5` files that contain multiple subdatasets. When opened, it lists available subdatasets and lets you view one by index. You can also specify a band to display (default is the first band) or change bands interactively with '[' and ']'.
@@ -93,11 +103,7 @@ viewtif AG100.v003.33.-107.0001.h5 --subset 1 --band 3
 `[WARN] raster lacks CRS/transform; cannot place overlays.`
 
 ### Update in v1.0.7: File Geodatabase (.gdb) support
-`viewtif` can now open raster datasets stored inside Esri File Geodatabases (`.gdb`). When you open a .gdb directly, `viewtif`` will list available raster datasets first, then you can choose one to view.
-
-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.
+`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.
 
 ```bash
 # List available raster datasets
@@ -114,16 +120,19 @@ If the dataset is very large (e.g., >20 million pixels), it will pause and warn
 You can proceed manually or rerun with the `--scale` option for a smaller, faster preview.
 
 ### Update in v0.2.2: NetCDF support with optional cartopy visualization
-`viewtif` now supports NetCDF (`.nc`) files with xarray and optional cartopy geographic visualization.
+`viewtif` now supports NetCDF (`.nc`) files via xarray, with optional cartopy-based geographic visualization. Use `[`  /  `]` to move forward or backward through time steps, and press M to switch between the three built-in colormaps ("RdBu_r", "viridis", "magma").
 
-#### Installation with NetCDF support
-```bash
-pip install "viewtif[netcdf]"
-```
+### Update in v0.2.6: New user controls for NetCDF visualization
+- `--vmin [value] --vmax [value]` let you set the display range (for all file types).
+- `--timestep [int]` lets you jump directly to a chosen time slice.
+- `cartopy off` let you see raw NetCDF images.
 
 #### Examples
 ```bash
 viewtif data.nc
+viewtif data.nc --vmin 280 --vmax 320
+viewtif data.nc --timestep 100
+viewtif data.nc --cartopy off
 ```
 
 ## Controls
@@ -133,7 +142,7 @@ viewtif data.nc
 | Arrow keys or `WASD` | Pan                                     |
 | `C` / `V`            | Increase / decrease contrast            |
 | `G` / `H`            | Increase / decrease gamma               |
-| `M`                  | Toggle colormap (`viridis` ↔ `magma`)   |
+| `M`                  | Toggle colormap. Single-band: viridis/magma. NetCDF: RdBu_r/viridis/magma.   |
 | `[` / `]`            | Previous / next band (or time step)     |
 | `R`                  | Reset view                              |
 
@@ -149,6 +158,8 @@ viewtif data.nc
 - Zip_Codes.shp and associated files
 - HLS_B04.tif, HLS_B03.tif, HLS_B02.tif (RGB sample)
 - AG100.v003.33.-107.0001.h5 (HDF5 file)
+- [tasmax_mon_ACCESS-CM2_ssp370_r1i1p1f1_gn_2021.nc](https://data.nas.nasa.gov/nex-dcp30-cmip6/monthly/ACCESS-CM2/ssp370/r1i1p1f1/tasmax/tasmax_mon_ACCESS-CM2_ssp370_r1i1p1f1_gn_2021.nc)
+- [tas_Amon_KIOST-ESM_ssp585_r1i1p1f1_gr1_201501-210012.nc](https://dap.ceda.ac.uk/badc/cmip6/data/CMIP6/ScenarioMIP/KIOST/KIOST-ESM/ssp585/r1i1p1f1/Amon/tas/gr1/v20191106/tas_Amon_KIOST-ESM_ssp585_r1i1p1f1_gr1_201501-210012.nc)
 
 ## Credit & License
 `viewtif` was inspired by the NASA JPL Thermal Viewer — Semi-Automated Georeferencer (GeoViewer v1.12) developed by Jake Longenecker (University of Miami Rosenstiel School of Marine, Atmospheric & Earth Science) while at the NASA Jet Propulsion Laboratory, California Institute of Technology, with inspiration from JPL’s ECOSTRESS geolocation batch workflow by Andrew Alamillo. The original GeoViewer was released under the MIT License (2025) and may be freely adapted with citation.
@@ -156,9 +167,18 @@ viewtif data.nc
 ## Citation
 Longenecker, Jake; Lee, Christine; Hulley, Glynn; Cawse-Nicholson, Kerry; Purkis, Sam; Gleason, Art; Otis, Dan; Galdamez, Ileana; Meiseles, Jacquelyn. GeoViewer v1.12: NASA JPL Thermal Viewer—Semi-Automated Georeferencer User Guide & Reference Manual. Jet Propulsion Laboratory, California Institute of Technology, 2025. PDF.
 
-## License
-This project is released under the MIT License.
-
 ## Contributors
 - [@HarshShinde0](https://github.com/HarshShinde0) — added mouse-wheel and trackpad zoom support; added NetCDF support with [@nkeikon](https://github.com/nkeikon) 
-- [@p-vdp](https://github.com/p-vdp) — added File Geodatabase (.gdb) raster support
+- [@p-vdp](https://github.com/p-vdp) — added File Geodatabase (.gdb) raster support
+
+## License
+This project is released under the MIT License © 2025 Keiko Nomura.
+
+If you find this tool useful, please consider supporting or acknowledging the author. 
+
+## Useful links
+- [Demo by User](https://www.linkedin.com/posts/desmond-lartey_geospatial-analysts-heads-up-check-out-activity-7386336488050925568-G5bN?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAA0INsBVIO1f6nS_NkKqFh4Na1ZpoYo2fc)
+- [Demo at the initial release](https://www.linkedin.com/posts/keiko-nomura-0231891_dont-you-sometimes-just-want-to-see-a-activity-7383409138296528896-sbRM?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAA0INsBVIO1f6nS_NkKqFh4Na1ZpoYo2fc)
+- [Demo on HDF files](https://www.linkedin.com/posts/keiko-nomura-0231891_now-you-can-see-hdf-files-from-the-command-activity-7383963721561399296-F5i0?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAA0INsBVIO1f6nS_NkKqFh4Na1ZpoYo2fc)
+- [Demo on NetCDF files](https://www.linkedin.com/posts/keiko-nomura-0231891_you-can-now-view-netcdf-files-nc-from-activity-7386189562072670208-3A0V?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAA0INsBVIO1f6nS_NkKqFh4Na1ZpoYo2fc)
+- [Demo on Esri Geodatabases](https://www.linkedin.com/posts/keiko-nomura-0231891_did-you-know-viewtif-now-supports-esri-geodatabases-activity-7390165568688959488-pvpk?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAA0INsBVIO1f6nS_NkKqFh4Na1ZpoYo2fc)

viewtif-0.2.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+viewtif/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+viewtif/tif_viewer.py,sha256=-vO-62ApjcG7lVVTHB5ggc9qSeB7YmdR1gmfskp-Vzg,51628
+viewtif-0.2.6.dist-info/METADATA,sha256=CJZC9X2CtZjzQTEVg_MKTKMGNS7Vq8hcTUFEQck0Er4,9541
+viewtif-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+viewtif-0.2.6.dist-info/entry_points.txt,sha256=NVEjlRyJ7R7hFPOVsZJio3Hl0VqlX7_oVfA7819XvHM,52
+viewtif-0.2.6.dist-info/licenses/LICENSE,sha256=-aRH3Wo6exTLQLNp9yj6HptkUXXtNjdUSzumkyRsK4s,1069
+viewtif-0.2.6.dist-info/RECORD,,

viewtif-0.2.6.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Keiko Nomura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

viewtif-0.2.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-viewtif/tif_viewer.py,sha256=a4fdzq8_r0YQ-LVoTiYv32WAxxuldCGhD9-pDJ1sEPA,57465
-viewtif-0.2.4.dist-info/METADATA,sha256=Ow100gbhTP6qtJBRl5MQT14brtDPusML9aupaMwPJ0k,7280
-viewtif-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-viewtif-0.2.4.dist-info/entry_points.txt,sha256=NVEjlRyJ7R7hFPOVsZJio3Hl0VqlX7_oVfA7819XvHM,52
-viewtif-0.2.4.dist-info/RECORD,,