feat: add Tanager STAC search dialog to QGIS plugin (#267)

* feat: add Tanager STAC search dialog to QGIS plugin

Adds a dockable Tanager search panel that lets users query Planet
Tanager STAC scenes, add footprint layers, open orthorectified visual
imagery, and download radiance HDF5 files directly from QGIS.

* feat: enhance Tanager search dialog and functionality with new asset handling and UI improvements

* feat: implement value range handling for Tanager data type in Load Data Dialog

* Address Copilot review feedback

- Add .hdf5 to DATA_TYPES["Tanager"]["extensions"] so the file browser
  filter exposes .hdf5 Tanager files, matching the new content-based
  detection in _detect_type().
- Track the last default applied to the value-range spinboxes in
  LoadDataDialog and add a preserve_user_edits flag to
  _apply_data_type_value_range. Preview and load completion now skip
  the default re-apply when the user has edited Min/Max since the last
  default, preventing custom visualization ranges from being clobbered
  before the layer is rendered.

* feat: enhance Tanager data handling with 2D geolocation extraction and default plot settings

* Fix PyQt6 import smoke test failure when matplotlib is unavailable

- Guard _apply_data_type_plot_defaults with a HAS_MATPLOTLIB check so
  add_spectrum() does not AttributeError on ylabel_combo when the
  dialog ran the matplotlib-less setup_ui() fallback (matches the
  pattern used by update_plot and similar methods).
- Skip test_spectral_plot_uses_tanager_radiance_defaults via
  pytest.importorskip("matplotlib") so the assertions only run in
  environments where the dialog widgets actually exist. The PyQt6
  import smoke CI job installs PyQt6 + numpy + Pillow only, not
  matplotlib, so the previous test crashed there.

* feat: update Tanager search dialog to handle footprints without GeoDataFrame and improve selection functionality

Author: giswqs

qgis_plugin/README.md

@@ -12,6 +12,8 @@ Check out this [short video demo](https://youtu.be/EEUAC5BxqtM) and [full video
 
 -   **Load Multiple Hyperspectral Formats**: Support for NASA EMIT, PACE, DESIS, NEON AOP, AVIRIS, PRISMA, EnMAP, Planet Tanager, Wyvern, and generic GeoTIFF/NetCDF hyperspectral data.
 
+-   **Tanager Search and Visualization**: Search Planet Tanager STAC scenes from QGIS, add footprint layers, open orthorectified visual imagery, and download orthorectified radiance HDF5 files for hyperspectral analysis.
+
 -   **Band Combination Visualization**: Easily change RGB band combinations using wavelength values. Includes presets for:
 
     -   True Color (RGB)
@@ -81,6 +83,14 @@ When QGIS is launched from this Conda environment, the plugin automatically dete
 4. Configure RGB wavelengths for visualization
 5. Click **Load Data**
 
+### Searching Tanager Data
+
+1. Click the **Search Tanager Data** button
+2. Use the current map extent or enter a bounding box
+3. Set optional date, collection, query, cloud, and count filters
+4. Click **Search**
+5. Add footprints, open the visual asset, or download the radiance HDF5 for analysis
+
 ### Changing Band Combinations
 
 1. Click the **Band Combination** button

qgis_plugin/hypercoast_qgis/dialogs/load_data_dialog.py

@@ -47,6 +47,9 @@
 )
 from ..cache_manager import create_generated_raster_path
 
+DEFAULT_VALUE_RANGE = (0.0, 0.5)
+TANAGER_VALUE_RANGE = (0.0, 100.0)
+
 
 class DatasetPreviewWorker(QThread):
     """Worker thread for loading dataset metadata without blocking QGIS."""
@@ -161,6 +164,10 @@ def __init__(self, iface, plugin, parent=None):
         self._preview_worker = None
         self._load_worker = None
         self._pending_load_context = None
+        # Track the last default the dialog applied to the value-range spinboxes
+        # so background callbacks can detect user edits and avoid overwriting
+        # them. Initialized to match the spinbox values set in setup_ui().
+        self._last_applied_value_range = (0.0, DEFAULT_VALUE_RANGE[1])
 
         self.setWindowTitle("Load Hyperspectral Data")
         self.setObjectName("HyperCoastLoadDataDock")
@@ -253,7 +260,7 @@ def setup_ui(self):
 
         self.vmax_spin = QDoubleSpinBox()
         self.vmax_spin.setRange(-1000, 1000)
-        self.vmax_spin.setValue(0.5)
+        self.vmax_spin.setValue(DEFAULT_VALUE_RANGE[1])
         self.vmax_spin.setDecimals(4)
         range_layout.addWidget(QLabel("Max:"))
         range_layout.addWidget(self.vmax_spin)
@@ -358,12 +365,61 @@ def browse_file(self):
             self.dataset = None
             self.info_text.clear()
             self._populate_variable_combo(None)
+            self._apply_data_type_value_range(
+                self._resolved_value_range_data_type(filepath)
+            )
 
     def _clear_dataset_preview(self, *args):
         """Clear loaded preview state after the requested data type changes."""
         self.dataset = None
         self.info_text.clear()
         self._populate_variable_combo(None)
+        self._apply_data_type_value_range(self._resolved_value_range_data_type())
+
+    def _resolved_value_range_data_type(self, filepath=None):
+        """Return the data type to use for visualization range defaults.
+
+        Args:
+            filepath: Optional data file path to inspect for auto-detection.
+
+        Returns:
+            Selected or auto-detected data type.
+        """
+        data_type = self.data_type_combo.currentData()
+        if data_type != "auto":
+            return data_type
+        filepath = filepath or self.file_path_edit.text()
+        if filepath and os.path.exists(filepath):
+            return HyperspectralDataset(filepath, "auto").data_type
+        return data_type
+
+    def _apply_data_type_value_range(self, data_type, preserve_user_edits=False):
+        """Apply visualization range defaults for a data type.
+
+        Args:
+            data_type: Resolved HyperCoast data type.
+            preserve_user_edits: When True, skip updating the spinboxes if the
+                user has changed them since the last default was applied. Use
+                this from background callbacks (preview/load completion) so
+                custom min/max values entered before the callback fired are
+                not overwritten.
+        """
+        vmin, vmax = (
+            TANAGER_VALUE_RANGE if data_type == "Tanager" else DEFAULT_VALUE_RANGE
+        )
+        if preserve_user_edits:
+            last_vmin, last_vmax = self._last_applied_value_range
+            current_vmin = self.vmin_spin.value()
+            current_vmax = self.vmax_spin.value()
+            tolerance = 10 ** -self.vmin_spin.decimals()
+            if (
+                abs(current_vmin - last_vmin) > tolerance
+                or abs(current_vmax - last_vmax) > tolerance
+            ):
+                return
+        self.vmin_spin.setValue(vmin)
+        self.vmax_spin.setValue(vmax)
+        self._last_applied_value_range = (vmin, vmax)
 
     def preview_dataset(self):
         """Preview the selected dataset."""
@@ -400,6 +456,9 @@ def _on_preview_finished(self, dataset, error_detail):
         try:
             if dataset is not None:
                 self.dataset = dataset
+                self._apply_data_type_value_range(
+                    dataset.data_type, preserve_user_edits=True
+                )
                 self.progress_bar.setValue(80)
                 self.info_text.setText(self._format_dataset_info(dataset))
                 self._populate_variable_combo(dataset)
@@ -620,6 +679,9 @@ def _on_load_finished(self, dataset, temp_path, error_detail):
                 raise ValueError(f"Failed to load dataset. Details: {error_detail}")
 
             self.dataset = dataset
+            self._apply_data_type_value_range(
+                self.dataset.data_type, preserve_user_edits=True
+            )
             self.progress_bar.setValue(80)
             selected_data_var = self.dataset.get_data_variable()
             selected_variable = variable_name or getattr(

qgis_plugin/hypercoast_qgis/dialogs/spectral_inspector_tool.py

@@ -165,7 +165,12 @@ def extract_spectrum_at_point(self, point):
                     # Update spectral plot dialog if open
                     if self.plugin.spectral_plot_dialog:
                         self.plugin.spectral_plot_dialog.add_spectrum(
-                            lat, lon, wavelengths, values, layer.name()
+                            lat,
+                            lon,
+                            wavelengths,
+                            values,
+                            layer.name(),
+                            data_info.get("data_type"),
                         )
 
                     QgsMessageLog.logMessage(

qgis_plugin/hypercoast_qgis/dialogs/spectral_plot_dialog.py

@@ -49,6 +49,9 @@
 except ImportError:
     HAS_MATPLOTLIB = False
 
+DEFAULT_Y_RANGE = (0.0, 0.5)
+TANAGER_Y_RANGE = (0.0, 100.0)
+
 
 class SpectralPlotDialog(QDockWidget):
     """Dockable panel for displaying spectral plots."""
@@ -134,6 +137,7 @@ def setup_ui(self):
             QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon
         )
         self.layer_combo.setSizePolicy(policy.Expanding, policy.Fixed)
+        self.layer_combo.currentIndexChanged.connect(self._on_selected_layer_changed)
         sampling_layout.addWidget(QLabel("Layer:"))
         sampling_layout.addWidget(self.layer_combo, 1)
 
@@ -188,14 +192,14 @@ def setup_ui(self):
 
         ylim_layout = QHBoxLayout()
         self.ymin_spin = QDoubleSpinBox()
-        self.ymin_spin.setRange(-1, 10)
-        self.ymin_spin.setValue(0)
+        self.ymin_spin.setRange(-1000, 10000)
+        self.ymin_spin.setValue(DEFAULT_Y_RANGE[0])
         self.ymin_spin.setDecimals(4)
         ylim_layout.addWidget(self.ymin_spin)
         ylim_layout.addWidget(QLabel("-"))
         self.ymax_spin = QDoubleSpinBox()
-        self.ymax_spin.setRange(-1, 10)
-        self.ymax_spin.setValue(0.5)
+        self.ymax_spin.setRange(-1000, 10000)
+        self.ymax_spin.setValue(DEFAULT_Y_RANGE[1])
         self.ymax_spin.setDecimals(4)
         ylim_layout.addWidget(self.ymax_spin)
         axis_form.addRow("Y Range:", ylim_layout)
@@ -324,6 +328,7 @@ def refresh_layer_combo(self):
                 self.layer_combo.setCurrentIndex(index)
 
         self.layer_combo.blockSignals(False)
+        self._apply_data_type_plot_defaults(self._selected_layer_data_type())
 
     def selected_layer_id(self):
         """Return the selected sampling layer ID.
@@ -335,6 +340,45 @@ def selected_layer_id(self):
             return None
         return self.layer_combo.currentData()
 
+    def _on_selected_layer_changed(self, *args):
+        """Apply plot defaults when the selected sampling layer changes."""
+        self._apply_data_type_plot_defaults(self._selected_layer_data_type())
+
+    def _selected_layer_data_type(self):
+        """Return the data type represented by the selected sampling layer.
+
+        Returns:
+            HyperCoast data type string, or ``None`` for mixed/unknown layers.
+        """
+        layer_id = self.selected_layer_id()
+        if layer_id:
+            data_info = self.plugin.get_hyperspectral_data(layer_id) or {}
+            return data_info.get("data_type")
+
+        data_types = {
+            (self.plugin.get_hyperspectral_data(layer_id) or {}).get("data_type")
+            for layer_id in self.plugin.get_all_hyperspectral_layers()
+        }
+        data_types.discard(None)
+        if len(data_types) == 1:
+            return next(iter(data_types))
+        return None
+
+    def _apply_data_type_plot_defaults(self, data_type):
+        """Apply axis label and range defaults for a data type.
+
+        Args:
+            data_type: HyperCoast data type string.
+        """
+        if not HAS_MATPLOTLIB or data_type != "Tanager":
+            return
+
+        index = self.ylabel_combo.findText("Radiance")
+        if index >= 0:
+            self.ylabel_combo.setCurrentIndex(index)
+        self.ymin_spin.setValue(TANAGER_Y_RANGE[0])
+        self.ymax_spin.setValue(TANAGER_Y_RANGE[1])
+
     def _project_layer(self, layer_id):
         """Return a QGIS project layer by ID.
 
@@ -351,22 +395,25 @@ def _project_layer(self, layer_id):
         except Exception:
             return None
 
-    def add_spectrum(self, lat, lon, wavelengths, values, layer_name):
+    def add_spectrum(self, lat, lon, wavelengths, values, layer_name, data_type=None):
         """Add a new spectrum to the plot.
 
         :param lat: Latitude
         :param lon: Longitude
         :param wavelengths: Array of wavelengths
         :param values: Array of spectral values
         :param layer_name: Name of the source layer
+        :param data_type: Optional HyperCoast data type.
         """
+        self._apply_data_type_plot_defaults(data_type)
         spectrum = {
             "lat": lat,
             "lon": lon,
             "wavelengths": np.array(wavelengths),
             "values": np.array(values),
             "layer": layer_name,
             "label": f"({lat:.4f}, {lon:.4f})",
+            "data_type": data_type,
         }
 
         self.spectra.append(spectrum)