Thredds palettes

CHANGES.md

@@ -2,10 +2,15 @@
 
 #### next release (8.7.2)
 
+- Add ability for users to select the palettes supplied by ncWMS servers for changing the visualisation of data.
+
 - [The next improvement]
 
 #### 8.7.1 - 2024-04-16
 
+- Add ability for users to select Thredds palettes when available from Thredds servers for changing the visualisation of data.
+
+- Fixed exception thrown from `objectArrayTrait` when a model has 0 strata and a `MergeStrategy` of `topStratum`.
 - Upgraded to TerriajS Cesium 1.115.0
 - Fix `PointStyleTraits.marker` bug where URLs were not being used.
 - Fixed a bug with passing a relative baseUrl to Cesium >= 1.113.0 when `document.baseURI` is different to its `location`.

lib/Models/Catalog/Ows/WebMapServiceCapabilities.ts

@@ -37,6 +37,12 @@ export type CapabilitiesDimension = string & {
   readonly current?: boolean;
 };
 
+export type Palettes = {
+  palettes: ReadonlyArray<string>;
+  defaultPalette: string;
+  scaleRange: number[];
+};
+
 export type CapabilitiesExtent = string & {
   readonly name: string;
   readonly default?: string;

lib/Models/Catalog/Ows/WebMapServiceCapabilitiesStratum.ts

@@ -44,6 +44,7 @@ import WebMapServiceCapabilities, {
   getRectangleFromLayer
 } from "./WebMapServiceCapabilities";
 import WebMapServiceCatalogItem from "./WebMapServiceCatalogItem";
+import { Complete } from "../../../Core/TypeModifiers";
 
 const dateFormat = require("dateformat");
 
@@ -89,6 +90,69 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
     ) as this;
   }
 
+  async fetchPalettes(
+    abstract: string,
+    legend:
+      | Complete<{
+          title?: string | undefined;
+          url?: string | undefined;
+          imageScaling?: number | undefined;
+          urlMimeType?: string | undefined;
+          items?:
+            | Complete<{
+                title?: string | undefined;
+                multipleTitles?: string[] | undefined;
+                maxMultipleTitlesShowed: number | undefined;
+                titleAbove?: string | undefined;
+                titleBelow?: string | undefined;
+                color?: string | undefined;
+                outlineColor?: string | undefined;
+                outlineWidth?: number | undefined;
+                multipleColors?: string[] | undefined;
+                imageUrl?: string | undefined;
+                marker?: string | undefined;
+                rotation: number | undefined;
+                addSpacingAbove?: boolean | undefined;
+                imageHeight: number | undefined;
+                imageWidth: number | undefined;
+              }>[]
+            | undefined;
+          backgroundColor?: string | undefined;
+        }>
+      | undefined
+  ): Promise<StratumFromTraits<WebMapServiceAvailableStyleTraits>[]> {
+    const paletteResult: StratumFromTraits<WebMapServiceAvailableStyleTraits>[] =
+      [];
+
+    const url = this.catalogItem
+      .uri!.clone()
+      .setSearch({
+        service: "WMS",
+        version: this.useWmsVersion130 ? "1.3.0" : "1.1.1",
+        request: "GetMetadata",
+        item: "layerDetails",
+        layerName: this.catalogItem.layersArray[0]
+      })
+      .toString();
+
+    if (url) {
+      const paletteUrl = proxyCatalogItemUrl(this.catalogItem, url);
+      const response = await fetch(paletteUrl);
+      const data = await response.json();
+      const palettes = data.palettes;
+      palettes.forEach((palette: any) => {
+        paletteResult.push({
+          name: palette,
+          title: palette,
+          abstract: abstract,
+          legend: legend
+        });
+      });
+    }
+
+    return paletteResult;
+  }
+
   @computed get metadataUrls() {
     const metadataUrls: MetadataURL[] = [];
 
@@ -179,7 +243,6 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
           (candidate) => candidate.name === style
         );
       }
