From aa2c569b8d62ce7f302af941518a63e4c613b493 Mon Sep 17 00:00:00 2001
From: Marco Hutter <javagl@javagl.de>
Date: Sat, 5 Oct 2024 16:59:36 +0200
Subject: [PATCH 1/7] First draft of GPM sandcastle

---
 .../development/NGA GPM Visualization.html    | 1378 +++++++++++++++++
 .../development/NGA GPM Visualization.jpg     |  Bin 0 -> 8429 bytes
 2 files changed, 1378 insertions(+)
 create mode 100644 Apps/Sandcastle/gallery/development/NGA GPM Visualization.html
 create mode 100644 Apps/Sandcastle/gallery/development/NGA GPM Visualization.jpg
diff --git a/Apps/Sandcastle/gallery/development/NGA GPM Visualization.html b/Apps/Sandcastle/gallery/development/NGA GPM Visualization.html
new file mode 100644
index 000000000000..86f84132ba5c
--- /dev/null
+++ b/Apps/Sandcastle/gallery/development/NGA GPM Visualization.html	
@@ -0,0 +1,1378 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
+    />
+    <meta
+      name="description"
+      content="An example for the visualization of NGA_gpm_local extension data"
+    />
+    <meta name="cesium-sandcastle-labels" content="Development" />
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script
+      type="text/javascript"
+      src="../../../Build/CesiumUnminified/Cesium.js"
+      nomodule
+    ></script>
+    <script type="module" src="../load-cesium-es6.js"></script>
+  </head>
+
+  <body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+    <style>
+      @import url(../templates/bucket.css);
+
+      #toolbar {
+        background: rgba(42, 42, 42, 0.8);
+        padding: 4px;
+        border-radius: 4px;
+      }
+
+      #toolbar input {
+        vertical-align: middle;
+        padding-top: 2px;
+        padding-bottom: 2px;
+      }
+    </style>
+    <div id="cesiumContainer" class="fullSize"></div>
+    <div id="loadingOverlay">
+      <h1>Loading...</h1>
+    </div>
+    <div id="toolbar">
+      <table>
+        <tbody>
+          <tr>
+            <td colspan="3">
+              <h4>Cesium GPM Visualization</h4>
+            </td>
+          </tr>
+          <tr>
+            <td>Data set</td>
+            <td>
+              <select data-bind="options: dataSetNames, value: dataSetName"></select>
+            </td>
+            <td style="text-align: right">
+              <button type="button" data-bind="click: zoomToCurrentTileset">Zoom</button>
+            </td>
+          </tr>
+          <tr>
+            <td>Anchor point ellipsoid</td>
+            <td colspan="2">
+              <input
+                type="range"
+                min="1.0"
+                max="500"
+                step="1"
+                data-bind="value: anchorPointEllipsoidScaling, valueUpdate: 'input'"
+              />
+              <input
+                type="text"
+                size="5"
+                data-bind="value: anchorPointEllipsoidScaling"
+              />
+              <label
+                ><input
+                  type="checkbox"
+                  data-bind="checked: anchorPointLabelsVisible"
+                />Labels</label
+              >
+            </td>
+          </tr>
+          <tr>
+            <td>Shader mode</td>
+            <td colspan="2">
+              <select data-bind="options: shaderModes, value: shaderMode"></select>
+            </td>
+          </tr>
+          <tr id="texture-threshold-control" class="hidden">
+            <td>Texture threshold (m)</td>
+            <td>
+              <input
+                type="range"
+                min="0.0"
+                max="16.0"
+                step="0.01"
+                data-bind="value: textureThreshold, valueUpdate: 'input'"
+              />
+              <input type="text" size="5" data-bind="value: textureThreshold" />
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+    <script id="cesium_sandcastle_script">
+      window.startup = async function (Cesium) {
+        "use strict";
+        //Sandcastle_Begin
+
+        // Basic setup
+        const viewer = new Cesium.Viewer("cesiumContainer", {
+          //globe: false,
+          //skyBox: false,
+          timeline: false,
+          animation: false,
+          depthPlaneEllipsoidOffset: 10000,
+        });
+
+        const maxarCredit = new Cesium.Credit(
+          "<span>Provided by Maxar for GPM v1.2 evaluation purposes</span>",
+          true,
+        );
+        viewer.creditDisplay.addStaticCredit(maxarCredit);
+
+        // The options that will be passed to all Cesium3DTilesed.from ... functions
+        const defaultTilesetOptions = {
+          //debugShowBoundingVolume: true,
+          maximumScreenSpaceError: 4,
+          cacheBytes: 536870912 * 4,
+        };
+
+        // Whether the data should be loaded from localhost instead of ion
+        const useLocalServer = true;
+        const baseUrl = "http://localhost:8003/";
+
+        if (!useLocalServer) {
+          // Access token that grants access to lajes, port canaveral, cwt, and bing maps aerial:
+          Cesium.Ion.defaultAccessToken =
+            "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI0MmExYzE1NS01ZGI3LTQyNjQtYWNkYi1mMTE1MGJmY2YzODgiLCJpZCI6NDQsImlhdCI6MTcxODM3NDM5MX0.TsMmPMPVIJvgu93jTFsCKj43PLdKfpiZi_gMONecJ3I";
+        }
+
+        // The set of data sets that are available in the UI
+        const dataSetOptions = [
+          {
+            name: "Port Canaveral",
+            url: `${baseUrl}port_canaveral/tileset.json`,
+            assetId: 2622944,
+            initialCameraConfiguration: {
+              destination: new Cesium.Cartesian3(
+                918010.2634368961,
+                -5538948.372542206,
+                3016855.1270222967,
+              ),
+              orientation: new Cesium.HeadingPitchRoll(
+                4.316957618964909,
+                -0.36573164980955686,
+                6.283174173076164,
+              ),
+            },
+          },
+          {
+            name: "Lajes",
+            url: `${baseUrl}lajes/tileset.json`,
+            assetId: 2622949,
+            initialCameraConfiguration: {
+              destination: new Cesium.Cartesian3(
+                4436474.736810458,
+                -2279634.446362909,
+                3962861.396769178,
+              ),
+              orientation: new Cesium.HeadingPitchRoll(
+                5.214554743456651,
+                -0.5265190154471187,
+                0.000008735845947960286,
+              ),
+            },
+          },
+        ];
+        /**
+         * Create a tileset from the given data set option
+         *
+         * @param {object} dataSetOption The data set option
+         * @returns A promise to wait for
+         */
+        async function createTileset(dataSetOption) {
+          if (useLocalServer) {
+            const url = dataSetOption.url;
+            return viewer.scene.primitives.add(
+              await Cesium.Cesium3DTileset.fromUrl(url, defaultTilesetOptions),
+            );
+          }
+          const assetId = dataSetOption.assetId;
+          return viewer.scene.primitives.add(
+            await Cesium.Cesium3DTileset.fromIonAssetId(assetId, defaultTilesetOptions),
+          );
+        }
+
+        //============================================================================
+        // Application state
+
+        class App {
+          constructor() {
+            // The name of the current data set, as of the
+            // dataSetOptions[i].name
+            this._currentDataSetName = undefined;
+
+            // The current tileset
+            this._currentTileset = undefined;
+
+            // The current custom shader, or undefined
+            this._currentCustomShader = undefined;
+
+            // The current value of the `u_textureThreshold` uniform that indicates
+            // whether fragments should be highlighted in the `currentThresholdShader`.
+            this._textureThreshold = 16.0;
+
+            // The scaling factor for the anchor point ellipsoids
+            this.anchorPointEllipsoidScaling = 100.0;
+
+            // A set of functions that will be called whenever
+            // the `currentTileset` changed, and receive the
+            // oldCurrentTileset and newCurrentTileset
+            this._currentTilesetChangedListeners = [];
+          }
+
+          async selectCurrentDataSet(dataSetName) {
+            if (this._currentDataSetName === dataSetName) {
+              return;
+            }
+            for (const dataSetOption of dataSetOptions) {
+              if (dataSetOption.name === dataSetName) {
+                this._currentDataSetName = dataSetName;
+                await this.createCurrentTileset(dataSetOption);
+              }
+            }
+          }
+
+          get currentTileset() {
+            return this._currentTileset;
+          }
+          set currentTileset(value) {
+            const oldCurrentTileset = this._currentTileset;
+            this._currentTileset = value;
+            this.updateCustomShaderInTileset();
+            this.notifyCurrentTilesetChanged(oldCurrentTileset, this.currentTileset);
+          }
+
+          /**
+           * Add the given function to be called when the current tileset
+           * changed, receiving the "old" and the "new" current tileset.
+           *
+           * @param {object} listener The listener
+           */
+          addCurrentTilesetChangedListener(listener) {
+            this._currentTilesetChangedListeners.push(listener);
+          }
+
+          /**
+           * Notify all registered listeners that the current tileset changed
+           *
+           * @param {Cesium3DTileset} oldCurrentTileset
+           * @param {Cesium3DTileset} newCurrentTileset
+           *
+           * @private
+           */
+          notifyCurrentTilesetChanged(oldCurrentTileset, newCurrentTileset) {
+            for (const listener of this._currentTilesetChangedListeners) {
+              listener(oldCurrentTileset, newCurrentTileset);
+            }
+          }
+
+          get currentCustomShader() {
+            return this._currentCustomShader;
+          }
+          set currentCustomShader(value) {
+            this._currentCustomShader = value;
+            this.updateTextureThresholdInShader();
+            this.updateCustomShaderInTileset();
+          }
+
+          /**
+           * If the currentTileset is defined, then assign the currentCustomShader
+           * to it.
+           *
+           * @private
+           */
+          updateCustomShaderInTileset() {
+            if (this.currentTileset === undefined) {
+              return;
+            }
+            this.currentTileset.customShader = this.currentCustomShader;
+          }
+
+          get textureThreshold() {
+            return this._textureThreshold;
+          }
+
+          set textureThreshold(value) {
+            this._textureThreshold = value;
+            this.updateTextureThresholdInShader();
+          }
+
+          /**
+           * If the currentCustomShader is defined and has a `u_textureThreshold`
+           * uniform, then set its value to the current `textureThreshold`
+           *
+           * @private
+           */
+          updateTextureThresholdInShader() {
+            if (this.currentCustomShader === undefined) {
+              return;
+            }
+            const hasTextureThreshold = Object.keys(
+              this.currentCustomShader.uniforms,
+            ).includes("u_textureThreshold");
+            if (!hasTextureThreshold) {
+              return;
+            }
+            this.currentCustomShader.setUniform(
+              "u_textureThreshold",
+              this.textureThreshold,
+            );
+          }
+
+          /**
+           * Load the tileset that is described in the given data
+           * set option, and set it as the current tileset.
+           *
+           * @param {string} url The tileset URL
+           * @returns A promise to wait for...
+           */
+          async createCurrentTileset(dataSetOption) {
+            if (Cesium.defined(this.currentTileset)) {
+              viewer.scene.primitives.remove(this.currentTileset);
+              this.currentTileset = undefined;
+            }
+
+            // Create the tileset
+            this.currentTileset = await createTileset(dataSetOption);
+            if (Cesium.defined(dataSetOption.initialCameraConfiguration)) {
+              viewer.scene.camera.setView(dataSetOption.initialCameraConfiguration);
+            } else {
+              this.zoomToCurrentTileset();
+            }
+          }
+
+          /**
+           * Zoom to the current tileset, with a small, unspecified offset...
+           */
+          zoomToCurrentTileset() {
+            if (this.currentTileset === undefined) {
+              return;
+            }
+            const offset = new Cesium.HeadingPitchRange(
+              Cesium.Math.toRadians(0.0),
+              Cesium.Math.toRadians(-22.5),
+              10000.0,
+            );
+            viewer.zoomTo(this.currentTileset, offset);
+          }
+        }
+
+        const app = new App();
+
+        //============================================================================
+
+        /**
+         * Pick the local uncertainty information from the texture at the given
+         * window position.
+         *
+         * This makes assumptions about the structure of the metadata that is
+         * contained in the underlying data sets.
+         *
+         * It assumes that the data contains two PPE (Per-Point-Error) textures
+         * that are internally converted into structural metadata property
+         * texture properties.
+         *
+         * The first PPE texture uses the SIGZ trait (sigma/standard deviation in
+         * z-direction, in meters). This will be the `y`-component of the result.
+         *
+         * The second PPE texture uses the SIGR trait (sigma/standard deviation in
+         * radial direction in meters). This will be the x-component of the result.
+         *
+         * (Both values are in the range of [0...16], with 16 being the noData value)
+         *
+         * @param {Cartesian2} windowPosition The position in the window
+         * @returns {Cartesian2} The local uncertainty, with `x` being
+         * the radial uncertainty and `y` being the vertical uncertainty
+         */
+        function pickUncertaintyFromTexture(windowPosition) {
+          const schemaId = undefined;
+          const classNameX = "ppeTexture_1";
+          const propertyNameX = "SIGR";
+          const classNameY = "ppeTexture_0";
+          const propertyNameY = "SIGZ";
+          const result = new Cesium.Cartesian2();
+
+          const metadataSchema = viewer.scene.pickMetadataSchema(windowPosition);
+          console.log("metadataSchema", metadataSchema);
+
+          let metadataValueX = viewer.scene.pickMetadata(
+            windowPosition,
+            schemaId,
+            classNameX,
+            propertyNameX,
+          );
+          let metadataValueY = viewer.scene.pickMetadata(
+            windowPosition,
+            schemaId,
+            classNameY,
+            propertyNameY,
+          );
+
+          console.log("metadataValueX ", metadataValueX);
+          console.log("metadataValueY ", metadataValueY);
+          if (!metadataValueX) {
+            metadataValueX = 0;
+          }
+          if (!metadataValueY) {
+            metadataValueY = 0;
+          }
+          result.x = metadataValueX;
+          result.y = metadataValueY;
+          return result;
+        }
+
+        //============================================================================
+        // Property texture shaders
+
+        class PropertyTextureShaders {
+          /**
+           * Create a custom (fragment) shader for the specified property.
+           *
+           * It accesses the metadata value with the given property name and
+           * normalizes it to a value in [0,1] based on the given source range.
+           * If the resulting value is less than 1.0, this value is used
+           * as the brightness for the fragment.
+           *
+           * @param {string} propertyName The property name
+           * @param {number} sourceMin The minimum source value
+           * @param {number} sourceMax The maximum source value
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createShader1D(propertyName, sourceMin, sourceMax) {
+            const shader = new Cesium.CustomShader({
+              fragmentShaderText: `
+        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+        {
+          float value = float(fsInput.metadata.${propertyName});
+          float range = float(${sourceMax}) - float(${sourceMin});
+          float brightness = (value - float(${sourceMin})) / range;
+
+          if (value < float(${sourceMax})) {
+            material.diffuse = vec3(brightness);
+          }
+        }
+      `,
+            });
+            return shader;
+          }
+
+          /**
+           * Create a custom (fragment) shader for the specified properties.
+           *
+           * It accesses the metadata values with the given property names and
+           * normalizes them to a value in [0,1] based on the given source ranges.
+           * If the resulting values are both less than 1.0, the values are used
+           * as the red- and green components of the fragment.
+           *
+           * @param {string} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createShader2D(
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            const shader = new Cesium.CustomShader({
+              fragmentShaderText: `
+        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+        {
+          float value0 = float(fsInput.metadata.${propertyName0});
+          float range0 = float(${sourceMax0}) - float(${sourceMin0});
+          float brightness0 = (value0 - float(${sourceMin0})) / range0;
+
+          float value1 = float(fsInput.metadata.${propertyName1});
+          float range1 = float(${sourceMax1}) - float(${sourceMin1});
+          float brightness1 = (value1 - float(${sourceMin1})) / range1;
+
+          if (value0 < float(${sourceMax0}) && value1 < float(${sourceMax1})) {
+            material.diffuse = vec3(brightness0, brightness1, 0.0);
+          }
+        }
+      `,
+            });
+            return shader;
+          }
+
+          /**
+           * Create a custom (fragment) shader for a threshold visualization of
+           * the specified property.
+           *
+           * It defines a `u_textureThreshold` FLOAT uniform for the threshold
+           * value. It accesses the metadata value with the given property name.
+           * If the resulting value is less than 1.0 but larger than
+           * the threshold, then the fragment will be shown in a highlighting
+           * color. Otherwise, the fragment will be shown with its original
+           * color with lower saturation and lightness.
+           *
+           * @param {string} propertyName The property name
+           * @param {number} sourceMin The minimum source value
+           * @param {number} sourceMax The maximum source value
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createThresholdShader1D(propertyName, sourceMin, sourceMax) {
+            const shader = new Cesium.CustomShader({
+              uniforms: {
+                // A threshold value for the texture: When this
+                // is exceeded, then the fragment will be highlighted
+                u_textureThreshold: {
+                  type: Cesium.UniformType.FLOAT,
+                  value: 16.0,
+                },
+              },
+              fragmentShaderText: `
+        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+        {
+          float value = float(fsInput.metadata.${propertyName});
+          float range = float(${sourceMax}) - float(${sourceMin});
+          float brightness = (value - float(${sourceMin})) / range;
+
+          if (value < float(${sourceMax}) && value > u_textureThreshold) {
+            material.diffuse = vec3(1.0, 1.0, 0.0);
+          } else {
+            vec3 diffuseHsl = czm_RGBToHSL(material.diffuse);
+            diffuseHsl.y *= 0.25;
+            diffuseHsl.z *= 0.25;
+            material.diffuse = czm_HSLToRGB(diffuseHsl);
+          }
+        }
+      `,
+            });
+            return shader;
+          }
+
+          /**
+           * Create a custom (fragment) shader for a threshold visualization of
+           * the specified property.
+           *
+           * It defines a `u_textureThreshold` FLOAT uniform for the threshold
+           * value. It accesses the metadata values with the given property names.
+           * If the resulting value is less than 1.0 but larger than
+           * the threshold, then the fragment will be shown in a highlighting
+           * color. Otherwise, the fragment will be shown with its original
+           * color with lower saturation and lightness.
+           *
+           * @param {string} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createThresholdShader2D(
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            const shader = new Cesium.CustomShader({
+              uniforms: {
+                // A threshold value for the texture: When this
+                // is exceeded, then the fragment will be highlighted
+                u_textureThreshold: {
+                  type: Cesium.UniformType.FLOAT,
+                  value: 16.0,
+                },
+              },
+              fragmentShaderText: `
+        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+        {
+          float value0 = float(fsInput.metadata.${propertyName0});
+          float range0 = float(${sourceMax0}) - float(${sourceMin0});
+          float brightness0 = (value0 - float(${sourceMin0})) / range0;
+
+          float value1 = float(fsInput.metadata.${propertyName1});
+          float range1 = float(${sourceMax1}) - float(${sourceMin1});
+          float brightness1 = (value1 - float(${sourceMin1})) / range1;
+ 
+          vec3 diffuseHsl = czm_RGBToHSL(material.diffuse);
+          diffuseHsl.y *= 0.25;
+          diffuseHsl.z *= 0.25;
+          vec3 diffuseResult = czm_HSLToRGB(diffuseHsl);
+
+          if (value0 < float(${sourceMax0}) && value0 > u_textureThreshold) {
+            diffuseResult.x = 1.0;
+            diffuseResult.y = 1.0;
+          }
+          if (value1 < float(${sourceMax1}) && value1 > u_textureThreshold) {
+            diffuseResult.x = 1.0;
+            diffuseResult.z = 1.0;
+          }
+          material.diffuse = diffuseResult;
+        }
+      `,
+            });
+            return shader;
+          }
+
+          /**
+           * Creates a object that can be used as one entry in the options
+           * of a Sandcastle toolbar menu.
+           *
+           * Depending on which property names are defined, this will
+           * create an option to select default shading, a 1D shader,
+           * or a 2D shader
+           *
+           * @param {string} title The title to be displayed in the combox box
+           * @param {string|undefined} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string|undefined} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The shader option
+           * @private
+           */
+          static createShaderOption(
+            title,
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            return {
+              text: title,
+              onselect: function () {
+                if (Cesium.defined(propertyName0) && Cesium.defined(propertyName1)) {
+                  app.currentCustomShader = PropertyTextureShaders.createShader2D(
+                    propertyName0,
+                    sourceMin0,
+                    sourceMax0,
+                    propertyName1,
+                    sourceMin1,
+                    sourceMax1,
+                  );
+                } else if (Cesium.defined(propertyName0)) {
+                  app.currentCustomShader = PropertyTextureShaders.createShader1D(
+                    propertyName0,
+                    sourceMin0,
+                    sourceMax0,
+                  );
+                } else {
+                  app.currentCustomShader = undefined;
+                }
+
+                document.getElementById("texture-threshold-control").className = "hidden";
+              },
+            };
+          }
+
+          /**
+           * Creates a object that can be used as one entry in the options
+           * of a Sandcastle toolbar menu.
+           *
+           * It will allow selecting a "threshold shader" for the specified
+           * properties.
+           *
+           * @param {string} title The title to be displayed in the combox box
+           * @param {string} title The title to be displayed in the combox box
+           * @param {string|undefined} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string|undefined} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The shader option
+           * @private
+           */
+          static createThresholdShaderOption(
+            title,
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            return {
+              text: title,
+              onselect: function () {
+                if (Cesium.defined(propertyName0) && Cesium.defined(propertyName1)) {
+                  app.currentCustomShader =
+                    PropertyTextureShaders.createThresholdShader2D(
+                      propertyName0,
+                      sourceMin0,
+                      sourceMax0,
+                      propertyName1,
+                      sourceMin1,
+                      sourceMax1,
+                    );
+                } else if (Cesium.defined(propertyName0)) {
+                  app.currentCustomShader =
+                    PropertyTextureShaders.createThresholdShader1D(
+                      propertyName0,
+                      sourceMin0,
+                      sourceMax0,
+                    );
+                } else {
+                  app.currentCustomShader = undefined;
+                }
+
+                document.getElementById("texture-threshold-control").className = "";
+              },
+            };
+          }
+
+          /**
+           * Create the shader options for the Sandcastle toolbar menu
+           */
+          static createShaderOptions() {
+            const shaderOptions = [
+              PropertyTextureShaders.createShaderOption(
+                "Default Shading",
+                undefined,
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createShaderOption(
+                "Local Vertical Uncertainty",
+                "SIGZ",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createShaderOption(
+                "Local Radial Uncertainty",
+                "SIGR",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createShaderOption(
+                "Local Combined Uncertainty",
+                "SIGZ",
+                0.0,
+                16.0,
+                "SIGR",
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createThresholdShaderOption(
+                "Local Vertical Threshold",
+                "SIGZ",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createThresholdShaderOption(
+                "Local Radial Threshold",
+                "SIGR",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createThresholdShaderOption(
+                "Local Combined Threshold",
+                "SIGZ",
+                0.0,
+                16.0,
+                "SIGR",
+                0.0,
+                16.0,
+              ),
+            ];
+            return shaderOptions;
+          }
+        }
+
+        //============================================================================
+        // Texture picking: A label and an ellipsid for the local uncertainty at
+        // the picked position
+
+        class TexturePickingHandler {
+          constructor() {
+            // Whether texture picking is currently enabled
+            this.enabled = false;
+
+            // The current ellipsoid primitive showing the uncertainty radii
+            this.errorEllipsoidPrimitive = undefined;
+
+            const errorLabels = viewer.scene.primitives.add(new Cesium.LabelCollection());
+            // The label showing the uncertainty values
+            this.errorLabel = errorLabels.add({
+              position: Cesium.Cartesian3.fromDegrees(0, 0),
+              show: false,
+              text: "",
+              font: "20px sans-serif",
+              showBackground: true,
+              disableDepthTestDistance: 1e15,
+              horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+              verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+              pixelOffset: new Cesium.Cartesian2(0.0, 5.0),
+              pixelOffsetScaleByDistance: new Cesium.NearFarScalar(50, 0.0, 2000, -2.0),
+            });
+
+            // Install the handler that will pick the uncertainty values
+            // from the texture, and update the error ellipsoid and label
+            const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
+            const that = this;
+            handler.setInputAction(function (movement) {
+              if (!that.enabled) {
+                return;
+              }
+              const worldPosition = viewer.scene.pickPosition(movement.position);
+              if (worldPosition === undefined) {
+                that.clear();
+              } else {
+                const uncertainty = pickUncertaintyFromTexture(movement.position);
+                that.update(worldPosition, uncertainty.x, uncertainty.y);
+              }
+            }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+            handler.setInputAction(function () {
+              if (!that.enabled) {
+                return;
+              }
+              that.clear();
+            }, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
+          }
+
+          /**
+           * Set whether texture uncertainty picking is currently enabled
+           *
+           * @param {boolean} enabled The state
+           */
+          setEnabled(enabled) {
+            this.enabled = enabled;
+            if (!enabled) {
+              this.clear();
+            }
+          }
+
+          /**
+           * Hide the error label, and remove the error ellipsoid
+           */
+          clear() {
+            viewer.scene.primitives.remove(this.errorEllipsoidPrimitive);
+            this.errorEllipsoidPrimitive = undefined;
+            this.errorLabel.show = false;
+          }
+
+          /**
+           * Update the error label and ellipsoid primitive for the
+           * given parameters.
+           *
+           * @param {Cartesian3} worldPosition The position for the label
+           * and ellipsoid
+           * @param {number} sizeX The radial size (uncertainty)
+           * @param {number} sizeY The vertical size (uncertainty)
+           * @private
+           */
+          update(center, sizeX, sizeY) {
+            this.updateErrorLabel(center, sizeX, sizeY);
+            this.updateErrorEllipsoidPrimitive(center, sizeX, sizeY);
+          }
+
+          /**
+           * Update the error label for the given parameters.
+           *
+           * @param {Cartesian3} worldPosition The position for the label
+           * @param {number} sizeX The radial size (uncertainty)
+           * @param {number} sizeY The vertical size (uncertainty)
+           * @private
+           */
+          updateErrorLabel(center, sizeX, sizeY) {
+            const cartographic = Cesium.Cartographic.fromCartesian(center);
+            cartographic.height += sizeY + 1.0;
+            const labelPosition = Cesium.Cartographic.toCartesian(cartographic);
+            this.errorLabel.position = labelPosition;
+            this.errorLabel.show = true;
+            const radialString = sizeX === 16.0 ? "(unknown)" : `${sizeX.toFixed(4)}m`;
+            const verticalString = sizeY === 16.0 ? "(unknown)" : `${sizeY.toFixed(4)}m`;
+            this.errorLabel.text =
+              `Local Radial Uncertainty: ${radialString}\n` +
+              `Local Vertical Uncertainty: ${verticalString}`;
+          }
+
+          /**
+           * Update the error ellipsoid primitive for the given parameters.
+           *
+           * @param {Cartesian3} worldPosition The position for the ellipsoid
+           * @param {number} sizeX The radial size (uncertainty)
+           * @param {number} sizeY The vertical size (uncertainty)
+           * @private
+           */
+          updateErrorEllipsoidPrimitive(center, sizeX, sizeY) {
+            viewer.scene.primitives.remove(this.errorEllipsoidPrimitive);
+            const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);
+            const ellipsoidGeometry = new Cesium.EllipsoidGeometry({
+              radii: new Cesium.Cartesian3(sizeX, sizeX, sizeY),
+              vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
+            });
+            const ellipsoid = new Cesium.GeometryInstance({
+              geometry: ellipsoidGeometry,
+              modelMatrix: modelMatrix,
+              attributes: {
+                color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                  Cesium.Color.BLUE.withAlpha(0.6),
+                ),
+                depthFailColor: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                  Cesium.Color.BLUE.withAlpha(0.2),
+                ),
+              },
+            });
+            this.errorEllipsoidPrimitive = new Cesium.Primitive({
+              geometryInstances: [ellipsoid],
+              appearance: new Cesium.PerInstanceColorAppearance({
+                closed: true,
+                translucent: true,
+              }),
+              depthFailAppearance: new Cesium.PerInstanceColorAppearance({
+                closed: true,
+                translucent: true,
+              }),
+              asynchronous: false,
+            });
+            viewer.scene.primitives.add(this.errorEllipsoidPrimitive);
+          }
+        }
+
+        const texturePickingHandler = new TexturePickingHandler();
+        app.addCurrentTilesetChangedListener(function () {
+          texturePickingHandler.clear();
+        });
+
+        //============================================================================
+        // Anchor point visualization
+
+        class AnchorPointVisualizer {
+          constructor() {
+            // A mapping from anchor point JSON objects to their entities
+            this.anchorPointEntities = new Map();
+
+            // The labels showing the uncertainty values for the anchor points
+            this.anchorPointLabelCollection = viewer.scene.primitives.add(
+              new Cesium.LabelCollection(),
+            );
+
+            // Whether the labels at the anchor points (containing the
+            // standard deviations) are visible
+            this.anchorPointLabelsVisible = false;
+
+            // A mapping from anchor point JSON objects to their labels
+            this.anchorPointLabels = new Map();
+
+            // The set of anchor point JSON object whose entities and labels
+            // should be added to the anchorPointEntities in the next frame
+            this.anchorPointsForNextFrame = new Set();
+
+            // For each file that is visible, obtain its anchor points
+            // and add them to the set of anchorPointsForNextFrame
+            const that = this;
+            this.tileVisibleListener = function (tile) {
+              const anchorPointsIndirect = that.obtainAnchorPoints(tile);
+              if (Cesium.defined(anchorPointsIndirect)) {
+                for (const anchorPoint of anchorPointsIndirect) {
+                  that.anchorPointsForNextFrame.add(anchorPoint);
+                }
+              }
+            };
+
+            this.initialize();
+          }
+
+          /**
+           * Initialize the anchor point visualization by attaching the
+           * required listeners to the scene and tileset
+           *
+           * @private
+           */
+          initialize() {
+            const that = this;
+
+            // Before rendering, clear the set of anchor points that
+            // should be shown in the next frame. The set will be
+            // filled with the ones that should be rendered, during
+            // the rendering process of the tileset, using the
+            // tileVisibleListener that was attached to the
+            // tileset.
+            viewer.scene.preRender.addEventListener(function () {
+              that.anchorPointsForNextFrame.clear();
+            });
+
+            // Trigger an update to attach the tileVisibleListener
+            // to the current tileset (if it is defined)
+            this.updateForCurrentTilesetChanged(undefined, app.currentTileset);
+
+            // After rendering, update the anchor point visualization
+            // by adding/removing elements from the anchorPointEntities
+            // as necessary
+            viewer.scene.postRender.addEventListener(function () {
+              // For all anchor points that should be visible in the next
+              // frame but are NOT yet visible: Create an entity in the
+              // viewer, and add it to the anchorPointEntities, and
+              // create a label and add it to the anchorPointLabelCollection
+              // and anchorPointLabels
+              for (const anchorPoint of that.anchorPointsForNextFrame) {
+                if (
+                  !that.anchorPointEntities.has(anchorPoint) ||
+                  !that.anchorPointLabels.has(anchorPoint)
+                ) {
+                  const anchorPointVisualizationData =
+                    that.createAnchorPointVisualizationData(anchorPoint);
+                  if (!that.anchorPointEntities.has(anchorPoint)) {
+                    const anchorPointEntity = that.createAnchorPointEntity(
+                      anchorPointVisualizationData,
+                    );
+                    that.anchorPointEntities.set(anchorPoint, anchorPointEntity);
+                  }
+
+                  if (!that.anchorPointLabels.has(anchorPoint)) {
+                    const anchorPointLabel = that.createAnchorPointLabel(
+                      anchorPointVisualizationData,
+                    );
+                    that.anchorPointLabels.set(anchorPoint, anchorPointLabel);
+                  }
+                }
+              }
+
+              // For all anchor points that currently ARE visible, but should
+              // not be visible in the next frame: Remove the entity from the
+              // viewer and the anchorPointEntities, and remove the label
+              // from the anchorPointLabelCollection and the anchorPointLabels
+              for (const anchorPoint of that.anchorPointEntities.keys()) {
+                if (!that.anchorPointsForNextFrame.has(anchorPoint)) {
+                  const anchorPointEntity = that.anchorPointEntities.get(anchorPoint);
+                  viewer.entities.remove(anchorPointEntity);
+                  that.anchorPointEntities.delete(anchorPoint);
+                }
+              }
+              for (const anchorPoint of that.anchorPointLabels.keys()) {
+                if (!that.anchorPointsForNextFrame.has(anchorPoint)) {
+                  const anchorPointLabel = that.anchorPointLabels.get(anchorPoint);
+                  that.anchorPointLabelCollection.remove(anchorPointLabel);
+                  that.anchorPointLabels.delete(anchorPoint);
+                }
+              }
+            });
+          }
+
+          /**
+           * Set whether the labels that show the standard deviation at the
+           * anchor points are currently visible.
+           *
+           * @param {boolean} anchorPointLabelsVisible
+           */
+          setAnchorPointLabelsVisible(anchorPointLabelsVisible) {
+            if (this.anchorPointLabelsVisible === anchorPointLabelsVisible) {
+              return;
+            }
+            this.anchorPointLabelsVisible = anchorPointLabelsVisible;
+            // Apparently, switching the `show` flag on/off sometimes causes the
+            // background to no longer be shown. This may be a CesiumJS issue,
+            // and has to be investigated. For now, just remove all labels when
+            // the flag was changed, which will cause them to be re-created
+            // in the next frame...
+            const labels = this.anchorPointLabels.values();
+            for (const label of labels) {
+              this.anchorPointLabelCollection.remove(label);
+            }
+            this.anchorPointLabels.clear();
+          }
+
+          /**
+           * Creates the data for the visualization of the given anchor point.
+           *
+           * The result will be an object with the following properties:
+           * - anchorPoint: The given anchorPoint
+           * - position: A Cartesian3 of the position
+           * - orientation: A Quaternion for the ellipsoid orientation
+           * - standardDeviations: A Cartesian3 containing the standard
+           *   deviations, serving as a basis for the ellipsoid radii
+           *
+           * @param {AnchorPointIndirect} anchorPoint The anchor point, as found in
+           * the `NGA_gpm_local` `anchorPointsIndirect` array
+           * @returns The visualization data
+           */
+          createAnchorPointVisualizationData(anchorPoint) {
+            const position = anchorPoint.position;
+
+            // Compute the eigen decomposition of the covariance matrix
+            const covarianceMatrix = anchorPoint.covarianceMatrix;
+            const eigenDecomposition = {
+              unitary: new Cesium.Matrix3(),
+              diagonal: new Cesium.Matrix3(),
+            };
+            Cesium.Matrix3.computeEigenDecomposition(
+              covarianceMatrix,
+              eigenDecomposition,
+            );
+
+            // The eigenvalues are the elements on the diagonal of the diagonal matrix
+            const eigenValue0 = eigenDecomposition.diagonal[0];
+            const eigenValue1 = eigenDecomposition.diagonal[4];
+            const eigenValue2 = eigenDecomposition.diagonal[8];
+
+            // The eigenvectors are the columns of the unitary matrix. The orientation
+            // is computed directly from this matrix.
+            const orientation = Cesium.Quaternion.fromRotationMatrix(
+              eigenDecomposition.unitary,
+              new Cesium.Quaternion(),
+            );
+
+            // The eigenvalues contain the variance. The square root of that
+            // is the standard deviation in meters, and used for the radii
+            // of the anchor point ellipsoid (multipled by the
+            // anchorPointEllipsoidScaling)
+            const standardDeviations = new Cesium.Cartesian3(
+              Math.sqrt(eigenValue0),
+              Math.sqrt(eigenValue1),
+              Math.sqrt(eigenValue2),
+            );
+
+            return {
+              anchorPoint: anchorPoint,
+              position: position,
+              orientation: orientation,
+              standardDeviations: standardDeviations,
+            };
+          }
+
+          /**
+           * Create a label showing the standard deviations from the given
+           * visualization data, at the position of the anchor point.
+           *
+           * @param {object} anchorPointVisualizationData The anchor point
+           * visualization data (see createAnchorPointVisualizationData)
+           * @returns The label
+           */
+          createAnchorPointLabel(anchorPointVisualizationData) {
+            const standardDeviations = anchorPointVisualizationData.standardDeviations;
+            const x = standardDeviations.x;
+            const y = standardDeviations.y;
+            const z = standardDeviations.z;
+            const text = `${x.toFixed(3)}m, ${y.toFixed(3)}m, ${z.toFixed(3)}m`;
+
+            const labelPosition = anchorPointVisualizationData.position;
+            const anchorPointLabel = this.anchorPointLabelCollection.add({
+              position: labelPosition,
+              show: this.anchorPointLabelsVisible,
+              text: text,
+              font: "12px sans-serif",
+              showBackground: true,
+              disableDepthTestDistance: 1e15,
+              horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+              verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+              pixelOffset: new Cesium.Cartesian2(0.0, 5.0),
+              pixelOffsetScaleByDistance: new Cesium.NearFarScalar(50, 0.0, 2000, -2.0),
+            });
+            return anchorPointLabel;
+          }
+
+          /**
+           * Creates the CesiumJS Entity for the given anchor point
+           *
+           * @param {object} anchorPointVisualizationData The anchor point
+           * visualization data (see createAnchorPointVisualizationData)
+           * @returns The entity
+           * @private
+           */
+          createAnchorPointEntity(anchorPointVisualizationData) {
+            const position = anchorPointVisualizationData.position;
+            const orientation = anchorPointVisualizationData.orientation;
+            const standardDeviations = anchorPointVisualizationData.standardDeviations;
+
+            const radii = new Cesium.Cartesian3();
+            const radiiProperty = new Cesium.CallbackProperty(function () {
+              const baseRadius = app.anchorPointEllipsoidScaling;
+              Cesium.Cartesian3.multiplyByScalar(standardDeviations, baseRadius, radii);
+              return radii;
+            }, false);
+
+            const anchorPointEntity = viewer.entities.add({
+              position: position,
+              orientation: orientation,
+              ellipsoid: {
+                radii: radiiProperty,
+                material: Cesium.Color.BLUE.withAlpha(0.5),
+                outline: true,
+                outlineColor: Cesium.Color.BLACK,
+              },
+            });
+            return anchorPointEntity;
+          }
+
+          /**
+           * Obtain the content from the given tile, and the `NGA_gpm_local` extension
+           * object from that content, and return the `anchorPointsIndirect`, or
+           * `undefined` if any element is `undefined`.
+           *
+           * @param {Tile} tile The tile
+           * @returns The anchor points, or undefined
+           */
+          obtainAnchorPoints(tile) {
+            const content = tile?.content;
+            const modelContent =
+              content instanceof Cesium.Model3DTileContent ? content : undefined;
+            if (!modelContent) {
+              return undefined;
+            }
+
+            const extensionObject = modelContent.getExtension("NGA_gpm_local");
+            if (!extensionObject) {
+              return undefined;
+            }
+            return extensionObject.anchorPointsIndirect;
+          }
+
+          /**
+           * Will be called via the "App" currentTilesetChangedListener, whenever
+           * the selected tileset changes.
+           *
+           * @param {Cesium3DTileset|undefined} oldCurrentTileset The old tileset
+           * @param {Cesium3DTileset|undefined} newCurrentTileset The new tileset
+           */
+          updateForCurrentTilesetChanged(oldCurrentTileset, newCurrentTileset) {
+            if (oldCurrentTileset !== undefined) {
+              oldCurrentTileset.tileVisible.removeEventListener(this.tileVisibleListener);
+            }
+            if (newCurrentTileset !== undefined) {
+              newCurrentTileset.tileVisible.addEventListener(this.tileVisibleListener);
+            }
+          }
+        }
+
+        const anchorPointVisualizer = new AnchorPointVisualizer();
+        app.addCurrentTilesetChangedListener(
+          function (oldCurrentTileset, newCurrentTileset) {
+            anchorPointVisualizer.updateForCurrentTilesetChanged(
+              oldCurrentTileset,
+              newCurrentTileset,
+            );
+          },
+        );
+
+        //============================================================================
+        // ViewModel for Sandcastle UI
+
+        const interactionOptions = [
+          {
+            text: "View",
+            onselect: function () {
+              texturePickingHandler.setEnabled(false);
+            },
+          },
+          {
+            text: "Pick",
+            onselect: function () {
+              texturePickingHandler.setEnabled(true);
+            },
+          },
+        ];
+
+        const shaderOptions = PropertyTextureShaders.createShaderOptions();
+
+        const viewModel = {
+          textureThreshold: 16.0,
+          anchorPointEllipsoidScaling: app.anchorPointEllipsoidScaling,
+          anchorPointLabelsVisible: app.anchorPointLabelsVisible,
+          dataSetNames: dataSetOptions.map((e) => e.name),
+          dataSetName: "Port Canaveral",
+          zoomToCurrentTileset: function () {
+            app.zoomToCurrentTileset();
+          },
+          interactionModes: interactionOptions.map((e) => e.text),
+          interactionMode: "Pick",
+          shaderModes: shaderOptions.map((e) => e.text),
+          shaderMode: "Default Shading",
+        };
+
+        // enable texture picking mode by default
+        texturePickingHandler.setEnabled(true);
+
+        async function updateModelFromView() {
+          app.anchorPointEllipsoidScaling = Number(viewModel.anchorPointEllipsoidScaling);
+          const anchorPointLabelsVisible = Boolean(viewModel.anchorPointLabelsVisible);
+          anchorPointVisualizer.setAnchorPointLabelsVisible(anchorPointLabelsVisible);
+          app.textureThreshold = Number(viewModel.textureThreshold);
+          await app.selectCurrentDataSet(viewModel.dataSetName);
+          for (const interactionOption of interactionOptions) {
+            if (interactionOption.text === viewModel.interactionMode) {
+              interactionOption.onselect();
+            }
+          }
+          for (const shaderOption of shaderOptions) {
+            if (shaderOption.text === viewModel.shaderMode) {
+              shaderOption.onselect();
+            }
+          }
+        }
+
+        Cesium.knockout.track(viewModel);
+        const toolbar = document.getElementById("toolbar");
+        Cesium.knockout.applyBindings(viewModel, toolbar);
+        for (const name in viewModel) {
+          if (viewModel.hasOwnProperty(name)) {
+            Cesium.knockout.getObservable(viewModel, name).subscribe(updateModelFromView);
+          }
+        }
+
+        await app.selectCurrentDataSet(dataSetOptions[0].name);
+
+        const scene = viewer.scene;
+
+        const canvas = viewer.canvas;
+        canvas.setAttribute("tabindex", "0"); // Put focus on the canvas
+        canvas.onclick = function () {
+          canvas.focus();
+        };
+
+        function captureCameraSettings(viewer) {
+          const camera = viewer.camera;
+          const cameraCode = `viewer.scene.camera.setView({
+  destination: new Cesium.Cartesian3(${camera.position.x}, ${camera.position.y}, ${camera.position.z}),
+  orientation: new Cesium.HeadingPitchRoll(${camera.heading}, ${camera.pitch}, ${camera.roll}),
+});`;
+          console.log(cameraCode);
+        }
+
+        document.addEventListener("keydown", function (e) {
+          if (e.key === "c") {
+            captureCameraSettings(viewer);
+          }
+        });
+
+        //Sandcastle_End
+      };
+      if (typeof Cesium !== "undefined") {
+        window.startupCalled = true;
+        window.startup(Cesium).catch((error) => {
+          "use strict";
+          console.error(error);
+        });
+        Sandcastle.finishedLoading();
+      }
+    </script>
+  </body>
+</html>
diff --git a/Apps/Sandcastle/gallery/development/NGA GPM Visualization.jpg b/Apps/Sandcastle/gallery/development/NGA GPM Visualization.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5b2daea52ce03c25b298593a0d15c500b66cbe60
GIT binary patch
literal 8429
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

literal 0
HcmV?d00001


From b4e5af441bce29cf58800c8e80c06b14477d59b1 Mon Sep 17 00:00:00 2001
From: Marco Hutter <javagl@javagl.de>
Date: Wed, 16 Oct 2024 16:02:27 +0200
Subject: [PATCH 2/7] Update GPM visualization Sandcastle

---
 .../3D Tiles NGA GPM Visualization.html       | 1352 +++++++++++++++++
 .../3D Tiles NGA GPM Visualization.jpg        |  Bin 0 -> 8429 bytes
 2 files changed, 1352 insertions(+)
 create mode 100644 Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html
 create mode 100644 Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.jpg

diff --git a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html
new file mode 100644
index 000000000000..0a5c679375af
--- /dev/null
+++ b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
@@ -0,0 +1,1352 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
+    />
+    <meta
+      name="description"
+      content="An example for the visualization of NGA_gpm_local extension data"
+    />
+    <meta name="cesium-sandcastle-labels" content="3D Tiles" />
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script
+      type="text/javascript"
+      src="../../../Build/CesiumUnminified/Cesium.js"
+      nomodule
+    ></script>
+    <script type="module" src="../load-cesium-es6.js"></script>
+  </head>
+
+  <body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+    <style>
+      @import url(../templates/bucket.css);
+
+      #toolbar {
+        background: rgba(42, 42, 42, 0.8);
+        padding: 4px;
+        border-radius: 4px;
+      }
+
+      #toolbar input {
+        vertical-align: middle;
+        padding-top: 2px;
+        padding-bottom: 2px;
+      }
+    </style>
+    <div id="cesiumContainer" class="fullSize"></div>
+    <div id="loadingOverlay">
+      <h1>Loading...</h1>
+    </div>
+    <div id="toolbar">
+      <table>
+        <tbody>
+          <tr>
+            <td colspan="3">
+              <h4>Cesium GPM Visualization</h4>
+            </td>
+          </tr>
+          <tr>
+            <td>Data set</td>
+            <td>
+              <select data-bind="options: dataSetNames, value: dataSetName"></select>
+            </td>
+            <td style="text-align: right">
+              <button type="button" data-bind="click: zoomToCurrentTileset">Zoom</button>
+            </td>
+          </tr>
+          <tr>
+            <td>Anchor point ellipsoid</td>
+            <td colspan="2">
+              <input
+                type="range"
+                min="1.0"
+                max="500"
+                step="1"
+                data-bind="value: anchorPointEllipsoidScaling, valueUpdate: 'input'"
+              />
+              <input
+                type="text"
+                size="5"
+                data-bind="value: anchorPointEllipsoidScaling"
+              />
+              <label
+                ><input
+                  type="checkbox"
+                  data-bind="checked: anchorPointLabelsVisible"
+                />Labels</label
+              >
+            </td>
+          </tr>
+          <tr>
+            <td>Shader mode</td>
+            <td colspan="2">
+              <select data-bind="options: shaderModes, value: shaderMode"></select>
+            </td>
+          </tr>
+          <tr id="texture-threshold-control" class="hidden">
+            <td>Texture threshold (m)</td>
+            <td>
+              <input
+                type="range"
+                min="0.0"
+                max="16.0"
+                step="0.01"
+                data-bind="value: textureThreshold, valueUpdate: 'input'"
+              />
+              <input type="text" size="5" data-bind="value: textureThreshold" />
+            </td>
+          </tr>
+          <tr>
+            <td colspan="3">
+              <br />
+              Uncertainty information is stored as GPM metadata in the tiles.<br />
+              <br />
+              The <i>anchor points</i> provide information about the low-frequency
+              error.<br />
+              This error is visualized as ellipsoids.<br />
+              <br />
+              The high-frequency error is represented as
+              <i>Per-Point Error</i> textures.<br />
+              This error can be visualized with custom shaders. The 'uncertainty'<br />
+              shaders visualize the horizontal or vertical uncertainty with a color<br />
+              scale. The 'threshold' shaders highlight areas where the selected<br />
+              error threshold is exceeded. Picking a point on the tileset will show<br />
+              a label with the actual error values.
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+    <script id="cesium_sandcastle_script">
+      window.startup = async function (Cesium) {
+        "use strict";
+        //Sandcastle_Begin
+
+        // Basic setup
+        const viewer = new Cesium.Viewer("cesiumContainer", {
+          timeline: false,
+          animation: false,
+          depthPlaneEllipsoidOffset: 10000,
+        });
+
+        const maxarCredit = new Cesium.Credit(
+          "<span>Provided by Maxar for GPM v1.2 evaluation purposes</span>",
+          true,
+        );
+        viewer.creditDisplay.addStaticCredit(maxarCredit);
+
+        // The options that will be passed to all Cesium3DTileset.from ... functions
+        const defaultTilesetOptions = {
+          maximumScreenSpaceError: 4,
+          cacheBytes: 536870912 * 4,
+        };
+
+        // The set of data sets that are available in the UI
+        const dataSetOptions = [
+          {
+            name: "Port Canaveral",
+            assetId: 2772481,
+            initialCameraConfiguration: {
+              destination: new Cesium.Cartesian3(
+                918010.2634368961,
+                -5538948.372542206,
+                3016855.1270222967,
+              ),
+              orientation: new Cesium.HeadingPitchRoll(
+                4.316957618964909,
+                -0.36573164980955686,
+                6.283174173076164,
+              ),
+            },
+          },
+          {
+            name: "Lajes",
+            assetId: 2772479,
+            initialCameraConfiguration: {
+              destination: new Cesium.Cartesian3(
+                4436474.736810458,
+                -2279634.446362909,
+                3962861.396769178,
+              ),
+              orientation: new Cesium.HeadingPitchRoll(
+                5.214554743456651,
+                -0.5265190154471187,
+                0.000008735845947960286,
+              ),
+            },
+          },
+        ];
+
+        /**
+         * Create a tileset from the given data set option
+         *
+         * @param {object} dataSetOption The data set option
+         * @returns A promise to wait for
+         */
+        async function createTileset(dataSetOption) {
+          const assetId = dataSetOption.assetId;
+          return viewer.scene.primitives.add(
+            await Cesium.Cesium3DTileset.fromIonAssetId(assetId, defaultTilesetOptions),
+          );
+        }
+
+        //============================================================================
+        // Application state
+
+        class App {
+          constructor() {
+            // The name of the current data set, as of the
+            // dataSetOptions[i].name
+            this._currentDataSetName = undefined;
+
+            // The current tileset
+            this._currentTileset = undefined;
+
+            // The current custom shader, or undefined
+            this._currentCustomShader = undefined;
+
+            // The current value of the `u_textureThreshold` uniform that indicates
+            // whether fragments should be highlighted in the `currentCustomShader`.
+            this._textureThreshold = 3.0;
+
+            // The scaling factor for the anchor point ellipsoids
+            this.anchorPointEllipsoidScaling = 100.0;
+
+            // A set of functions that will be called whenever
+            // the `currentTileset` changed, and receive the
+            // oldCurrentTileset and newCurrentTileset
+            this._currentTilesetChangedListeners = [];
+          }
+
+          async selectCurrentDataSet(dataSetName) {
+            if (this._currentDataSetName === dataSetName) {
+              return;
+            }
+            for (const dataSetOption of dataSetOptions) {
+              if (dataSetOption.name === dataSetName) {
+                this._currentDataSetName = dataSetName;
+                await this.createCurrentTileset(dataSetOption);
+              }
+            }
+          }
+
+          get currentTileset() {
+            return this._currentTileset;
+          }
+          set currentTileset(value) {
+            const oldCurrentTileset = this._currentTileset;
+            this._currentTileset = value;
+            this.updateCustomShaderInTileset();
+            this.notifyCurrentTilesetChanged(oldCurrentTileset, this.currentTileset);
+          }
+
+          /**
+           * Add the given function to be called when the current tileset
+           * changed, receiving the "old" and the "new" current tileset.
+           *
+           * @param {object} listener The listener
+           */
+          addCurrentTilesetChangedListener(listener) {
+            this._currentTilesetChangedListeners.push(listener);
+          }
+
+          /**
+           * Notify all registered listeners that the current tileset changed
+           *
+           * @param {Cesium3DTileset} oldCurrentTileset
+           * @param {Cesium3DTileset} newCurrentTileset
+           *
+           * @private
+           */
+          notifyCurrentTilesetChanged(oldCurrentTileset, newCurrentTileset) {
+            for (const listener of this._currentTilesetChangedListeners) {
+              listener(oldCurrentTileset, newCurrentTileset);
+            }
+          }
+
+          get currentCustomShader() {
+            return this._currentCustomShader;
+          }
+          set currentCustomShader(value) {
+            this._currentCustomShader = value;
+            this.updateTextureThresholdInShader();
+            this.updateCustomShaderInTileset();
+          }
+
+          /**
+           * If the currentTileset is defined, then assign the currentCustomShader
+           * to it.
+           *
+           * @private
+           */
+          updateCustomShaderInTileset() {
+            if (this.currentTileset === undefined) {
+              return;
+            }
+            this.currentTileset.customShader = this.currentCustomShader;
+          }
+
+          get textureThreshold() {
+            return this._textureThreshold;
+          }
+
+          set textureThreshold(value) {
+            this._textureThreshold = value;
+            this.updateTextureThresholdInShader();
+          }
+
+          /**
+           * If the currentCustomShader is defined and has a `u_textureThreshold`
+           * uniform, then set its value to the current `textureThreshold`
+           *
+           * @private
+           */
+          updateTextureThresholdInShader() {
+            if (this.currentCustomShader === undefined) {
+              return;
+            }
+            const hasTextureThreshold = Object.keys(
+              this.currentCustomShader.uniforms,
+            ).includes("u_textureThreshold");
+            if (!hasTextureThreshold) {
+              return;
+            }
+            this.currentCustomShader.setUniform(
+              "u_textureThreshold",
+              this.textureThreshold,
+            );
+          }
+
+          /**
+           * Load the tileset that is described in the given data
+           * set option, and set it as the current tileset.
+           *
+           * @param {object} dataSetOption The data set option
+           * @returns A promise to wait for...
+           */
+          async createCurrentTileset(dataSetOption) {
+            if (Cesium.defined(this.currentTileset)) {
+              viewer.scene.primitives.remove(this.currentTileset);
+              this.currentTileset = undefined;
+            }
+
+            this.currentTileset = await createTileset(dataSetOption);
+            if (Cesium.defined(dataSetOption.initialCameraConfiguration)) {
+              viewer.scene.camera.setView(dataSetOption.initialCameraConfiguration);
+            } else {
+              this.zoomToCurrentTileset();
+            }
+          }
+
+          /**
+           * Zoom to the current tileset, with a small, unspecified offset...
+           */
+          zoomToCurrentTileset() {
+            if (this.currentTileset === undefined) {
+              return;
+            }
+            const offset = new Cesium.HeadingPitchRange(
+              Cesium.Math.toRadians(0.0),
+              Cesium.Math.toRadians(-22.5),
+              10000.0,
+            );
+            viewer.zoomTo(this.currentTileset, offset);
+          }
+        }
+
+        const app = new App();
+
+        //============================================================================
+
+        /**
+         * Pick the local uncertainty information from the texture at the given
+         * window position.
+         *
+         * This makes assumptions about the structure of the metadata that is
+         * contained in the underlying data sets.
+         *
+         * It assumes that the data contains two PPE (Per-Point-Error) textures
+         * that are internally converted into structural metadata property
+         * texture properties.
+         *
+         * The first PPE texture uses the SIGZ trait (sigma/standard deviation in
+         * z-direction, in meters). This will be the `y`-component of the result.
+         *
+         * The second PPE texture uses the SIGR trait (sigma/standard deviation in
+         * radial direction in meters). This will be the x-component of the result.
+         *
+         * (Both values are in the range of [0...16], with 16 being the noData value)
+         *
+         * @param {Cartesian2} windowPosition The position in the window
+         * @returns {Cartesian2} The local uncertainty, with `x` being
+         * the radial uncertainty and `y` being the vertical uncertainty
+         */
+        function pickUncertaintyFromTexture(windowPosition) {
+          const schemaId = undefined;
+          const classNameX = "ppeTexture_1";
+          const propertyNameX = "SIGR";
+          const classNameY = "ppeTexture_0";
+          const propertyNameY = "SIGZ";
+          const result = new Cesium.Cartesian2();
+
+          let metadataValueX = viewer.scene.pickMetadata(
+            windowPosition,
+            schemaId,
+            classNameX,
+            propertyNameX,
+          );
+          let metadataValueY = viewer.scene.pickMetadata(
+            windowPosition,
+            schemaId,
+            classNameY,
+            propertyNameY,
+          );
+
+          if (!metadataValueX) {
+            metadataValueX = 0;
+          }
+          if (!metadataValueY) {
+            metadataValueY = 0;
+          }
+          result.x = metadataValueX;
+          result.y = metadataValueY;
+          return result;
+        }
+
+        //============================================================================
+        // Property texture shaders
+
+        class PropertyTextureShaders {
+          /**
+           * Create a custom (fragment) shader for the specified property.
+           *
+           * It accesses the metadata value with the given property name and
+           * normalizes it to a value in [0,1] based on the given source range.
+           * If the resulting value is less than 1.0, this value is used
+           * as the brightness for the fragment.
+           *
+           * @param {string} propertyName The property name
+           * @param {number} sourceMin The minimum source value
+           * @param {number} sourceMax The maximum source value
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createShader1D(propertyName, sourceMin, sourceMax) {
+            const shader = new Cesium.CustomShader({
+              fragmentShaderText: `
+                void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+                {
+                  float value = float(fsInput.metadata.${propertyName});
+                  float range = float(${sourceMax}) - float(${sourceMin});
+                  float brightness = (value - float(${sourceMin})) / range;
+
+                  if (value < float(${sourceMax})) {
+                    material.diffuse = vec3(brightness);
+                  }
+                }
+              `,
+            });
+            return shader;
+          }
+
+          /**
+           * Create a custom (fragment) shader for the specified properties.
+           *
+           * It accesses the metadata values with the given property names and
+           * normalizes them to a value in [0,1] based on the given source ranges.
+           * If the resulting values are both less than 1.0, the values are used
+           * as the red- and green components of the fragment.
+           *
+           * @param {string} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createShader2D(
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            const shader = new Cesium.CustomShader({
+              fragmentShaderText: `
+                void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+                {
+                  float value0 = float(fsInput.metadata.${propertyName0});
+                  float range0 = float(${sourceMax0}) - float(${sourceMin0});
+                  float brightness0 = (value0 - float(${sourceMin0})) / range0;
+
+                  float value1 = float(fsInput.metadata.${propertyName1});
+                  float range1 = float(${sourceMax1}) - float(${sourceMin1});
+                  float brightness1 = (value1 - float(${sourceMin1})) / range1;
+
+                  if (value0 < float(${sourceMax0}) && value1 < float(${sourceMax1})) {
+                    material.diffuse = vec3(brightness0, brightness1, 0.0);
+                  }
+                }
+              `,
+            });
+            return shader;
+          }
+
+          /**
+           * Create a custom (fragment) shader for a threshold visualization of
+           * the specified property.
+           *
+           * It defines a `u_textureThreshold` FLOAT uniform for the threshold
+           * value. It accesses the metadata value with the given property name.
+           * If the resulting value is less than 1.0 but larger than
+           * the threshold, then the fragment will be shown in a highlighting
+           * color. Otherwise, the fragment will be shown with its original
+           * color with lower saturation and lightness.
+           *
+           * @param {string} propertyName The property name
+           * @param {number} sourceMin The minimum source value
+           * @param {number} sourceMax The maximum source value
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createThresholdShader1D(propertyName, sourceMin, sourceMax) {
+            const shader = new Cesium.CustomShader({
+              uniforms: {
+                // A threshold value for the texture: When this
+                // is exceeded, then the fragment will be highlighted
+                u_textureThreshold: {
+                  type: Cesium.UniformType.FLOAT,
+                  value: 3.0,
+                },
+              },
+              fragmentShaderText: `
+                void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+                {
+                  float value = float(fsInput.metadata.${propertyName});
+                  float range = float(${sourceMax}) - float(${sourceMin});
+                  float brightness = (value - float(${sourceMin})) / range;
+
+                  if (value < float(${sourceMax}) && value > u_textureThreshold) {
+                    material.diffuse = vec3(1.0, 1.0, 0.0);
+                  } else {
+                    vec3 diffuseHsl = czm_RGBToHSL(material.diffuse);
+                    diffuseHsl.y *= 0.25;
+                    diffuseHsl.z *= 0.25;
+                    material.diffuse = czm_HSLToRGB(diffuseHsl);
+                  }
+                }
+              `,
+            });
+            return shader;
+          }
+
+          /**
+           * Create a custom (fragment) shader for a threshold visualization of
+           * the specified property.
+           *
+           * It defines a `u_textureThreshold` FLOAT uniform for the threshold
+           * value. It accesses the metadata values with the given property names.
+           * If the resulting value is less than 1.0 but larger than
+           * the threshold, then the fragment will be shown in a highlighting
+           * color. Otherwise, the fragment will be shown with its original
+           * color with lower saturation and lightness.
+           *
+           * @param {string} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The `CustomShader`
+           * @private
+           */
+          static createThresholdShader2D(
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            const shader = new Cesium.CustomShader({
+              uniforms: {
+                // A threshold value for the texture: When this
+                // is exceeded, then the fragment will be highlighted
+                u_textureThreshold: {
+                  type: Cesium.UniformType.FLOAT,
+                  value: 3.0,
+                },
+              },
+              fragmentShaderText: `
+                void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
+                {
+                  float value0 = float(fsInput.metadata.${propertyName0});
+                  float range0 = float(${sourceMax0}) - float(${sourceMin0});
+                  float brightness0 = (value0 - float(${sourceMin0})) / range0;
+
+                  float value1 = float(fsInput.metadata.${propertyName1});
+                  float range1 = float(${sourceMax1}) - float(${sourceMin1});
+                  float brightness1 = (value1 - float(${sourceMin1})) / range1;
+        
+                  vec3 diffuseHsl = czm_RGBToHSL(material.diffuse);
+                  diffuseHsl.y *= 0.25;
+                  diffuseHsl.z *= 0.25;
+                  vec3 diffuseResult = czm_HSLToRGB(diffuseHsl);
+
+                  if (value0 < float(${sourceMax0}) && value0 > u_textureThreshold) {
+                    diffuseResult.x = 1.0;
+                    diffuseResult.y = 1.0;
+                  }
+                  if (value1 < float(${sourceMax1}) && value1 > u_textureThreshold) {
+                    diffuseResult.x = 1.0;
+                    diffuseResult.z = 1.0;
+                  }
+                  material.diffuse = diffuseResult;
+                }
+              `,
+            });
+            return shader;
+          }
+
+          /**
+           * Creates a object that can be used as one entry in the options
+           * of a Sandcastle toolbar menu.
+           *
+           * Depending on which property names are defined, this will
+           * create an option to select default shading, a 1D shader,
+           * or a 2D shader
+           *
+           * @param {string} title The title to be displayed in the combox box
+           * @param {string|undefined} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string|undefined} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The shader option
+           * @private
+           */
+          static createShaderOption(
+            title,
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            return {
+              text: title,
+              onselect: function () {
+                if (Cesium.defined(propertyName0) && Cesium.defined(propertyName1)) {
+                  app.currentCustomShader = PropertyTextureShaders.createShader2D(
+                    propertyName0,
+                    sourceMin0,
+                    sourceMax0,
+                    propertyName1,
+                    sourceMin1,
+                    sourceMax1,
+                  );
+                } else if (Cesium.defined(propertyName0)) {
+                  app.currentCustomShader = PropertyTextureShaders.createShader1D(
+                    propertyName0,
+                    sourceMin0,
+                    sourceMax0,
+                  );
+                } else {
+                  app.currentCustomShader = undefined;
+                }
+
+                document.getElementById("texture-threshold-control").className = "hidden";
+              },
+            };
+          }
+
+          /**
+           * Creates a object that can be used as one entry in the options
+           * of a Sandcastle toolbar menu.
+           *
+           * It will allow selecting a "threshold shader" for the specified
+           * properties.
+           *
+           * @param {string} title The title to be displayed in the combox box
+           * @param {string} title The title to be displayed in the combox box
+           * @param {string|undefined} propertyName0 The property name 0
+           * @param {number} sourceMin0 The minimum source value 0
+           * @param {number} sourceMax0 The maximum source value 0
+           * @param {string|undefined} propertyName1 The property name 1
+           * @param {number} sourceMin1 The minimum source value 1
+           * @param {number} sourceMax1 The maximum source value 1
+           * @returns The shader option
+           * @private
+           */
+          static createThresholdShaderOption(
+            title,
+            propertyName0,
+            sourceMin0,
+            sourceMax0,
+            propertyName1,
+            sourceMin1,
+            sourceMax1,
+          ) {
+            return {
+              text: title,
+              onselect: function () {
+                if (Cesium.defined(propertyName0) && Cesium.defined(propertyName1)) {
+                  app.currentCustomShader =
+                    PropertyTextureShaders.createThresholdShader2D(
+                      propertyName0,
+                      sourceMin0,
+                      sourceMax0,
+                      propertyName1,
+                      sourceMin1,
+                      sourceMax1,
+                    );
+                } else if (Cesium.defined(propertyName0)) {
+                  app.currentCustomShader =
+                    PropertyTextureShaders.createThresholdShader1D(
+                      propertyName0,
+                      sourceMin0,
+                      sourceMax0,
+                    );
+                } else {
+                  app.currentCustomShader = undefined;
+                }
+
+                document.getElementById("texture-threshold-control").className = "";
+              },
+            };
+          }
+
+          /**
+           * Create the shader options for the Sandcastle toolbar menu
+           */
+          static createShaderOptions() {
+            // Note: The value of `16.0` that appears here corresponds
+            // to the "ppeTextures[i].traits.max" value that is found
+            // in the NGA_gpm_local extension object that is contained
+            // in the meshPrimitive objects
+
+            const shaderOptions = [
+              PropertyTextureShaders.createShaderOption(
+                "Default Shading",
+                undefined,
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createShaderOption(
+                "Local Vertical Uncertainty",
+                "SIGZ",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createShaderOption(
+                "Local Radial Uncertainty",
+                "SIGR",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createShaderOption(
+                "Local Combined Uncertainty",
+                "SIGZ",
+                0.0,
+                16.0,
+                "SIGR",
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createThresholdShaderOption(
+                "Local Vertical Threshold",
+                "SIGZ",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createThresholdShaderOption(
+                "Local Radial Threshold",
+                "SIGR",
+                0.0,
+                16.0,
+                undefined,
+                0.0,
+                16.0,
+              ),
+              PropertyTextureShaders.createThresholdShaderOption(
+                "Local Combined Threshold",
+                "SIGZ",
+                0.0,
+                16.0,
+                "SIGR",
+                0.0,
+                16.0,
+              ),
+            ];
+            return shaderOptions;
+          }
+        }
+
+        //============================================================================
+        // Texture picking: A label and an ellipsoid for the local uncertainty at
+        // the picked position
+
+        class TexturePickingHandler {
+          constructor() {
+            // Whether texture picking is currently enabled
+            this.enabled = false;
+
+            // The current ellipsoid primitive showing the uncertainty radii
+            this.errorEllipsoidPrimitive = undefined;
+
+            const errorLabels = viewer.scene.primitives.add(new Cesium.LabelCollection());
+            // The label showing the uncertainty values
+            this.errorLabel = errorLabels.add({
+              position: Cesium.Cartesian3.fromDegrees(0, 0),
+              show: false,
+              text: "",
+              font: "20px sans-serif",
+              showBackground: true,
+              disableDepthTestDistance: 1e15,
+              horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+              verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+              pixelOffset: new Cesium.Cartesian2(0.0, 5.0),
+              pixelOffsetScaleByDistance: new Cesium.NearFarScalar(50, 0.0, 2000, -2.0),
+            });
+
+            // Install the handler that will pick the uncertainty values
+            // from the texture, and update the error ellipsoid and label
+            const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
+            const that = this;
+            handler.setInputAction(function (movement) {
+              if (!that.enabled) {
+                return;
+              }
+              const worldPosition = viewer.scene.pickPosition(movement.position);
+              if (worldPosition === undefined) {
+                that.clear();
+              } else {
+                const uncertainty = pickUncertaintyFromTexture(movement.position);
+                that.update(worldPosition, uncertainty.x, uncertainty.y);
+              }
+            }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+            handler.setInputAction(function () {
+              if (!that.enabled) {
+                return;
+              }
+              that.clear();
+            }, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
+          }
+
+          /**
+           * Set whether texture uncertainty picking is currently enabled
+           *
+           * @param {boolean} enabled The state
+           */
+          setEnabled(enabled) {
+            this.enabled = enabled;
+            if (!enabled) {
+              this.clear();
+            }
+          }
+
+          /**
+           * Hide the error label, and remove the error ellipsoid
+           */
+          clear() {
+            viewer.scene.primitives.remove(this.errorEllipsoidPrimitive);
+            this.errorEllipsoidPrimitive = undefined;
+            this.errorLabel.show = false;
+          }
+
+          /**
+           * Update the error label and ellipsoid primitive for the
+           * given parameters.
+           *
+           * @param {Cartesian3} worldPosition The position for the label
+           * and ellipsoid
+           * @param {number} sizeX The radial size (uncertainty)
+           * @param {number} sizeY The vertical size (uncertainty)
+           * @private
+           */
+          update(center, sizeX, sizeY) {
+            this.updateErrorLabel(center, sizeX, sizeY);
+            this.updateErrorEllipsoidPrimitive(center, sizeX, sizeY);
+          }
+
+          /**
+           * Update the error label for the given parameters.
+           *
+           * @param {Cartesian3} worldPosition The position for the label
+           * @param {number} sizeX The radial size (uncertainty)
+           * @param {number} sizeY The vertical size (uncertainty)
+           * @private
+           */
+          updateErrorLabel(center, sizeX, sizeY) {
+            const cartographic = Cesium.Cartographic.fromCartesian(center);
+            cartographic.height += sizeY + 1.0;
+            const labelPosition = Cesium.Cartographic.toCartesian(cartographic);
+            this.errorLabel.position = labelPosition;
+            this.errorLabel.show = true;
+            const radialString = sizeX === 16.0 ? "(unknown)" : `${sizeX.toFixed(4)}m`;
+            const verticalString = sizeY === 16.0 ? "(unknown)" : `${sizeY.toFixed(4)}m`;
+            this.errorLabel.text =
+              `Local Radial Uncertainty: ${radialString}\n` +
+              `Local Vertical Uncertainty: ${verticalString}`;
+          }
+
+          /**
+           * Update the error ellipsoid primitive for the given parameters.
+           *
+           * @param {Cartesian3} worldPosition The position for the ellipsoid
+           * @param {number} sizeX The radial size (uncertainty)
+           * @param {number} sizeY The vertical size (uncertainty)
+           * @private
+           */
+          updateErrorEllipsoidPrimitive(center, sizeX, sizeY) {
+            viewer.scene.primitives.remove(this.errorEllipsoidPrimitive);
+            const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);
+            const ellipsoidGeometry = new Cesium.EllipsoidGeometry({
+              radii: new Cesium.Cartesian3(sizeX, sizeX, sizeY),
+              vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
+            });
+            const ellipsoid = new Cesium.GeometryInstance({
+              geometry: ellipsoidGeometry,
+              modelMatrix: modelMatrix,
+              attributes: {
+                color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                  Cesium.Color.BLUE.withAlpha(0.6),
+                ),
+                depthFailColor: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                  Cesium.Color.BLUE.withAlpha(0.2),
+                ),
+              },
+            });
+            this.errorEllipsoidPrimitive = new Cesium.Primitive({
+              geometryInstances: [ellipsoid],
+              appearance: new Cesium.PerInstanceColorAppearance({
+                closed: true,
+                translucent: true,
+              }),
+              depthFailAppearance: new Cesium.PerInstanceColorAppearance({
+                closed: true,
+                translucent: true,
+              }),
+              asynchronous: false,
+            });
+            viewer.scene.primitives.add(this.errorEllipsoidPrimitive);
+          }
+        }
+
+        const texturePickingHandler = new TexturePickingHandler();
+        app.addCurrentTilesetChangedListener(function () {
+          texturePickingHandler.clear();
+        });
+
+        //============================================================================
+        // Anchor point visualization
+
+        class AnchorPointVisualizer {
+          constructor() {
+            // A mapping from anchor point JSON objects to their entities
+            this.anchorPointEntities = new Map();
+
+            // The labels showing the uncertainty values for the anchor points
+            this.anchorPointLabelCollection = viewer.scene.primitives.add(
+              new Cesium.LabelCollection(),
+            );
+
+            // Whether the labels at the anchor points (containing the
+            // standard deviations) are visible
+            this.anchorPointLabelsVisible = false;
+
+            // A mapping from anchor point JSON objects to their labels
+            this.anchorPointLabels = new Map();
+
+            // The set of anchor point JSON object whose entities and labels
+            // should be added to the anchorPointEntities in the next frame
+            this.anchorPointsForNextFrame = new Set();
+
+            // For each file that is visible, obtain its anchor points
+            // and add them to the set of anchorPointsForNextFrame
+            const that = this;
+            this.tileVisibleListener = function (tile) {
+              const anchorPointsIndirect = that.obtainAnchorPoints(tile);
+              if (Cesium.defined(anchorPointsIndirect)) {
+                for (const anchorPoint of anchorPointsIndirect) {
+                  that.anchorPointsForNextFrame.add(anchorPoint);
+                }
+              }
+            };
+
+            this.initialize();
+          }
+
+          /**
+           * Initialize the anchor point visualization by attaching the
+           * required listeners to the scene and tileset
+           *
+           * @private
+           */
+          initialize() {
+            const that = this;
+
+            // Before rendering, clear the set of anchor points that
+            // should be shown in the next frame. The set will be
+            // filled with the ones that should be rendered, during
+            // the rendering process of the tileset, using the
+            // tileVisibleListener that was attached to the
+            // tileset.
+            viewer.scene.preRender.addEventListener(function () {
+              that.anchorPointsForNextFrame.clear();
+            });
+
+            // Trigger an update to attach the tileVisibleListener
+            // to the current tileset (if it is defined)
+            this.updateForCurrentTilesetChanged(undefined, app.currentTileset);
+
+            // After rendering, update the anchor point visualization
+            // by adding/removing elements from the anchorPointEntities
+            // as necessary
+            viewer.scene.postRender.addEventListener(function () {
+              // For all anchor points that should be visible in the next
+              // frame but are NOT yet visible: Create an entity in the
+              // viewer, and add it to the anchorPointEntities, and
+              // create a label and add it to the anchorPointLabelCollection
+              // and anchorPointLabels
+              for (const anchorPoint of that.anchorPointsForNextFrame) {
+                if (
+                  !that.anchorPointEntities.has(anchorPoint) ||
+                  !that.anchorPointLabels.has(anchorPoint)
+                ) {
+                  const anchorPointVisualizationData =
+                    that.createAnchorPointVisualizationData(anchorPoint);
+                  if (!that.anchorPointEntities.has(anchorPoint)) {
+                    const anchorPointEntity = that.createAnchorPointEntity(
+                      anchorPointVisualizationData,
+                    );
+                    that.anchorPointEntities.set(anchorPoint, anchorPointEntity);
+                  }
+
+                  if (!that.anchorPointLabels.has(anchorPoint)) {
+                    const anchorPointLabel = that.createAnchorPointLabel(
+                      anchorPointVisualizationData,
+                    );
+                    that.anchorPointLabels.set(anchorPoint, anchorPointLabel);
+                  }
+                }
+              }
+
+              // For all anchor points that currently ARE visible, but should
+              // not be visible in the next frame: Remove the entity from the
+              // viewer and the anchorPointEntities, and remove the label
+              // from the anchorPointLabelCollection and the anchorPointLabels
+              for (const anchorPoint of that.anchorPointEntities.keys()) {
+                if (!that.anchorPointsForNextFrame.has(anchorPoint)) {
+                  const anchorPointEntity = that.anchorPointEntities.get(anchorPoint);
+                  viewer.entities.remove(anchorPointEntity);
+                  that.anchorPointEntities.delete(anchorPoint);
+                }
+              }
+              for (const anchorPoint of that.anchorPointLabels.keys()) {
+                if (!that.anchorPointsForNextFrame.has(anchorPoint)) {
+                  const anchorPointLabel = that.anchorPointLabels.get(anchorPoint);
+                  that.anchorPointLabelCollection.remove(anchorPointLabel);
+                  that.anchorPointLabels.delete(anchorPoint);
+                }
+              }
+            });
+          }
+
+          /**
+           * Set whether the labels that show the standard deviation at the
+           * anchor points are currently visible.
+           *
+           * @param {boolean} anchorPointLabelsVisible
+           */
+          setAnchorPointLabelsVisible(anchorPointLabelsVisible) {
+            if (this.anchorPointLabelsVisible === anchorPointLabelsVisible) {
+              return;
+            }
+            this.anchorPointLabelsVisible = anchorPointLabelsVisible;
+            // Apparently, switching the `show` flag on/off sometimes causes the
+            // background to no longer be shown. This may be a CesiumJS issue,
+            // and has to be investigated. For now, just remove all labels when
+            // the flag was changed, which will cause them to be re-created
+            // in the next frame...
+            const labels = this.anchorPointLabels.values();
+            for (const label of labels) {
+              this.anchorPointLabelCollection.remove(label);
+            }
+            this.anchorPointLabels.clear();
+          }
+
+          /**
+           * Creates the data for the visualization of the given anchor point.
+           *
+           * The result will be an object with the following properties:
+           * - anchorPoint: The given anchorPoint
+           * - position: A Cartesian3 of the position
+           * - orientation: A Quaternion for the ellipsoid orientation
+           * - standardDeviations: A Cartesian3 containing the standard
+           *   deviations, serving as a basis for the ellipsoid radii
+           *
+           * @param {AnchorPointIndirect} anchorPoint The anchor point, as found in
+           * the `NGA_gpm_local` `anchorPointsIndirect` array
+           * @returns The visualization data
+           */
+          createAnchorPointVisualizationData(anchorPoint) {
+            const position = anchorPoint.position;
+
+            // Compute the eigen decomposition of the covariance matrix
+            const covarianceMatrix = anchorPoint.covarianceMatrix;
+            const eigenDecomposition = {
+              unitary: new Cesium.Matrix3(),
+              diagonal: new Cesium.Matrix3(),
+            };
+            Cesium.Matrix3.computeEigenDecomposition(
+              covarianceMatrix,
+              eigenDecomposition,
+            );
+
+            // The eigenvalues are the elements on the diagonal of the diagonal matrix
+            const eigenValue0 = eigenDecomposition.diagonal[0];
+            const eigenValue1 = eigenDecomposition.diagonal[4];
+            const eigenValue2 = eigenDecomposition.diagonal[8];
+
+            // The eigenvectors are the columns of the unitary matrix. The orientation
+            // is computed directly from this matrix.
+            const orientation = Cesium.Quaternion.fromRotationMatrix(
+              eigenDecomposition.unitary,
+              new Cesium.Quaternion(),
+            );
+
+            // The eigenvalues contain the variance. The square root of that
+            // is the standard deviation in meters, and used for the radii
+            // of the anchor point ellipsoid (multipled by the
+            // anchorPointEllipsoidScaling)
+            const standardDeviations = new Cesium.Cartesian3(
+              Math.sqrt(eigenValue0),
+              Math.sqrt(eigenValue1),
+              Math.sqrt(eigenValue2),
+            );
+
+            return {
+              anchorPoint: anchorPoint,
+              position: position,
+              orientation: orientation,
+              standardDeviations: standardDeviations,
+            };
+          }
+
+          /**
+           * Create a label showing the standard deviations from the given
+           * visualization data, at the position of the anchor point.
+           *
+           * @param {object} anchorPointVisualizationData The anchor point
+           * visualization data (see createAnchorPointVisualizationData)
+           * @returns The label
+           */
+          createAnchorPointLabel(anchorPointVisualizationData) {
+            const standardDeviations = anchorPointVisualizationData.standardDeviations;
+            const x = standardDeviations.x;
+            const y = standardDeviations.y;
+            const z = standardDeviations.z;
+            const text = `${x.toFixed(3)}m, ${y.toFixed(3)}m, ${z.toFixed(3)}m`;
+
+            const labelPosition = anchorPointVisualizationData.position;
+            const anchorPointLabel = this.anchorPointLabelCollection.add({
+              position: labelPosition,
+              show: this.anchorPointLabelsVisible,
+              text: text,
+              font: "12px sans-serif",
+              showBackground: true,
+              disableDepthTestDistance: 1e15,
+              horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+              verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+              pixelOffset: new Cesium.Cartesian2(0.0, 5.0),
+              pixelOffsetScaleByDistance: new Cesium.NearFarScalar(50, 0.0, 2000, -2.0),
+            });
+            return anchorPointLabel;
+          }
+
+          /**
+           * Creates the CesiumJS Entity for the given anchor point
+           *
+           * @param {object} anchorPointVisualizationData The anchor point
+           * visualization data (see createAnchorPointVisualizationData)
+           * @returns The entity
+           * @private
+           */
+          createAnchorPointEntity(anchorPointVisualizationData) {
+            const position = anchorPointVisualizationData.position;
+            const orientation = anchorPointVisualizationData.orientation;
+            const standardDeviations = anchorPointVisualizationData.standardDeviations;
+
+            const radii = new Cesium.Cartesian3();
+            const radiiProperty = new Cesium.CallbackProperty(function () {
+              const baseRadius = app.anchorPointEllipsoidScaling;
+              Cesium.Cartesian3.multiplyByScalar(standardDeviations, baseRadius, radii);
+              return radii;
+            }, false);
+
+            const anchorPointEntity = viewer.entities.add({
+              position: position,
+              orientation: orientation,
+              ellipsoid: {
+                radii: radiiProperty,
+                material: Cesium.Color.BLUE.withAlpha(0.5),
+                outline: true,
+                outlineColor: Cesium.Color.BLACK,
+              },
+            });
+            return anchorPointEntity;
+          }
+
+          /**
+           * Obtain the content from the given tile, and the `NGA_gpm_local` extension
+           * object from that content, and return the `anchorPointsIndirect`, or
+           * `undefined` if any element is `undefined`.
+           *
+           * @param {Tile} tile The tile
+           * @returns The anchor points, or undefined
+           */
+          obtainAnchorPoints(tile) {
+            const content = tile?.content;
+            const modelContent =
+              content instanceof Cesium.Model3DTileContent ? content : undefined;
+            if (!modelContent) {
+              return undefined;
+            }
+
+            const extensionObject = modelContent.getExtension("NGA_gpm_local");
+            if (!extensionObject) {
+              return undefined;
+            }
+            return extensionObject.anchorPointsIndirect;
+          }
+
+          /**
+           * Will be called via the "App" currentTilesetChangedListener, whenever
+           * the selected tileset changes.
+           *
+           * @param {Cesium3DTileset|undefined} oldCurrentTileset The old tileset
+           * @param {Cesium3DTileset|undefined} newCurrentTileset The new tileset
+           */
+          updateForCurrentTilesetChanged(oldCurrentTileset, newCurrentTileset) {
+            if (oldCurrentTileset !== undefined) {
+              oldCurrentTileset.tileVisible.removeEventListener(this.tileVisibleListener);
+            }
+            if (newCurrentTileset !== undefined) {
+              newCurrentTileset.tileVisible.addEventListener(this.tileVisibleListener);
+            }
+          }
+        }
+
+        const anchorPointVisualizer = new AnchorPointVisualizer();
+        app.addCurrentTilesetChangedListener(
+          function (oldCurrentTileset, newCurrentTileset) {
+            anchorPointVisualizer.updateForCurrentTilesetChanged(
+              oldCurrentTileset,
+              newCurrentTileset,
+            );
+          },
+        );
+
+        //============================================================================
+        // ViewModel for Sandcastle UI
+
+        const interactionOptions = [
+          {
+            text: "View",
+            onselect: function () {
+              texturePickingHandler.setEnabled(false);
+            },
+          },
+          {
+            text: "Pick",
+            onselect: function () {
+              texturePickingHandler.setEnabled(true);
+            },
+          },
+        ];
+
+        const shaderOptions = PropertyTextureShaders.createShaderOptions();
+
+        const viewModel = {
+          textureThreshold: 3.0,
+          anchorPointEllipsoidScaling: app.anchorPointEllipsoidScaling,
+          anchorPointLabelsVisible: app.anchorPointLabelsVisible,
+          dataSetNames: dataSetOptions.map((e) => e.name),
+          dataSetName: "Port Canaveral",
+          zoomToCurrentTileset: function () {
+            app.zoomToCurrentTileset();
+          },
+          interactionModes: interactionOptions.map((e) => e.text),
+          interactionMode: "Pick",
+          shaderModes: shaderOptions.map((e) => e.text),
+          shaderMode: "Default Shading",
+        };
+
+        // enable texture picking mode by default
+        texturePickingHandler.setEnabled(true);
+
+        async function updateModelFromView() {
+          app.anchorPointEllipsoidScaling = Number(viewModel.anchorPointEllipsoidScaling);
+          const anchorPointLabelsVisible = Boolean(viewModel.anchorPointLabelsVisible);
+          anchorPointVisualizer.setAnchorPointLabelsVisible(anchorPointLabelsVisible);
+          app.textureThreshold = Number(viewModel.textureThreshold);
+          await app.selectCurrentDataSet(viewModel.dataSetName);
+          for (const interactionOption of interactionOptions) {
+            if (interactionOption.text === viewModel.interactionMode) {
+              interactionOption.onselect();
+            }
+          }
+          for (const shaderOption of shaderOptions) {
+            if (shaderOption.text === viewModel.shaderMode) {
+              shaderOption.onselect();
+            }
+          }
+        }
+
+        Cesium.knockout.track(viewModel);
+        const toolbar = document.getElementById("toolbar");
+        Cesium.knockout.applyBindings(viewModel, toolbar);
+        for (const name in viewModel) {
+          if (viewModel.hasOwnProperty(name)) {
+            Cesium.knockout.getObservable(viewModel, name).subscribe(updateModelFromView);
+          }
+        }
+
+        await app.selectCurrentDataSet(dataSetOptions[0].name);
+
+        //Sandcastle_End
+      };
+      if (typeof Cesium !== "undefined") {
+        window.startupCalled = true;
+        window.startup(Cesium).catch((error) => {
+          "use strict";
+          console.error(error);
+        });
+        Sandcastle.finishedLoading();
+      }
+    </script>
+  </body>
+</html>
diff --git a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.jpg b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5b2daea52ce03c25b298593a0d15c500b66cbe60
GIT binary patch
literal 8429
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

literal 0
HcmV?d00001


From b9335ff8c25720200293ce8afcf254d43ab75e52 Mon Sep 17 00:00:00 2001
From: Marco Hutter <javagl@javagl.de>
Date: Wed, 16 Oct 2024 16:09:18 +0200
Subject: [PATCH 3/7] Minor typo fixes

---
 Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html
index 0a5c679375af..9c79f18dcdb0 100644
--- a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
+++ b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
@@ -624,7 +624,7 @@ <h4>Cesium GPM Visualization</h4>
            * create an option to select default shading, a 1D shader,
            * or a 2D shader
            *
-           * @param {string} title The title to be displayed in the combox box
+           * @param {string} title The title to be displayed in the combo box
            * @param {string|undefined} propertyName0 The property name 0
            * @param {number} sourceMin0 The minimum source value 0
            * @param {number} sourceMax0 The maximum source value 0
@@ -677,8 +677,8 @@ <h4>Cesium GPM Visualization</h4>
            * It will allow selecting a "threshold shader" for the specified
            * properties.
            *
-           * @param {string} title The title to be displayed in the combox box
-           * @param {string} title The title to be displayed in the combox box
+           * @param {string} title The title to be displayed in the combo box
+           * @param {string} title The title to be displayed in the combo box
            * @param {string|undefined} propertyName0 The property name 0
            * @param {number} sourceMin0 The minimum source value 0
            * @param {number} sourceMax0 The maximum source value 0

From d67aa3113e251fd17ac19a3b9ba600adbf37dce7 Mon Sep 17 00:00:00 2001
From: Marco Hutter <javagl@javagl.de>
Date: Thu, 21 Nov 2024 20:50:35 +0100
Subject: [PATCH 4/7] Remove outdated sandcastle from development section

---
 .../development/NGA GPM Visualization.html    | 1378 -----------------
 .../development/NGA GPM Visualization.jpg     |  Bin 8429 -> 0 bytes
 2 files changed, 1378 deletions(-)
 delete mode 100644 Apps/Sandcastle/gallery/development/NGA GPM Visualization.html
 delete mode 100644 Apps/Sandcastle/gallery/development/NGA GPM Visualization.jpg

diff --git a/Apps/Sandcastle/gallery/development/NGA GPM Visualization.html b/Apps/Sandcastle/gallery/development/NGA GPM Visualization.html
deleted file mode 100644
index 86f84132ba5c..000000000000
--- a/Apps/Sandcastle/gallery/development/NGA GPM Visualization.html	
+++ /dev/null
@@ -1,1378 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-    <meta
-      name="viewport"
-      content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
-    />
-    <meta
-      name="description"
-      content="An example for the visualization of NGA_gpm_local extension data"
-    />
-    <meta name="cesium-sandcastle-labels" content="Development" />
-    <title>Cesium Demo</title>
-    <script type="text/javascript" src="../Sandcastle-header.js"></script>
-    <script
-      type="text/javascript"
-      src="../../../Build/CesiumUnminified/Cesium.js"
-      nomodule
-    ></script>
-    <script type="module" src="../load-cesium-es6.js"></script>
-  </head>
-
-  <body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
-    <style>
-      @import url(../templates/bucket.css);
-
-      #toolbar {
-        background: rgba(42, 42, 42, 0.8);
-        padding: 4px;
-        border-radius: 4px;
-      }
-
-      #toolbar input {
-        vertical-align: middle;
-        padding-top: 2px;
-        padding-bottom: 2px;
-      }
-    </style>
-    <div id="cesiumContainer" class="fullSize"></div>
-    <div id="loadingOverlay">
-      <h1>Loading...</h1>
-    </div>
-    <div id="toolbar">
-      <table>
-        <tbody>
-          <tr>
-            <td colspan="3">
-              <h4>Cesium GPM Visualization</h4>
-            </td>
-          </tr>
-          <tr>
-            <td>Data set</td>
-            <td>
-              <select data-bind="options: dataSetNames, value: dataSetName"></select>
-            </td>
-            <td style="text-align: right">
-              <button type="button" data-bind="click: zoomToCurrentTileset">Zoom</button>
-            </td>
-          </tr>
-          <tr>
-            <td>Anchor point ellipsoid</td>
-            <td colspan="2">
-              <input
-                type="range"
-                min="1.0"
-                max="500"
-                step="1"
-                data-bind="value: anchorPointEllipsoidScaling, valueUpdate: 'input'"
-              />
-              <input
-                type="text"
-                size="5"
-                data-bind="value: anchorPointEllipsoidScaling"
-              />
-              <label
-                ><input
-                  type="checkbox"
-                  data-bind="checked: anchorPointLabelsVisible"
-                />Labels</label
-              >
-            </td>
-          </tr>
-          <tr>
-            <td>Shader mode</td>
-            <td colspan="2">
-              <select data-bind="options: shaderModes, value: shaderMode"></select>
-            </td>
-          </tr>
-          <tr id="texture-threshold-control" class="hidden">
-            <td>Texture threshold (m)</td>
-            <td>
-              <input
-                type="range"
-                min="0.0"
-                max="16.0"
-                step="0.01"
-                data-bind="value: textureThreshold, valueUpdate: 'input'"
-              />
-              <input type="text" size="5" data-bind="value: textureThreshold" />
-            </td>
-          </tr>
-        </tbody>
-      </table>
-    </div>
-    <script id="cesium_sandcastle_script">
-      window.startup = async function (Cesium) {
-        "use strict";
-        //Sandcastle_Begin
-
-        // Basic setup
-        const viewer = new Cesium.Viewer("cesiumContainer", {
-          //globe: false,
-          //skyBox: false,
-          timeline: false,
-          animation: false,
-          depthPlaneEllipsoidOffset: 10000,
-        });
-
-        const maxarCredit = new Cesium.Credit(
-          "<span>Provided by Maxar for GPM v1.2 evaluation purposes</span>",
-          true,
-        );
-        viewer.creditDisplay.addStaticCredit(maxarCredit);
-
-        // The options that will be passed to all Cesium3DTilesed.from ... functions
-        const defaultTilesetOptions = {
-          //debugShowBoundingVolume: true,
-          maximumScreenSpaceError: 4,
-          cacheBytes: 536870912 * 4,
-        };
-
-        // Whether the data should be loaded from localhost instead of ion
-        const useLocalServer = true;
-        const baseUrl = "http://localhost:8003/";
-
-        if (!useLocalServer) {
-          // Access token that grants access to lajes, port canaveral, cwt, and bing maps aerial:
-          Cesium.Ion.defaultAccessToken =
-            "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI0MmExYzE1NS01ZGI3LTQyNjQtYWNkYi1mMTE1MGJmY2YzODgiLCJpZCI6NDQsImlhdCI6MTcxODM3NDM5MX0.TsMmPMPVIJvgu93jTFsCKj43PLdKfpiZi_gMONecJ3I";
-        }
-
-        // The set of data sets that are available in the UI
-        const dataSetOptions = [
-          {
-            name: "Port Canaveral",
-            url: `${baseUrl}port_canaveral/tileset.json`,
-            assetId: 2622944,
-            initialCameraConfiguration: {
-              destination: new Cesium.Cartesian3(
-                918010.2634368961,
-                -5538948.372542206,
-                3016855.1270222967,
-              ),
-              orientation: new Cesium.HeadingPitchRoll(
-                4.316957618964909,
-                -0.36573164980955686,
-                6.283174173076164,
-              ),
-            },
-          },
-          {
-            name: "Lajes",
-            url: `${baseUrl}lajes/tileset.json`,
-            assetId: 2622949,
-            initialCameraConfiguration: {
-              destination: new Cesium.Cartesian3(
-                4436474.736810458,
-                -2279634.446362909,
-                3962861.396769178,
-              ),
-              orientation: new Cesium.HeadingPitchRoll(
-                5.214554743456651,
-                -0.5265190154471187,
-                0.000008735845947960286,
-              ),
-            },
-          },
-        ];
-        /**
-         * Create a tileset from the given data set option
-         *
-         * @param {object} dataSetOption The data set option
-         * @returns A promise to wait for
-         */
-        async function createTileset(dataSetOption) {
-          if (useLocalServer) {
-            const url = dataSetOption.url;
-            return viewer.scene.primitives.add(
-              await Cesium.Cesium3DTileset.fromUrl(url, defaultTilesetOptions),
-            );
-          }
-          const assetId = dataSetOption.assetId;
-          return viewer.scene.primitives.add(
-            await Cesium.Cesium3DTileset.fromIonAssetId(assetId, defaultTilesetOptions),
-          );
-        }
-
-        //============================================================================
-        // Application state
-
-        class App {
-          constructor() {
-            // The name of the current data set, as of the
-            // dataSetOptions[i].name
-            this._currentDataSetName = undefined;
-
-            // The current tileset
-            this._currentTileset = undefined;
-
-            // The current custom shader, or undefined
-            this._currentCustomShader = undefined;
-
-            // The current value of the `u_textureThreshold` uniform that indicates
-            // whether fragments should be highlighted in the `currentThresholdShader`.
-            this._textureThreshold = 16.0;
-
-            // The scaling factor for the anchor point ellipsoids
-            this.anchorPointEllipsoidScaling = 100.0;
-
-            // A set of functions that will be called whenever
-            // the `currentTileset` changed, and receive the
-            // oldCurrentTileset and newCurrentTileset
-            this._currentTilesetChangedListeners = [];
-          }
-
-          async selectCurrentDataSet(dataSetName) {
-            if (this._currentDataSetName === dataSetName) {
-              return;
-            }
-            for (const dataSetOption of dataSetOptions) {
-              if (dataSetOption.name === dataSetName) {
-                this._currentDataSetName = dataSetName;
-                await this.createCurrentTileset(dataSetOption);
-              }
-            }
-          }
-
-          get currentTileset() {
-            return this._currentTileset;
-          }
-          set currentTileset(value) {
-            const oldCurrentTileset = this._currentTileset;
-            this._currentTileset = value;
-            this.updateCustomShaderInTileset();
-            this.notifyCurrentTilesetChanged(oldCurrentTileset, this.currentTileset);
-          }
-
-          /**
-           * Add the given function to be called when the current tileset
-           * changed, receiving the "old" and the "new" current tileset.
-           *
-           * @param {object} listener The listener
-           */
-          addCurrentTilesetChangedListener(listener) {
-            this._currentTilesetChangedListeners.push(listener);
-          }
-
-          /**
-           * Notify all registered listeners that the current tileset changed
-           *
-           * @param {Cesium3DTileset} oldCurrentTileset
-           * @param {Cesium3DTileset} newCurrentTileset
-           *
-           * @private
-           */
-          notifyCurrentTilesetChanged(oldCurrentTileset, newCurrentTileset) {
-            for (const listener of this._currentTilesetChangedListeners) {
-              listener(oldCurrentTileset, newCurrentTileset);
-            }
-          }
-
-          get currentCustomShader() {
-            return this._currentCustomShader;
-          }
-          set currentCustomShader(value) {
-            this._currentCustomShader = value;
-            this.updateTextureThresholdInShader();
-            this.updateCustomShaderInTileset();
-          }
-
-          /**
-           * If the currentTileset is defined, then assign the currentCustomShader
-           * to it.
-           *
-           * @private
-           */
-          updateCustomShaderInTileset() {
-            if (this.currentTileset === undefined) {
-              return;
-            }
-            this.currentTileset.customShader = this.currentCustomShader;
-          }
-
-          get textureThreshold() {
-            return this._textureThreshold;
-          }
-
-          set textureThreshold(value) {
-            this._textureThreshold = value;
-            this.updateTextureThresholdInShader();
-          }
-
-          /**
-           * If the currentCustomShader is defined and has a `u_textureThreshold`
-           * uniform, then set its value to the current `textureThreshold`
-           *
-           * @private
-           */
-          updateTextureThresholdInShader() {
-            if (this.currentCustomShader === undefined) {
-              return;
-            }
-            const hasTextureThreshold = Object.keys(
-              this.currentCustomShader.uniforms,
-            ).includes("u_textureThreshold");
-            if (!hasTextureThreshold) {
-              return;
-            }
-            this.currentCustomShader.setUniform(
-              "u_textureThreshold",
-              this.textureThreshold,
-            );
-          }
-
-          /**
-           * Load the tileset that is described in the given data
-           * set option, and set it as the current tileset.
-           *
-           * @param {string} url The tileset URL
-           * @returns A promise to wait for...
-           */
-          async createCurrentTileset(dataSetOption) {
-            if (Cesium.defined(this.currentTileset)) {
-              viewer.scene.primitives.remove(this.currentTileset);
-              this.currentTileset = undefined;
-            }
-
-            // Create the tileset
-            this.currentTileset = await createTileset(dataSetOption);
-            if (Cesium.defined(dataSetOption.initialCameraConfiguration)) {
-              viewer.scene.camera.setView(dataSetOption.initialCameraConfiguration);
-            } else {
-              this.zoomToCurrentTileset();
-            }
-          }
-
-          /**
-           * Zoom to the current tileset, with a small, unspecified offset...
-           */
-          zoomToCurrentTileset() {
-            if (this.currentTileset === undefined) {
-              return;
-            }
-            const offset = new Cesium.HeadingPitchRange(
-              Cesium.Math.toRadians(0.0),
-              Cesium.Math.toRadians(-22.5),
-              10000.0,
-            );
-            viewer.zoomTo(this.currentTileset, offset);
-          }
-        }
-
-        const app = new App();
-
-        //============================================================================
-
-        /**
-         * Pick the local uncertainty information from the texture at the given
-         * window position.
-         *
-         * This makes assumptions about the structure of the metadata that is
-         * contained in the underlying data sets.
-         *
-         * It assumes that the data contains two PPE (Per-Point-Error) textures
-         * that are internally converted into structural metadata property
-         * texture properties.
-         *
-         * The first PPE texture uses the SIGZ trait (sigma/standard deviation in
-         * z-direction, in meters). This will be the `y`-component of the result.
-         *
-         * The second PPE texture uses the SIGR trait (sigma/standard deviation in
-         * radial direction in meters). This will be the x-component of the result.
-         *
-         * (Both values are in the range of [0...16], with 16 being the noData value)
-         *
-         * @param {Cartesian2} windowPosition The position in the window
-         * @returns {Cartesian2} The local uncertainty, with `x` being
-         * the radial uncertainty and `y` being the vertical uncertainty
-         */
-        function pickUncertaintyFromTexture(windowPosition) {
-          const schemaId = undefined;
-          const classNameX = "ppeTexture_1";
-          const propertyNameX = "SIGR";
-          const classNameY = "ppeTexture_0";
-          const propertyNameY = "SIGZ";
-          const result = new Cesium.Cartesian2();
-
-          const metadataSchema = viewer.scene.pickMetadataSchema(windowPosition);
-          console.log("metadataSchema", metadataSchema);
-
-          let metadataValueX = viewer.scene.pickMetadata(
-            windowPosition,
-            schemaId,
-            classNameX,
-            propertyNameX,
-          );
-          let metadataValueY = viewer.scene.pickMetadata(
-            windowPosition,
-            schemaId,
-            classNameY,
-            propertyNameY,
-          );
-
-          console.log("metadataValueX ", metadataValueX);
-          console.log("metadataValueY ", metadataValueY);
-          if (!metadataValueX) {
-            metadataValueX = 0;
-          }
-          if (!metadataValueY) {
-            metadataValueY = 0;
-          }
-          result.x = metadataValueX;
-          result.y = metadataValueY;
-          return result;
-        }
-
-        //============================================================================
-        // Property texture shaders
-
-        class PropertyTextureShaders {
-          /**
-           * Create a custom (fragment) shader for the specified property.
-           *
-           * It accesses the metadata value with the given property name and
-           * normalizes it to a value in [0,1] based on the given source range.
-           * If the resulting value is less than 1.0, this value is used
-           * as the brightness for the fragment.
-           *
-           * @param {string} propertyName The property name
-           * @param {number} sourceMin The minimum source value
-           * @param {number} sourceMax The maximum source value
-           * @returns The `CustomShader`
-           * @private
-           */
-          static createShader1D(propertyName, sourceMin, sourceMax) {
-            const shader = new Cesium.CustomShader({
-              fragmentShaderText: `
-        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
-        {
-          float value = float(fsInput.metadata.${propertyName});
-          float range = float(${sourceMax}) - float(${sourceMin});
-          float brightness = (value - float(${sourceMin})) / range;
-
-          if (value < float(${sourceMax})) {
-            material.diffuse = vec3(brightness);
-          }
-        }
-      `,
-            });
-            return shader;
-          }
-
-          /**
-           * Create a custom (fragment) shader for the specified properties.
-           *
-           * It accesses the metadata values with the given property names and
-           * normalizes them to a value in [0,1] based on the given source ranges.
-           * If the resulting values are both less than 1.0, the values are used
-           * as the red- and green components of the fragment.
-           *
-           * @param {string} propertyName0 The property name 0
-           * @param {number} sourceMin0 The minimum source value 0
-           * @param {number} sourceMax0 The maximum source value 0
-           * @param {string} propertyName1 The property name 1
-           * @param {number} sourceMin1 The minimum source value 1
-           * @param {number} sourceMax1 The maximum source value 1
-           * @returns The `CustomShader`
-           * @private
-           */
-          static createShader2D(
-            propertyName0,
-            sourceMin0,
-            sourceMax0,
-            propertyName1,
-            sourceMin1,
-            sourceMax1,
-          ) {
-            const shader = new Cesium.CustomShader({
-              fragmentShaderText: `
-        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
-        {
-          float value0 = float(fsInput.metadata.${propertyName0});
-          float range0 = float(${sourceMax0}) - float(${sourceMin0});
-          float brightness0 = (value0 - float(${sourceMin0})) / range0;
-
-          float value1 = float(fsInput.metadata.${propertyName1});
-          float range1 = float(${sourceMax1}) - float(${sourceMin1});
-          float brightness1 = (value1 - float(${sourceMin1})) / range1;
-
-          if (value0 < float(${sourceMax0}) && value1 < float(${sourceMax1})) {
-            material.diffuse = vec3(brightness0, brightness1, 0.0);
-          }
-        }
-      `,
-            });
-            return shader;
-          }
-
-          /**
-           * Create a custom (fragment) shader for a threshold visualization of
-           * the specified property.
-           *
-           * It defines a `u_textureThreshold` FLOAT uniform for the threshold
-           * value. It accesses the metadata value with the given property name.
-           * If the resulting value is less than 1.0 but larger than
-           * the threshold, then the fragment will be shown in a highlighting
-           * color. Otherwise, the fragment will be shown with its original
-           * color with lower saturation and lightness.
-           *
-           * @param {string} propertyName The property name
-           * @param {number} sourceMin The minimum source value
-           * @param {number} sourceMax The maximum source value
-           * @returns The `CustomShader`
-           * @private
-           */
-          static createThresholdShader1D(propertyName, sourceMin, sourceMax) {
-            const shader = new Cesium.CustomShader({
-              uniforms: {
-                // A threshold value for the texture: When this
-                // is exceeded, then the fragment will be highlighted
-                u_textureThreshold: {
-                  type: Cesium.UniformType.FLOAT,
-                  value: 16.0,
-                },
-              },
-              fragmentShaderText: `
-        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
-        {
-          float value = float(fsInput.metadata.${propertyName});
-          float range = float(${sourceMax}) - float(${sourceMin});
-          float brightness = (value - float(${sourceMin})) / range;
-
-          if (value < float(${sourceMax}) && value > u_textureThreshold) {
-            material.diffuse = vec3(1.0, 1.0, 0.0);
-          } else {
-            vec3 diffuseHsl = czm_RGBToHSL(material.diffuse);
-            diffuseHsl.y *= 0.25;
-            diffuseHsl.z *= 0.25;
-            material.diffuse = czm_HSLToRGB(diffuseHsl);
-          }
-        }
-      `,
-            });
-            return shader;
-          }
-
-          /**
-           * Create a custom (fragment) shader for a threshold visualization of
-           * the specified property.
-           *
-           * It defines a `u_textureThreshold` FLOAT uniform for the threshold
-           * value. It accesses the metadata values with the given property names.
-           * If the resulting value is less than 1.0 but larger than
-           * the threshold, then the fragment will be shown in a highlighting
-           * color. Otherwise, the fragment will be shown with its original
-           * color with lower saturation and lightness.
-           *
-           * @param {string} propertyName0 The property name 0
-           * @param {number} sourceMin0 The minimum source value 0
-           * @param {number} sourceMax0 The maximum source value 0
-           * @param {string} propertyName1 The property name 1
-           * @param {number} sourceMin1 The minimum source value 1
-           * @param {number} sourceMax1 The maximum source value 1
-           * @returns The `CustomShader`
-           * @private
-           */
-          static createThresholdShader2D(
-            propertyName0,
-            sourceMin0,
-            sourceMax0,
-            propertyName1,
-            sourceMin1,
-            sourceMax1,
-          ) {
-            const shader = new Cesium.CustomShader({
-              uniforms: {
-                // A threshold value for the texture: When this
-                // is exceeded, then the fragment will be highlighted
-                u_textureThreshold: {
-                  type: Cesium.UniformType.FLOAT,
-                  value: 16.0,
-                },
-              },
-              fragmentShaderText: `
-        void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material)
-        {
-          float value0 = float(fsInput.metadata.${propertyName0});
-          float range0 = float(${sourceMax0}) - float(${sourceMin0});
-          float brightness0 = (value0 - float(${sourceMin0})) / range0;
-
-          float value1 = float(fsInput.metadata.${propertyName1});
-          float range1 = float(${sourceMax1}) - float(${sourceMin1});
-          float brightness1 = (value1 - float(${sourceMin1})) / range1;
- 
-          vec3 diffuseHsl = czm_RGBToHSL(material.diffuse);
-          diffuseHsl.y *= 0.25;
-          diffuseHsl.z *= 0.25;
-          vec3 diffuseResult = czm_HSLToRGB(diffuseHsl);
-
-          if (value0 < float(${sourceMax0}) && value0 > u_textureThreshold) {
-            diffuseResult.x = 1.0;
-            diffuseResult.y = 1.0;
-          }
-          if (value1 < float(${sourceMax1}) && value1 > u_textureThreshold) {
-            diffuseResult.x = 1.0;
-            diffuseResult.z = 1.0;
-          }
-          material.diffuse = diffuseResult;
-        }
-      `,
-            });
-            return shader;
-          }
-
-          /**
-           * Creates a object that can be used as one entry in the options
-           * of a Sandcastle toolbar menu.
-           *
-           * Depending on which property names are defined, this will
-           * create an option to select default shading, a 1D shader,
-           * or a 2D shader
-           *
-           * @param {string} title The title to be displayed in the combox box
-           * @param {string|undefined} propertyName0 The property name 0
-           * @param {number} sourceMin0 The minimum source value 0
-           * @param {number} sourceMax0 The maximum source value 0
-           * @param {string|undefined} propertyName1 The property name 1
-           * @param {number} sourceMin1 The minimum source value 1
-           * @param {number} sourceMax1 The maximum source value 1
-           * @returns The shader option
-           * @private
-           */
-          static createShaderOption(
-            title,
-            propertyName0,
-            sourceMin0,
-            sourceMax0,
-            propertyName1,
-            sourceMin1,
-            sourceMax1,
-          ) {
-            return {
-              text: title,
-              onselect: function () {
-                if (Cesium.defined(propertyName0) && Cesium.defined(propertyName1)) {
-                  app.currentCustomShader = PropertyTextureShaders.createShader2D(
-                    propertyName0,
-                    sourceMin0,
-                    sourceMax0,
-                    propertyName1,
-                    sourceMin1,
-                    sourceMax1,
-                  );
-                } else if (Cesium.defined(propertyName0)) {
-                  app.currentCustomShader = PropertyTextureShaders.createShader1D(
-                    propertyName0,
-                    sourceMin0,
-                    sourceMax0,
-                  );
-                } else {
-                  app.currentCustomShader = undefined;
-                }
-
-                document.getElementById("texture-threshold-control").className = "hidden";
-              },
-            };
-          }
-
-          /**
-           * Creates a object that can be used as one entry in the options
-           * of a Sandcastle toolbar menu.
-           *
-           * It will allow selecting a "threshold shader" for the specified
-           * properties.
-           *
-           * @param {string} title The title to be displayed in the combox box
-           * @param {string} title The title to be displayed in the combox box
-           * @param {string|undefined} propertyName0 The property name 0
-           * @param {number} sourceMin0 The minimum source value 0
-           * @param {number} sourceMax0 The maximum source value 0
-           * @param {string|undefined} propertyName1 The property name 1
-           * @param {number} sourceMin1 The minimum source value 1
-           * @param {number} sourceMax1 The maximum source value 1
-           * @returns The shader option
-           * @private
-           */
-          static createThresholdShaderOption(
-            title,
-            propertyName0,
-            sourceMin0,
-            sourceMax0,
-            propertyName1,
-            sourceMin1,
-            sourceMax1,
-          ) {
-            return {
-              text: title,
-              onselect: function () {
-                if (Cesium.defined(propertyName0) && Cesium.defined(propertyName1)) {
-                  app.currentCustomShader =
-                    PropertyTextureShaders.createThresholdShader2D(
-                      propertyName0,
-                      sourceMin0,
-                      sourceMax0,
-                      propertyName1,
-                      sourceMin1,
-                      sourceMax1,
-                    );
-                } else if (Cesium.defined(propertyName0)) {
-                  app.currentCustomShader =
-                    PropertyTextureShaders.createThresholdShader1D(
-                      propertyName0,
-                      sourceMin0,
-                      sourceMax0,
-                    );
-                } else {
-                  app.currentCustomShader = undefined;
-                }
-
-                document.getElementById("texture-threshold-control").className = "";
-              },
-            };
-          }
-
-          /**
-           * Create the shader options for the Sandcastle toolbar menu
-           */
-          static createShaderOptions() {
-            const shaderOptions = [
-              PropertyTextureShaders.createShaderOption(
-                "Default Shading",
-                undefined,
-                0.0,
-                16.0,
-                undefined,
-                0.0,
-                16.0,
-              ),
-              PropertyTextureShaders.createShaderOption(
-                "Local Vertical Uncertainty",
-                "SIGZ",
-                0.0,
-                16.0,
-                undefined,
-                0.0,
-                16.0,
-              ),
-              PropertyTextureShaders.createShaderOption(
-                "Local Radial Uncertainty",
-                "SIGR",
-                0.0,
-                16.0,
-                undefined,
-                0.0,
-                16.0,
-              ),
-              PropertyTextureShaders.createShaderOption(
-                "Local Combined Uncertainty",
-                "SIGZ",
-                0.0,
-                16.0,
-                "SIGR",
-                0.0,
-                16.0,
-              ),
-              PropertyTextureShaders.createThresholdShaderOption(
-                "Local Vertical Threshold",
-                "SIGZ",
-                0.0,
-                16.0,
-                undefined,
-                0.0,
-                16.0,
-              ),
-              PropertyTextureShaders.createThresholdShaderOption(
-                "Local Radial Threshold",
-                "SIGR",
-                0.0,
-                16.0,
-                undefined,
-                0.0,
-                16.0,
-              ),
-              PropertyTextureShaders.createThresholdShaderOption(
-                "Local Combined Threshold",
-                "SIGZ",
-                0.0,
-                16.0,
-                "SIGR",
-                0.0,
-                16.0,
-              ),
-            ];
-            return shaderOptions;
-          }
-        }
-
-        //============================================================================
-        // Texture picking: A label and an ellipsid for the local uncertainty at
-        // the picked position
-
-        class TexturePickingHandler {
-          constructor() {
-            // Whether texture picking is currently enabled
-            this.enabled = false;
-
-            // The current ellipsoid primitive showing the uncertainty radii
-            this.errorEllipsoidPrimitive = undefined;
-
-            const errorLabels = viewer.scene.primitives.add(new Cesium.LabelCollection());
-            // The label showing the uncertainty values
-            this.errorLabel = errorLabels.add({
-              position: Cesium.Cartesian3.fromDegrees(0, 0),
-              show: false,
-              text: "",
-              font: "20px sans-serif",
-              showBackground: true,
-              disableDepthTestDistance: 1e15,
-              horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
-              verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
-              pixelOffset: new Cesium.Cartesian2(0.0, 5.0),
-              pixelOffsetScaleByDistance: new Cesium.NearFarScalar(50, 0.0, 2000, -2.0),
-            });
-
-            // Install the handler that will pick the uncertainty values
-            // from the texture, and update the error ellipsoid and label
-            const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
-            const that = this;
-            handler.setInputAction(function (movement) {
-              if (!that.enabled) {
-                return;
-              }
-              const worldPosition = viewer.scene.pickPosition(movement.position);
-              if (worldPosition === undefined) {
-                that.clear();
-              } else {
-                const uncertainty = pickUncertaintyFromTexture(movement.position);
-                that.update(worldPosition, uncertainty.x, uncertainty.y);
-              }
-            }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
-            handler.setInputAction(function () {
-              if (!that.enabled) {
-                return;
-              }
-              that.clear();
-            }, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
-          }
-
-          /**
-           * Set whether texture uncertainty picking is currently enabled
-           *
-           * @param {boolean} enabled The state
-           */
-          setEnabled(enabled) {
-            this.enabled = enabled;
-            if (!enabled) {
-              this.clear();
-            }
-          }
-
-          /**
-           * Hide the error label, and remove the error ellipsoid
-           */
-          clear() {
-            viewer.scene.primitives.remove(this.errorEllipsoidPrimitive);
-            this.errorEllipsoidPrimitive = undefined;
-            this.errorLabel.show = false;
-          }
-
-          /**
-           * Update the error label and ellipsoid primitive for the
-           * given parameters.
-           *
-           * @param {Cartesian3} worldPosition The position for the label
-           * and ellipsoid
-           * @param {number} sizeX The radial size (uncertainty)
-           * @param {number} sizeY The vertical size (uncertainty)
-           * @private
-           */
-          update(center, sizeX, sizeY) {
-            this.updateErrorLabel(center, sizeX, sizeY);
-            this.updateErrorEllipsoidPrimitive(center, sizeX, sizeY);
-          }
-
-          /**
-           * Update the error label for the given parameters.
-           *
-           * @param {Cartesian3} worldPosition The position for the label
-           * @param {number} sizeX The radial size (uncertainty)
-           * @param {number} sizeY The vertical size (uncertainty)
-           * @private
-           */
-          updateErrorLabel(center, sizeX, sizeY) {
-            const cartographic = Cesium.Cartographic.fromCartesian(center);
-            cartographic.height += sizeY + 1.0;
-            const labelPosition = Cesium.Cartographic.toCartesian(cartographic);
-            this.errorLabel.position = labelPosition;
-            this.errorLabel.show = true;
-            const radialString = sizeX === 16.0 ? "(unknown)" : `${sizeX.toFixed(4)}m`;
-            const verticalString = sizeY === 16.0 ? "(unknown)" : `${sizeY.toFixed(4)}m`;
-            this.errorLabel.text =
-              `Local Radial Uncertainty: ${radialString}\n` +
-              `Local Vertical Uncertainty: ${verticalString}`;
-          }
-
-          /**
-           * Update the error ellipsoid primitive for the given parameters.
-           *
-           * @param {Cartesian3} worldPosition The position for the ellipsoid
-           * @param {number} sizeX The radial size (uncertainty)
-           * @param {number} sizeY The vertical size (uncertainty)
-           * @private
-           */
-          updateErrorEllipsoidPrimitive(center, sizeX, sizeY) {
-            viewer.scene.primitives.remove(this.errorEllipsoidPrimitive);
-            const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);
-            const ellipsoidGeometry = new Cesium.EllipsoidGeometry({
-              radii: new Cesium.Cartesian3(sizeX, sizeX, sizeY),
-              vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
-            });
-            const ellipsoid = new Cesium.GeometryInstance({
-              geometry: ellipsoidGeometry,
-              modelMatrix: modelMatrix,
-              attributes: {
-                color: Cesium.ColorGeometryInstanceAttribute.fromColor(
-                  Cesium.Color.BLUE.withAlpha(0.6),
-                ),
-                depthFailColor: Cesium.ColorGeometryInstanceAttribute.fromColor(
-                  Cesium.Color.BLUE.withAlpha(0.2),
-                ),
-              },
-            });
-            this.errorEllipsoidPrimitive = new Cesium.Primitive({
-              geometryInstances: [ellipsoid],
-              appearance: new Cesium.PerInstanceColorAppearance({
-                closed: true,
-                translucent: true,
-              }),
-              depthFailAppearance: new Cesium.PerInstanceColorAppearance({
-                closed: true,
-                translucent: true,
-              }),
-              asynchronous: false,
-            });
-            viewer.scene.primitives.add(this.errorEllipsoidPrimitive);
-          }
-        }
-
-        const texturePickingHandler = new TexturePickingHandler();
-        app.addCurrentTilesetChangedListener(function () {
-          texturePickingHandler.clear();
-        });
-
-        //============================================================================
-        // Anchor point visualization
-
-        class AnchorPointVisualizer {
-          constructor() {
-            // A mapping from anchor point JSON objects to their entities
-            this.anchorPointEntities = new Map();
-
-            // The labels showing the uncertainty values for the anchor points
-            this.anchorPointLabelCollection = viewer.scene.primitives.add(
-              new Cesium.LabelCollection(),
-            );
-
-            // Whether the labels at the anchor points (containing the
-            // standard deviations) are visible
-            this.anchorPointLabelsVisible = false;
-
-            // A mapping from anchor point JSON objects to their labels
-            this.anchorPointLabels = new Map();
-
-            // The set of anchor point JSON object whose entities and labels
-            // should be added to the anchorPointEntities in the next frame
-            this.anchorPointsForNextFrame = new Set();
-
-            // For each file that is visible, obtain its anchor points
-            // and add them to the set of anchorPointsForNextFrame
-            const that = this;
-            this.tileVisibleListener = function (tile) {
-              const anchorPointsIndirect = that.obtainAnchorPoints(tile);
-              if (Cesium.defined(anchorPointsIndirect)) {
-                for (const anchorPoint of anchorPointsIndirect) {
-                  that.anchorPointsForNextFrame.add(anchorPoint);
-                }
-              }
-            };
-
-            this.initialize();
-          }
-
-          /**
-           * Initialize the anchor point visualization by attaching the
-           * required listeners to the scene and tileset
-           *
-           * @private
-           */
-          initialize() {
-            const that = this;
-
-            // Before rendering, clear the set of anchor points that
-            // should be shown in the next frame. The set will be
-            // filled with the ones that should be rendered, during
-            // the rendering process of the tileset, using the
-            // tileVisibleListener that was attached to the
-            // tileset.
-            viewer.scene.preRender.addEventListener(function () {
-              that.anchorPointsForNextFrame.clear();
-            });
-
-            // Trigger an update to attach the tileVisibleListener
-            // to the current tileset (if it is defined)
-            this.updateForCurrentTilesetChanged(undefined, app.currentTileset);
-
-            // After rendering, update the anchor point visualization
-            // by adding/removing elements from the anchorPointEntities
-            // as necessary
-            viewer.scene.postRender.addEventListener(function () {
-              // For all anchor points that should be visible in the next
-              // frame but are NOT yet visible: Create an entity in the
-              // viewer, and add it to the anchorPointEntities, and
-              // create a label and add it to the anchorPointLabelCollection
-              // and anchorPointLabels
-              for (const anchorPoint of that.anchorPointsForNextFrame) {
-                if (
-                  !that.anchorPointEntities.has(anchorPoint) ||
-                  !that.anchorPointLabels.has(anchorPoint)
-                ) {
-                  const anchorPointVisualizationData =
-                    that.createAnchorPointVisualizationData(anchorPoint);
-                  if (!that.anchorPointEntities.has(anchorPoint)) {
-                    const anchorPointEntity = that.createAnchorPointEntity(
-                      anchorPointVisualizationData,
-                    );
-                    that.anchorPointEntities.set(anchorPoint, anchorPointEntity);
-                  }
-
-                  if (!that.anchorPointLabels.has(anchorPoint)) {
-                    const anchorPointLabel = that.createAnchorPointLabel(
-                      anchorPointVisualizationData,
-                    );
-                    that.anchorPointLabels.set(anchorPoint, anchorPointLabel);
-                  }
-                }
-              }
-
-              // For all anchor points that currently ARE visible, but should
-              // not be visible in the next frame: Remove the entity from the
-              // viewer and the anchorPointEntities, and remove the label
-              // from the anchorPointLabelCollection and the anchorPointLabels
-              for (const anchorPoint of that.anchorPointEntities.keys()) {
-                if (!that.anchorPointsForNextFrame.has(anchorPoint)) {
-                  const anchorPointEntity = that.anchorPointEntities.get(anchorPoint);
-                  viewer.entities.remove(anchorPointEntity);
-                  that.anchorPointEntities.delete(anchorPoint);
-                }
-              }
-              for (const anchorPoint of that.anchorPointLabels.keys()) {
-                if (!that.anchorPointsForNextFrame.has(anchorPoint)) {
-                  const anchorPointLabel = that.anchorPointLabels.get(anchorPoint);
-                  that.anchorPointLabelCollection.remove(anchorPointLabel);
-                  that.anchorPointLabels.delete(anchorPoint);
-                }
-              }
-            });
-          }
-
-          /**
-           * Set whether the labels that show the standard deviation at the
-           * anchor points are currently visible.
-           *
-           * @param {boolean} anchorPointLabelsVisible
-           */
-          setAnchorPointLabelsVisible(anchorPointLabelsVisible) {
-            if (this.anchorPointLabelsVisible === anchorPointLabelsVisible) {
-              return;
-            }
-            this.anchorPointLabelsVisible = anchorPointLabelsVisible;
-            // Apparently, switching the `show` flag on/off sometimes causes the
-            // background to no longer be shown. This may be a CesiumJS issue,
-            // and has to be investigated. For now, just remove all labels when
-            // the flag was changed, which will cause them to be re-created
-            // in the next frame...
-            const labels = this.anchorPointLabels.values();
-            for (const label of labels) {
-              this.anchorPointLabelCollection.remove(label);
-            }
-            this.anchorPointLabels.clear();
-          }
-
-          /**
-           * Creates the data for the visualization of the given anchor point.
-           *
-           * The result will be an object with the following properties:
-           * - anchorPoint: The given anchorPoint
-           * - position: A Cartesian3 of the position
-           * - orientation: A Quaternion for the ellipsoid orientation
-           * - standardDeviations: A Cartesian3 containing the standard
-           *   deviations, serving as a basis for the ellipsoid radii
-           *
-           * @param {AnchorPointIndirect} anchorPoint The anchor point, as found in
-           * the `NGA_gpm_local` `anchorPointsIndirect` array
-           * @returns The visualization data
-           */
-          createAnchorPointVisualizationData(anchorPoint) {
-            const position = anchorPoint.position;
-
-            // Compute the eigen decomposition of the covariance matrix
-            const covarianceMatrix = anchorPoint.covarianceMatrix;
-            const eigenDecomposition = {
-              unitary: new Cesium.Matrix3(),
-              diagonal: new Cesium.Matrix3(),
-            };
-            Cesium.Matrix3.computeEigenDecomposition(
-              covarianceMatrix,
-              eigenDecomposition,
-            );
-
-            // The eigenvalues are the elements on the diagonal of the diagonal matrix
-            const eigenValue0 = eigenDecomposition.diagonal[0];
-            const eigenValue1 = eigenDecomposition.diagonal[4];
-            const eigenValue2 = eigenDecomposition.diagonal[8];
-
-            // The eigenvectors are the columns of the unitary matrix. The orientation
-            // is computed directly from this matrix.
-            const orientation = Cesium.Quaternion.fromRotationMatrix(
-              eigenDecomposition.unitary,
-              new Cesium.Quaternion(),
-            );
-
-            // The eigenvalues contain the variance. The square root of that
-            // is the standard deviation in meters, and used for the radii
-            // of the anchor point ellipsoid (multipled by the
-            // anchorPointEllipsoidScaling)
-            const standardDeviations = new Cesium.Cartesian3(
-              Math.sqrt(eigenValue0),
-              Math.sqrt(eigenValue1),
-              Math.sqrt(eigenValue2),
-            );
-
-            return {
-              anchorPoint: anchorPoint,
-              position: position,
-              orientation: orientation,
-              standardDeviations: standardDeviations,
-            };
-          }
-
-          /**
-           * Create a label showing the standard deviations from the given
-           * visualization data, at the position of the anchor point.
-           *
-           * @param {object} anchorPointVisualizationData The anchor point
-           * visualization data (see createAnchorPointVisualizationData)
-           * @returns The label
-           */
-          createAnchorPointLabel(anchorPointVisualizationData) {
-            const standardDeviations = anchorPointVisualizationData.standardDeviations;
-            const x = standardDeviations.x;
-            const y = standardDeviations.y;
-            const z = standardDeviations.z;
-            const text = `${x.toFixed(3)}m, ${y.toFixed(3)}m, ${z.toFixed(3)}m`;
-
-            const labelPosition = anchorPointVisualizationData.position;
-            const anchorPointLabel = this.anchorPointLabelCollection.add({
-              position: labelPosition,
-              show: this.anchorPointLabelsVisible,
-              text: text,
-              font: "12px sans-serif",
-              showBackground: true,
-              disableDepthTestDistance: 1e15,
-              horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
-              verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
-              pixelOffset: new Cesium.Cartesian2(0.0, 5.0),
-              pixelOffsetScaleByDistance: new Cesium.NearFarScalar(50, 0.0, 2000, -2.0),
-            });
-            return anchorPointLabel;
-          }
-
-          /**
-           * Creates the CesiumJS Entity for the given anchor point
-           *
-           * @param {object} anchorPointVisualizationData The anchor point
-           * visualization data (see createAnchorPointVisualizationData)
-           * @returns The entity
-           * @private
-           */
-          createAnchorPointEntity(anchorPointVisualizationData) {
-            const position = anchorPointVisualizationData.position;
-            const orientation = anchorPointVisualizationData.orientation;
-            const standardDeviations = anchorPointVisualizationData.standardDeviations;
-
-            const radii = new Cesium.Cartesian3();
-            const radiiProperty = new Cesium.CallbackProperty(function () {
-              const baseRadius = app.anchorPointEllipsoidScaling;
-              Cesium.Cartesian3.multiplyByScalar(standardDeviations, baseRadius, radii);
-              return radii;
-            }, false);
-
-            const anchorPointEntity = viewer.entities.add({
-              position: position,
-              orientation: orientation,
-              ellipsoid: {
-                radii: radiiProperty,
-                material: Cesium.Color.BLUE.withAlpha(0.5),
-                outline: true,
-                outlineColor: Cesium.Color.BLACK,
-              },
-            });
-            return anchorPointEntity;
-          }
-
-          /**
-           * Obtain the content from the given tile, and the `NGA_gpm_local` extension
-           * object from that content, and return the `anchorPointsIndirect`, or
-           * `undefined` if any element is `undefined`.
-           *
-           * @param {Tile} tile The tile
-           * @returns The anchor points, or undefined
-           */
-          obtainAnchorPoints(tile) {
-            const content = tile?.content;
-            const modelContent =
-              content instanceof Cesium.Model3DTileContent ? content : undefined;
-            if (!modelContent) {
-              return undefined;
-            }
-
-            const extensionObject = modelContent.getExtension("NGA_gpm_local");
-            if (!extensionObject) {
-              return undefined;
-            }
-            return extensionObject.anchorPointsIndirect;
-          }
-
-          /**
-           * Will be called via the "App" currentTilesetChangedListener, whenever
-           * the selected tileset changes.
-           *
-           * @param {Cesium3DTileset|undefined} oldCurrentTileset The old tileset
-           * @param {Cesium3DTileset|undefined} newCurrentTileset The new tileset
-           */
-          updateForCurrentTilesetChanged(oldCurrentTileset, newCurrentTileset) {
-            if (oldCurrentTileset !== undefined) {
-              oldCurrentTileset.tileVisible.removeEventListener(this.tileVisibleListener);
-            }
-            if (newCurrentTileset !== undefined) {
-              newCurrentTileset.tileVisible.addEventListener(this.tileVisibleListener);
-            }
-          }
-        }
-
-        const anchorPointVisualizer = new AnchorPointVisualizer();
-        app.addCurrentTilesetChangedListener(
-          function (oldCurrentTileset, newCurrentTileset) {
-            anchorPointVisualizer.updateForCurrentTilesetChanged(
-              oldCurrentTileset,
-              newCurrentTileset,
-            );
-          },
-        );
-
-        //============================================================================
-        // ViewModel for Sandcastle UI
-
-        const interactionOptions = [
-          {
-            text: "View",
-            onselect: function () {
-              texturePickingHandler.setEnabled(false);
-            },
-          },
-          {
-            text: "Pick",
-            onselect: function () {
-              texturePickingHandler.setEnabled(true);
-            },
-          },
-        ];
-
-        const shaderOptions = PropertyTextureShaders.createShaderOptions();
-
-        const viewModel = {
-          textureThreshold: 16.0,
-          anchorPointEllipsoidScaling: app.anchorPointEllipsoidScaling,
-          anchorPointLabelsVisible: app.anchorPointLabelsVisible,
-          dataSetNames: dataSetOptions.map((e) => e.name),
-          dataSetName: "Port Canaveral",
-          zoomToCurrentTileset: function () {
-            app.zoomToCurrentTileset();
-          },
-          interactionModes: interactionOptions.map((e) => e.text),
-          interactionMode: "Pick",
-          shaderModes: shaderOptions.map((e) => e.text),
-          shaderMode: "Default Shading",
-        };
-
-        // enable texture picking mode by default
-        texturePickingHandler.setEnabled(true);
-
-        async function updateModelFromView() {
-          app.anchorPointEllipsoidScaling = Number(viewModel.anchorPointEllipsoidScaling);
-          const anchorPointLabelsVisible = Boolean(viewModel.anchorPointLabelsVisible);
-          anchorPointVisualizer.setAnchorPointLabelsVisible(anchorPointLabelsVisible);
-          app.textureThreshold = Number(viewModel.textureThreshold);
-          await app.selectCurrentDataSet(viewModel.dataSetName);
-          for (const interactionOption of interactionOptions) {
-            if (interactionOption.text === viewModel.interactionMode) {
-              interactionOption.onselect();
-            }
-          }
-          for (const shaderOption of shaderOptions) {
-            if (shaderOption.text === viewModel.shaderMode) {
-              shaderOption.onselect();
-            }
-          }
-        }
-
-        Cesium.knockout.track(viewModel);
-        const toolbar = document.getElementById("toolbar");
-        Cesium.knockout.applyBindings(viewModel, toolbar);
-        for (const name in viewModel) {
-          if (viewModel.hasOwnProperty(name)) {
-            Cesium.knockout.getObservable(viewModel, name).subscribe(updateModelFromView);
-          }
-        }
-
-        await app.selectCurrentDataSet(dataSetOptions[0].name);
-
-        const scene = viewer.scene;
-
-        const canvas = viewer.canvas;
-        canvas.setAttribute("tabindex", "0"); // Put focus on the canvas
-        canvas.onclick = function () {
-          canvas.focus();
-        };
-
-        function captureCameraSettings(viewer) {
-          const camera = viewer.camera;
-          const cameraCode = `viewer.scene.camera.setView({
-  destination: new Cesium.Cartesian3(${camera.position.x}, ${camera.position.y}, ${camera.position.z}),
-  orientation: new Cesium.HeadingPitchRoll(${camera.heading}, ${camera.pitch}, ${camera.roll}),
-});`;
-          console.log(cameraCode);
-        }
-
-        document.addEventListener("keydown", function (e) {
-          if (e.key === "c") {
-            captureCameraSettings(viewer);
-          }
-        });
-
-        //Sandcastle_End
-      };
-      if (typeof Cesium !== "undefined") {
-        window.startupCalled = true;
-        window.startup(Cesium).catch((error) => {
-          "use strict";
-          console.error(error);
-        });
-        Sandcastle.finishedLoading();
-      }
-    </script>
-  </body>
-</html>
diff --git a/Apps/Sandcastle/gallery/development/NGA GPM Visualization.jpg b/Apps/Sandcastle/gallery/development/NGA GPM Visualization.jpg
deleted file mode 100644
index 5b2daea52ce03c25b298593a0d15c500b66cbe60..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8429
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


From 0c5826ceaa36e57cb7999a73452521fe936ce872 Mon Sep 17 00:00:00 2001
From: Marco Hutter <javagl@javagl.de>
Date: Fri, 22 Nov 2024 19:02:52 +0100
Subject: [PATCH 5/7] Update defined check

Co-authored-by: Gabby Getz <gabby@cesium.com>
---
 Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html
index 9c79f18dcdb0..c5b47c2960ca 100644
--- a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
+++ b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
@@ -1251,10 +1251,10 @@ <h4>Cesium GPM Visualization</h4>
            * @param {Cesium3DTileset|undefined} newCurrentTileset The new tileset
            */
           updateForCurrentTilesetChanged(oldCurrentTileset, newCurrentTileset) {
-            if (oldCurrentTileset !== undefined) {
+            if (Cesium.defined(oldCurrentTileset)) {
               oldCurrentTileset.tileVisible.removeEventListener(this.tileVisibleListener);
             }
-            if (newCurrentTileset !== undefined) {
+            if (Cesium.defined(newCurrentTileset)) {
               newCurrentTileset.tileVisible.addEventListener(this.tileVisibleListener);
             }
           }

From 9a641a5a2225a8856ee4eefad111bf3c61029e1e Mon Sep 17 00:00:00 2001
From: Marco Hutter <javagl@javagl.de>
Date: Fri, 22 Nov 2024 19:03:16 +0100
Subject: [PATCH 6/7] Update defined check

Co-authored-by: Gabby Getz <gabby@cesium.com>
---
 Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html
index c5b47c2960ca..a102825ca013 100644
--- a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
+++ b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
@@ -1232,12 +1232,12 @@ <h4>Cesium GPM Visualization</h4>
             const content = tile?.content;
             const modelContent =
               content instanceof Cesium.Model3DTileContent ? content : undefined;
-            if (!modelContent) {
+            if (!Cesium.defined(modelContent)) {
               return undefined;
             }
 
             const extensionObject = modelContent.getExtension("NGA_gpm_local");
-            if (!extensionObject) {
+            if (!Cesium.defined(extensionObject)) {
               return undefined;
             }
             return extensionObject.anchorPointsIndirect;

From 708a83a1025d3905a3e6d7c2ea0ee0c5a7cb1f2d Mon Sep 17 00:00:00 2001
From: Marco Hutter <javagl@javagl.de>
Date: Fri, 22 Nov 2024 19:05:21 +0100
Subject: [PATCH 7/7] Apply suggestions from code review

Mainly defined checks

Co-authored-by: Gabby Getz <gabby@cesium.com>
---
 .../gallery/3D Tiles NGA GPM Visualization.html     | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html
index a102825ca013..40f008469ef3 100644
--- a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
+++ b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.html	
@@ -285,7 +285,7 @@ <h4>Cesium GPM Visualization</h4>
            * @private
            */
           updateCustomShaderInTileset() {
-            if (this.currentTileset === undefined) {
+            if (!Cesium.defined(this.currentTileset)) {
               return;
             }
             this.currentTileset.customShader = this.currentCustomShader;
@@ -307,7 +307,7 @@ <h4>Cesium GPM Visualization</h4>
            * @private
            */
           updateTextureThresholdInShader() {
-            if (this.currentCustomShader === undefined) {
+            if (!Cesium.defined(this.currentCustomShader)) {
               return;
             }
             const hasTextureThreshold = Object.keys(
@@ -347,7 +347,7 @@ <h4>Cesium GPM Visualization</h4>
            * Zoom to the current tileset, with a small, unspecified offset...
            */
           zoomToCurrentTileset() {
-            if (this.currentTileset === undefined) {
+            if (!Cesium.defined(this.currentTileset)) {
               return;
             }
             const offset = new Cesium.HeadingPitchRange(
@@ -407,10 +407,10 @@ <h4>Cesium GPM Visualization</h4>
             propertyNameY,
           );
 
-          if (!metadataValueX) {
+          if (!Cesium.defined(metadataValueX)) {
             metadataValueX = 0;
           }
-          if (!metadataValueY) {
+          if (!Cesium.defined(metadataValueY)) {
             metadataValueY = 0;
           }
           result.x = metadataValueX;
@@ -678,7 +678,6 @@ <h4>Cesium GPM Visualization</h4>
            * properties.
            *
            * @param {string} title The title to be displayed in the combo box
-           * @param {string} title The title to be displayed in the combo box
            * @param {string|undefined} propertyName0 The property name 0
            * @param {number} sourceMin0 The minimum source value 0
            * @param {number} sourceMax0 The maximum source value 0
@@ -840,7 +839,7 @@ <h4>Cesium GPM Visualization</h4>
                 return;
               }
               const worldPosition = viewer.scene.pickPosition(movement.position);
-              if (worldPosition === undefined) {
+              if (!Cesium.defined(worldPosition)) {
                 that.clear();
               } else {
                 const uncertainty = pickUncertaintyFromTexture(movement.position);

+ Cesium GPM Visualization +
Data set	+ +	+ +
Anchor point ellipsoid	+ + + Labels +
Shader mode	+ +
Texture threshold (m)	+ + +
- Cesium GPM Visualization -
Data set	- -	- -
Anchor point ellipsoid	- - - Labels -
Shader mode	- -
Texture threshold (m)	- - -