fix(netcdf): let an RGB composite be sampled like a single band (#1723)

* fix(netcdf): let an RGB composite be sampled like a single band

Adding a NetCDF cube as an RGB composite added the layer but retained
nothing, so Identify stayed disabled and the spectral profile never
appeared. Register the composite's three channel grids and its cube
reader, report all three readings in the popup, and give the layer a band
summary in place of the colormap controls, which would otherwise re-bake
the composite as a single band.

* Address CodeRabbit review feedback

- Bounds-check row/column in gridValueAt: the helper is exported, and a
  column past a row's width would fold into the next row and report a real
  value from the wrong cell rather than the documented miss. Covers the
  out-of-range, negative, and non-integer cases with regression tests.

Author: giswqs

apps/geolibre-desktop/src/components/layout/AddNetcdfDialog.tsx

@@ -475,7 +475,7 @@ export function AddNetcdfDialog({ open, appApi, onOpenChange }: AddNetcdfDialogP
             scaleFactor: channels[0].scaleFactor,
             addOffset: channels[0].addOffset,
           });
-          addImageOverlayLayer(
+          const layerId = addImageOverlayLayer(
             `${baseName} - ${variable} (RGB)`,
             {
               url: encodeImageOverlay(image),
@@ -486,9 +486,25 @@ export function AddNetcdfDialog({ open, appApi, onOpenChange }: AddNetcdfDialogP
               // Without this the store defaults it to "kml-ground-overlay",
               // which every consumer of that marker would then act on.
               sourceKind: NETCDF_IMAGE_SOURCE_KIND,
-              metadata: { variable },
+              // Identify reads cell values, not features, exactly as the
+              // single-band path does; a composite reports all three channels.
+              metadata: { variable, pixelIdentify: true },
             },
           );
+          // A composite is by definition built on a band axis, so the file
+          // always stays open: it is what a click's spectral signature and the
+          // 3-D cube view are read from.
+          retainedFileRef.current = dataset.file;
+          registerNetcdfLayer(layerId, {
+            grid: channels[0],
+            variable,
+            ...(selectedVar?.units ? { units: selectedVar.units } : {}),
+            cube: cubeReader(dataset, variable, rgbAxis, selector),
+            rgb: {
+              bands: rgbBands,
+              channels: channels as [LocalNetcdfGrid, LocalNetcdfGrid, LocalNetcdfGrid],
+            },
+          });
           appApi.fitBounds?.(image.bounds);
         } else if (useImagePath) {
           // The grid itself, not just its pixels, so the Style panel can

apps/geolibre-desktop/src/components/panels/LayerPanel.tsx

@@ -221,7 +221,7 @@ import {
 } from "../../lib/postgis-connections";
 import { IS_MAS_BUILD } from "../../lib/build-flags";
 import { isTauri } from "../../lib/is-tauri";
-import { getNetcdfImageSource } from "../../lib/netcdf-image-symbology";
+import { getNetcdfLayerState } from "../../lib/netcdf-image-symbology";
 import { BasemapPickerDialog } from "./BasemapPickerDialog";
 import { LayerPanelPlaceSearch } from "./LayerPanelPlaceSearch";
 import { LayerSwatchIcon } from "./LayerSwatchIcon";
@@ -584,11 +584,13 @@ function hasNativeIdentifyLayers(layer: GeoLibreLayer): boolean {
   // registered by a plugin, but its values are held in memory and read directly
   // by useNetcdfIdentify. Named here rather than given a synthetic
   // `nativeLayerIds`, which would make layer-sync treat it as plugin-owned and
-  // stop drawing it. Gated on the grid actually being retained: an RGB
-  // composite shares the source kind but registers none, and a reload drops it,
-  // and offering Identify that answers nothing is worse than not offering it.
+  // stop drawing it. Gated on the grids actually being retained — a project
+  // reload drops them — since offering Identify that answers nothing is worse
+  // than not offering it. Deliberately the layer state rather than
+  // `getNetcdfImageSource`, which is null for an RGB composite: that has no
+  // colormap to re-apply but does have three channels a click can read.
   if (layer.metadata.sourceKind === NETCDF_IMAGE_SOURCE_KIND) {
-    return getNetcdfImageSource(layer.id) !== null;
+    return getNetcdfLayerState(layer.id) !== null;
   }
 
   return Array.isArray(layer.metadata.nativeLayerIds) && layer.metadata.nativeLayerIds.length > 0;

apps/geolibre-desktop/src/components/panels/NetcdfSymbologySection.tsx

@@ -4,6 +4,7 @@ import { Boxes } from "lucide-react";
 import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { useColormapRamps } from "../../hooks/useColormapRamps";
+import { bandMeasure } from "../../lib/netcdf-band-axis";
 import { openNetcdfCubeSetup } from "../../lib/netcdf-cube-store";
 import {
   bakeNetcdfImage,
@@ -13,8 +14,65 @@ import {
   netcdfImageSymbology,
   warmNetcdfColormap,
   type NetcdfImageSymbology,
+  type NetcdfLayerState,
 } from "../../lib/netcdf-image-symbology";
 
+/** The three band pickers' names, red first, reused for the RGB summary rows. */
+const CHANNEL_LABEL_KEYS = [
+  "addData.netcdf.channel.red",
+  "addData.netcdf.channel.green",
+  "addData.netcdf.channel.blue",
+] as const;
+
+/**
+ * What an RGB composite gets in place of the colormap controls: the three bands
+ * it was composed from, and the way into the 3-D cube.
+ *
+ * There is nothing to re-apply here — the pixels came from three channels, each
+ * stretched to its own range, and re-baking any one of them with a colormap
+ * would replace the composite with a single-band image. So the bands are shown
+ * rather than edited; changing them means adding the layer again.
+ *
+ * @param props.layerId - The composite's layer id, for the cube setup.
+ * @param props.state - Its retained grids, which must carry `rgb`.
+ * @returns The summary section.
+ */
+function NetcdfRgbSection({ layerId, state }: { layerId: string; state: NetcdfLayerState }) {
+  const { t } = useTranslation();
+  const axis = state.cube?.axis;
+  return (
+    <>
+      <Separator />
+      <div className="space-y-3">
+        <p className="text-xs font-semibold">{t("addData.netcdf.bandCombinationLabel")}</p>
+        <dl className="space-y-1 text-xs">
+          {(state.rgb?.bands ?? []).map((band, channel) => (
+            <div key={CHANNEL_LABEL_KEYS[channel]} className="flex items-baseline gap-2">
+              <dt className="text-muted-foreground">{t(CHANNEL_LABEL_KEYS[channel])}</dt>
+              <dd className="truncate font-medium">
+                {axis ? bandMeasure(axis, band) : String(band)}
+              </dd>
+            </div>
+          ))}
+        </dl>
+        {/* Same condition as the single-band section's button: only a layer
+            whose source file is still open on a band axis has a cube to read. */}
+        {state.cube ? (
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            onClick={() => openNetcdfCubeSetup(layerId)}
+          >
+            <Boxes className="me-1.5 h-4 w-4" aria-hidden="true" />
+            {t("netcdfSymbology.openCube")}
+          </Button>
+        ) : null}
+      </div>
+    </>
+  );
+}
+
 /**
  * Symbology for a NetCDF grid baked into an `image` overlay: the same colormap
  * catalogue the raster panel offers, a reverse toggle, and the color limits.
@@ -28,8 +86,12 @@ import {
  * case after a project reload: the baked pixels are in the project file but the
  * values behind them are not, so there is nothing to re-colormap.
  *
+ * An RGB composite retains its grids but has no single ramp to edit, so it gets
+ * {@link NetcdfRgbSection} — its bands, and the cube — instead.
+ *
  * @param props.layer - The image layer to style.
- * @returns The symbology controls, or null when the grid is unavailable.
+ * @returns The symbology controls, the RGB summary, or null when nothing about
+ *   the layer is retained.
  */
 export function NetcdfSymbologySection({ layer }: { layer: GeoLibreLayer }) {
   const { t } = useTranslation();
@@ -60,6 +122,11 @@ export function NetcdfSymbologySection({ layer }: { layer: GeoLibreLayer }) {
     setPendingSymbology(null);
   }
 
+  // After the hooks above, not before: an early return that skipped them would
+  // change the hook order between a single-band layer and a composite.
+  const rgbState = getNetcdfLayerState(layer.id);
+  if (rgbState?.rgb) return <NetcdfRgbSection layerId={layer.id} state={rgbState} />;
+
   if (!source) return null;
 
   // Re-baking walks every cell and then PNG-encodes the result, which is

apps/geolibre-desktop/src/components/panels/StylePanel.tsx

@@ -56,7 +56,7 @@ import { useTranslation } from "react-i18next";
 import { AttributeFormSection } from "./AttributeFormSection";
 import { LayerJoinsSection } from "./LayerJoinsSection";
 import { VirtualFieldsSection } from "./VirtualFieldsSection";
-import { getNetcdfImageSource, NETCDF_IMAGE_SOURCE_KIND } from "../../lib/netcdf-image-symbology";
+import { getNetcdfLayerState, NETCDF_IMAGE_SOURCE_KIND } from "../../lib/netcdf-image-symbology";
 import { NetcdfProfilePanel } from "./NetcdfProfilePanel";
 import { NetcdfSymbologySection } from "./NetcdfSymbologySection";
 import { RasterSymbologySection } from "./RasterSymbologySection";
@@ -4631,11 +4631,14 @@ export function StylePanel({
   }
 
   if (!hasVectorPaintControls) {
-    // The section renders nothing without a retained grid, so ask here too, or
+    // The section renders nothing without retained grids, so ask here too, or
     // the panel would suppress the fallback message and show an empty body.
+    // The layer state rather than `getNetcdfImageSource`, which is null for an
+    // RGB composite: that one has no colormap to re-apply, but it does have a
+    // band summary to show and pixels to sample.
     const hasNetcdfSymbology =
       layer.metadata.sourceKind === NETCDF_IMAGE_SOURCE_KIND &&
-      getNetcdfImageSource(layer.id) !== null;
+      getNetcdfLayerState(layer.id) !== null;
     return (
       <aside aria-label={t("style.panelLabel")} className={STYLE_PANEL_ASIDE_CLASS}>
         {resizeHandle}
@@ -4660,8 +4663,8 @@ export function StylePanel({
             {/* A NetCDF grid baked to pixels has no MapLibre paint properties,
                 so it lands in this branch; its colormap/limits are re-applied
                 by re-baking the image rather than by a style property. The
-                grid is dropped on a project reload, and an RGB composite never
-                had one, so the generic message still has to appear for those. */}
+                grids are dropped on a project reload, so the generic message
+                still has to appear for a layer restored from one. */}
             {hasNetcdfSymbology ? (
               <NetcdfSymbologySection layer={layer} />
             ) : (

apps/geolibre-desktop/src/hooks/useNetcdfIdentify.ts

@@ -1,14 +1,19 @@
 import { useAppStore } from "@geolibre/core";
+import type { TFunction } from "i18next";
 import maplibregl from "maplibre-gl";
 import { useEffect } from "react";
 import { useTranslation } from "react-i18next";
 import type { MapController } from "@geolibre/map";
+import { bandMeasure } from "../lib/netcdf-band-axis";
 import {
   displayUnits,
   getNetcdfLayerState,
   gridPixelAt,
+  gridValueAt,
   NETCDF_IMAGE_SOURCE_KIND,
   readNetcdfProfile,
+  type GridPixel,
+  type NetcdfLayerState,
 } from "../lib/netcdf-image-symbology";
 import {
   addNetcdfProfileSample,
@@ -35,6 +40,55 @@ function formatReading(value: number, units: string | undefined): string {
   return unit ? `${formatValue(value)} ${unit}` : formatValue(value);
 }
 
+/**
+ * The channel names an RGB composite's rows are labelled with, red first — the
+ * same three the Add dialog's band pickers carry, so a reading is named exactly
+ * as the field that chose it.
+ */
+const CHANNEL_LABEL_KEYS = [
+  "addData.netcdf.channel.red",
+  "addData.netcdf.channel.green",
+  "addData.netcdf.channel.blue",
+] as const;
+
+/**
+ * The value rows for one clicked cell.
+ *
+ * A single-band layer reports the variable it was built from. A composite
+ * reports all three channels instead: they are the same variable at three
+ * bands, so naming it three times would say nothing, where the channel and the
+ * band it was drawn from say everything. The three share a geometry, so the
+ * cell `gridPixelAt` found on the red channel addresses the other two directly.
+ *
+ * @param state - The layer's retained grids.
+ * @param pixel - The cell under the click.
+ * @param t - The translator, for the channel names and the no-data marker.
+ * @returns Label/value pairs, in display order.
+ */
+function valueRows(
+  state: NetcdfLayerState,
+  pixel: GridPixel,
+  t: TFunction,
+): Array<[string, string]> {
+  const reading = (value: number | null): string =>
+    value === null ? t("netcdfIdentify.noData") : formatReading(value, state.units);
+
+  const rgb = state.rgb;
+  if (!rgb) return [[state.variable, reading(pixel.value)]];
+
+  const axis = state.cube?.axis;
+  return rgb.bands.map((band, channel) => {
+    const name = t(CHANNEL_LABEL_KEYS[channel]);
+    return [
+      // The axis is gone once the file behind a second cube closed it, and with
+      // it any way to say which wavelength this was; the channel name alone
+      // still reads correctly.
+      axis ? `${name} (${bandMeasure(axis, band)})` : name,
+      reading(gridValueAt(rgb.channels[channel], pixel.row, pixel.column)),
+    ] as [string, string];
+  });
+}
+
 /**
  * Bridges the store's `identifyLayerId` to a NetCDF image layer's retained grid.
  *
@@ -107,12 +161,7 @@ export function useNetcdfIdentify(
       const container = document.createElement("div");
       container.className = "space-y-0.5 text-xs";
       const rows: Array<[string, string]> = [
-        [
-          state.variable,
-          pixel.value === null
-            ? t("netcdfIdentify.noData")
-            : formatReading(pixel.value, state.units),
-        ],
+        ...valueRows(state, pixel, t),
         [t("netcdfIdentify.coordinates"), `${pixel.lng.toFixed(5)}, ${pixel.lat.toFixed(5)}`],
         [t("netcdfIdentify.cell"), `${pixel.row}, ${pixel.column}`],
       ];

apps/geolibre-desktop/src/lib/netcdf-band-axis.ts

@@ -47,6 +47,28 @@ export function axisOptionLabel(axis: LocalNetcdfAxis, coordinate: number, index
   return `${measure} (${axis.name} ${index})`;
 }
 
+/**
+ * `"650.41 nm"` — just the band's measure, for places where the axis and the
+ * channel it feeds are already named around it (the identify popup's red/green/
+ * blue rows, the Style panel's band summary). Shorter than {@link bandLabel} on
+ * purpose: those sit inside a row that is already a label.
+ *
+ * An axis with no coordinate values, or none at this index, has no measure to
+ * show, so it falls back to naming the position — the only thing known about it.
+ *
+ * @param axis - The band axis.
+ * @param index - The band's position along it.
+ * @returns The coordinate with its units, or `"bands 47"`.
+ */
+export function bandMeasure(axis: LocalNetcdfAxis, index: number): string {
+  const coordinate = axis.values?.[index];
+  if (coordinate === undefined) return `${axis.name} ${index}`;
+  const rounded = Number.isInteger(coordinate) ? String(coordinate) : coordinate.toFixed(2);
+  // Without units the bare number reads as nothing in particular, so keep the
+  // axis name in front of it rather than showing a naked "47".
+  return axis.units ? `${rounded} ${axis.units}` : `${axis.name} ${rounded}`;
+}
+
 /** How one band index should read in a picker, whatever the axis carries. */
 export function bandLabel(axis: LocalNetcdfAxis, index: number): string {
   const coordinate = axis.values?.[index];