-
       // If no style is selected and this WMS doesn't support GetLegendGraphics - we must use the first style if none is explicitly specified.
       // (If WMS supports GetLegendGraphics we can use it and omit style parameter to get the "default" style's legend)
       if (!isDefined(layerStyle) && !this.catalogItem.supportsGetLegendGraphic)
@@ -222,6 +285,9 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
         if (style) {
           legendUri.setQuery("style", style);
         }
+        if (this.isNcWMS && this.palette) {
+          legendUri.setQuery("palette", this.palette);
+        }
         legendUrlMimeType = "image/png";
       }
 
@@ -361,10 +427,6 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
     const result: StratumFromTraits<WebMapServiceAvailableLayerStylesTraits>[] =
       [];
 
-    if (!this.capabilities) {
-      return result;
-    }
-
     const capabilitiesLayers = this.capabilitiesLayers;
     for (const layerTuple of capabilitiesLayers) {
       const layerName = layerTuple[0];

lib/Models/Catalog/Ows/WebMapServiceCatalogItem.ts

@@ -38,7 +38,8 @@ import {
 } from "../../../Table/tableFeatureInfoContext";
 import WebMapServiceCatalogItemTraits, {
   SUPPORTED_CRS_3857,
-  SUPPORTED_CRS_4326
+  SUPPORTED_CRS_4326,
+  WebMapServiceAvailableLayerStylesTraits
 } from "../../../Traits/TraitsClasses/WebMapServiceCatalogItemTraits";
 import CommonStrata from "../../Definition/CommonStrata";
 import CreateModel from "../../Definition/CreateModel";
@@ -225,12 +226,16 @@ class WebMapServiceCatalogItem
   }
 
   protected async forceLoadMetadata(): Promise<void> {
+    if (this.palettes.length === 0) {
+      this.fetchPalettes();
+    }
     if (
       this.strata.get(GetCapabilitiesMixin.getCapabilitiesStratumName) !==
       undefined
     )
       return;
     const stratum = await WebMapServiceCapabilitiesStratum.load(this);
+
     runInAction(() => {
       this.strata.set(GetCapabilitiesMixin.getCapabilitiesStratumName, stratum);
     });
@@ -380,6 +385,7 @@ class WebMapServiceCatalogItem
     if (time) {
       uri.addQuery("time", time);
     }
+
     return uri.toString();
   }
 
@@ -518,8 +524,6 @@ class WebMapServiceCatalogItem
         return undefined;
       }
 
-      console.log(`Creating new ImageryProvider for time ${time}`);
-
       // Set dimensionParameters
       const dimensionParameters = formatDimensionsForOws(this.dimensions);
       if (time !== undefined) {
@@ -619,6 +623,104 @@ class WebMapServiceCatalogItem
     }
   );
 
