Thredds palettes

CHANGES.md

@@ -2,6 +2,8 @@
 
 #### next release (8.6.1)
 
+- Add ability for users to select Thredds palettes when available from Thredds servers for changing the visualisation of data.
+
 - [The next improvement]
 
 #### 8.6.0 - 2024-03-12

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,62 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
     ) as this;
   }
 
+  async fetchPalettes(
+    abstract: string,
+    legend:
+      | Complete<{
+          title?: string | undefined;
+          url?: string | undefined;
+          paletteUrl?: 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 urlRegex = /(https?:\/\/[^\s]+)/g;
+    const urls = abstract?.match(urlRegex);
+
+    if (urls) {
+      const paletteUrl = proxyCatalogItemUrl(this.catalogItem, urls[0]);
+      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[] = [];
 
@@ -172,14 +229,14 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
       )?.styles;
 
       let layerStyle: Model<WebMapServiceAvailableStyleTraits> | undefined;
+      let paletteUrl: string | undefined;
 
       if (isDefined(style)) {
         // Attempt to find layer style based on AvailableStyleTraits
         layerStyle = layerAvailableStyles?.find(
           (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)
@@ -250,6 +307,8 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
           legendUri.setQuery("transparent", "true");
         }
 
+        i;
+
         // Add colour scale range params if supported
         if (
           this.catalogItem.supportsColorScaleRange &&
@@ -264,7 +323,8 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
           createStratumInstance(LegendTraits, {
             url: legendUri.toString(),
             urlMimeType: legendUrlMimeType,
-            imageScaling: legendScaling
+            imageScaling: legendScaling,
+            paletteUrl: paletteUrl
           })
         );
       }
@@ -361,10 +421,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];
@@ -410,6 +466,29 @@ export default class WebMapServiceCapabilitiesStratum extends LoadableStratum(
       });
     }
 
+    if (this.catalogItem.isThredds) {
+      //   const paletteResult: StratumFromTraits<WebMapServiceAvailableLayerStylesTraits>[] =
+      // [];
+
+      async () => {
+        const res = result[0];
+        const styles = res.styles ?? null;
+        if (styles && styles[0].abstract) {
+          const palettes = await this.fetchPalettes(
+            styles[0].abstract,
+            styles[0].legend
+          );
+          console.log(palettes);
+          result[0].styles = palettes;
+          return result;
+        } else {
+          return result;
+        }
+      };
+    } else {
+      return result;
+    }
+
     return result;
   }
 

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";
@@ -619,6 +620,72 @@ class WebMapServiceCatalogItem
     }
   );
 
+  fetchPalettes(): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      if (!this.isThredds) {
+        reject("Not a THREDDS server");
+      }
+      const urlRegex = /(https?:\/\/[^\s]+)/g;
+      const selectedStyle = this.availableStyles[0].styles.filter(
+        (style) => style.name === this.styles
+      );
+      const abstract = selectedStyle[0]?.abstract;
+      const urls = abstract?.match(urlRegex);
+      const extractedUrl = urls?.[0];
+
+      if (!extractedUrl) {
+        reject("No URL found in abstract");
+      }
+      const proxiedUrl = proxyCatalogItemUrl(this, extractedUrl!);
+
+      fetch(proxiedUrl, { method: "GET" })
+        .then((response) => response.json())
+        .then((data) => {
+          this.setTrait(CommonStrata.user, "threddsPalettes", data.palettes);
+          resolve(data.palettes);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  }
+
+  @computed
+  get threddsPaletteDimensions(): SelectableDimensionEnum[] {
+    if (!this.isThredds) {
+      return [];
+    }
+
+    const options: { name: string; id: string }[] = [];
+
+    this.threddsPalettes.map((palette) => {
+      options.push({
+        name: palette,
+        id: palette
+      });
+    });
+
+    return [
+      {
+        name: "Palettes",
+        id: `${this.uniqueId}-palettes`,
+        options,
+        selectedId: this.threddsPalette,
+        setDimensionValue: (
+          stratumId: string,
+          newPalette: string | undefined
+        ) => {
+          runInAction(() => {
+            this.setTrait(stratumId, "threddsPalette", newPalette);
+            const currentStyle = this.stylesArray[0];
+            const newStyles = currentStyle.split("/")[0] + "/" + newPalette;
+            this.setTrait(stratumId, "styles", newStyles);
+          });
+        }
+      }
+    ];
+  }
+
   @computed
   get styleSelectableDimensions(): SelectableDimensionEnum[] {
     return this.availableStyles.map((layer, layerIndex) => {
@@ -671,6 +738,7 @@ class WebMapServiceCatalogItem
             );
             styles[layerIndex] = newStyle;
             this.setTrait(stratumId, "styles", styles.join(","));
+            this.fetchPalettes();
           });
         },
         // There is no way of finding out default style if no style has been selected :(
@@ -758,7 +826,8 @@ class WebMapServiceCatalogItem
     return filterOutUndefined([
       ...super.selectableDimensions,
       ...this.wmsDimensionSelectableDimensions,
-      ...this.styleSelectableDimensions
+      ...this.styleSelectableDimensions,
+      ...this.threddsPaletteDimensions
     ]);
   }
 

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 = [

lib/Traits/TraitsClasses/LegendTraits.ts

@@ -135,6 +135,14 @@ export default class LegendTraits extends ModelTraits {
   })
   url?: string;
 
+  @primitiveTrait({
+    type: "string",
+    name: "Palettes URL",
+    description:
+      "The URL of the endpoint which returns the list of Thredds palette"
+  })
+  paletteUrl?: string;
+
   @primitiveTrait({
     type: "number",
     name: "Scaling",

lib/Traits/TraitsClasses/WebMapServiceCatalogItemTraits.ts

@@ -69,6 +69,16 @@ export class WebMapServiceAvailableLayerStylesTraits extends ModelTraits {
   styles?: WebMapServiceAvailableStyleTraits[];
 }
 
+export class WebMapServiceAvailablePaletteTraits extends ModelTraits {
+  @primitiveTrait({
+    type: "string",
+    name: "URL",
+    description:
+      "The URL of the GetMetadata request for the palette. This is used to get the palettes available for a layer."
+  })
+  url?: string;
+}
+
 export class WebMapServiceAvailableDimensionTraits extends ModelTraits {
   @primitiveTrait({
     type: "string",
@@ -316,6 +326,22 @@ export default class WebMapServiceCatalogItemTraits extends mixTraits(
   })
   colorScaleMaximum: number = 50;
 
+  @primitiveTrait({
+    type: "string",
+    name: "Thredds palette",
+    description:
+      "palette is a non-standard property supported by THREDDS servers. This property is ignored unless WebMapServiceCatalogItem's isThredds is true. The default value is 'default'."
+  })
+  threddsPalette?: string = "default";
+
+  @primitiveArrayTrait({
+    type: "string",
+    name: "Thredds palettes",
+    description:
+      "Used to store the palettes available for a layer. This is a non-standard property supported by THREDDS servers. This property is ignored unless WebMapServiceCatalogItem's isThredds is true. The default value is ['default']."
+  })
+  threddsPalettes: string[] = ["default"];
+
   @primitiveTrait({
     type: "boolean",
     name: "Use WMS version 1.3.0",