+  fetchPalettes(): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      if (!this.isThredds) {
+        resolve([]);
+      }
+
+      if (this.palettes.length > 0) {
+        resolve([...this.palettes]);
+      }
+
+      const extractedUrl = this.uri!.clone()
+        .setSearch({
+          service: "WMS",
+          version: this.useWmsVersion130 ? "1.3.0" : "1.1.1",
+          request: "GetMetadata",
+          item: "layerDetails",
+          layerName: this.layersArray[0]
+        })
+        .toString();
+
+      if (!extractedUrl) {
+        resolve([]);
+      }
+      const proxiedUrl = proxyCatalogItemUrl(this, extractedUrl!);
+
+      fetch(proxiedUrl, { method: "GET" })
+        .then((response) => response.json())
+        .then((data) => {
+          this.setTrait(CommonStrata.user, "palettes", data.palettes);
+          this.setTrait(
+            CommonStrata.user,
+            "colorScaleMinimum",
+            data.scaleRange[0]
+          );
+          this.setTrait(
+            CommonStrata.user,
+            "colorScaleMaximum",
+            data.scaleRange[1]
+          );
+          this.setTrait(
+            CommonStrata.user,
+            "defaultPalette",
+            data.defaultPalette
+          );
+          this.setTrait(
+            CommonStrata.user,
+            "noPaletteStyles",
+            data.noPaletteStyles
+          );
+          this.setTrait(CommonStrata.user, "showPalettes", true);
+          resolve(data.palettes);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  }
+
+  @computed
+  get paletteDimensions(): SelectableDimensionEnum[] {
+    if (!this.isNcWMS || !this.showPalettes) {
+      return [];
+    }
+
+    const options: { name: string; id: string }[] = [];
+
+    this.palettes.map((palette) => {
+      options.push({
+        name: palette,
+        id: palette
+      });
+    });
+
+    return [
+      {
+        name: "Palettes",
+        id: `${this.uniqueId}-palettes`,
+        options,
+        selectedId: this.palette,
+        setDimensionValue: (
+          stratumId: string,
+          newPalette: string | undefined
+        ) => {
+          //if (this.stylesArray[0]) {
+          runInAction(() => {
+            this.setTrait(stratumId, "palette", newPalette);
+            const currentStyle = this.stylesArray[0]
+              ? this.stylesArray[0]
+              : "default";
+            const newStyles = currentStyle.split("/")[0] + "/" + newPalette;
+            this.setTrait(stratumId, "styles", newStyles);
+          });
+          //}
+        }
+      }
+    ];
+  }
+
   @computed
   get styleSelectableDimensions(): SelectableDimensionEnum[] {
     return this.availableStyles.map((layer, layerIndex) => {
@@ -665,12 +767,26 @@ class WebMapServiceCatalogItem
           newStyle: string | undefined
         ) => {
           if (!newStyle) return;
+
           runInAction(() => {
             const styles = this.styleSelectableDimensions.map(
               (style) => style.selectedId || ""
             );
-            styles[layerIndex] = newStyle;
-            this.setTrait(stratumId, "styles", styles.join(","));
+            styles[layerIndex] = newStyle ? newStyle : "";
+
+            if (this.isNcWMS && this.palette) {
+              const currentStyle = newStyle.split("/")[0];
+              const currentPalette = this.palette;
+              const newStyles = currentStyle + "/" + currentPalette;
+              this.setTrait(stratumId, "styles", newStyles);
+              if (this.noPaletteStyles.includes(newStyle)) {
+                this.setTrait(stratumId, "showPalettes", false);
+              } else {
+                this.setTrait(stratumId, "showPalettes", true);
+              }
+            } else {
+              this.setTrait(stratumId, "styles", styles.join(","));
+            }
           });
         },
         // There is no way of finding out default style if no style has been selected :(
@@ -755,10 +871,13 @@ class WebMapServiceCatalogItem
       return super.selectableDimensions;
     }
 
+    const paletteDimensions = this.showPalettes ? this.paletteDimensions : [];
+
     return filterOutUndefined([
       ...super.selectableDimensions,
       ...this.wmsDimensionSelectableDimensions,
-      ...this.styleSelectableDimensions
+      ...this.styleSelectableDimensions,
+      ...paletteDimensions
     ]);
   }
 

lib/ReactViews/Analytics/ParameterEditor.jsx

@@ -61,6 +61,7 @@ const ParameterEditor = createReactClass({
   renderEditor() {
     for (let i = 0; i < ParameterEditor.parameterTypeConverters.length; ++i) {
       const converter = ParameterEditor.parameterTypeConverters[i];
+
       const editor = converter.parameterTypeToDiv(
         this.props.parameter.type,
         this

lib/ReactViews/Workbench/Controls/Legend.tsx

@@ -18,7 +18,7 @@ import LegendOwnerTraits from "../../../Traits/TraitsClasses/LegendOwnerTraits";
 import LegendTraits, {
   LegendItemTraits
 } from "../../../Traits/TraitsClasses/LegendTraits";
-import Styles from "./legend.scss";
+import Styles, { legend } from "./legend.scss";
 
 /* A lookup map for displayable mime types */
 const DISPLAYABLE_MIME_TYPES = [