cesiumjs-anywidget 0.2.4__tar.gz → 0.4.0__tar.gz

{cesiumjs_anywidget-0.2.4 → cesiumjs_anywidget-0.4.0}/.gitignore

@@ -211,4 +211,4 @@ node_modules/
 package-lock.json
 
 # Generated/bundled files - source is in js/ subdirectory
-src/cesiumjs_anywidget/index.js
+src/cesiumjs_anywidget/index.js

{cesiumjs_anywidget-0.2.4 → cesiumjs_anywidget-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cesiumjs-anywidget
-Version: 0.2.4
+Version: 0.4.0
 Summary: A Jupyter widget for CesiumJS 3D globe visualization using anywidget
 Project-URL: Homepage, https://github.com/Alex-PLACET/cesiumjs_anywidget
 Project-URL: Repository, https://github.com/Alex-PLACET/cesiumjs_anywidget

cesiumjs_anywidget-0.4.0/fix_tests.py

@@ -0,0 +1,62 @@
+import re
+
+# Read the test file
+with open('tests/test_methods.py', 'r') as f:
+    content = f.read()
+
+# Fix the assertions
+# Change: assert widget_instance.geojson_data == geojson
+# To:     assert widget_instance.geojson_data == [geojson]
+content = re.sub(
+    r'assert widget_instance\.geojson_data == (sample_geojson|geojson|new_geojson)([^\[])',
+    r'assert widget_instance.geojson_data == [\1]\2',
+    content
+)
+
+# Fix: assert len(widget_instance.geojson_data["features"]) == 2
+# To:   assert len(widget_instance.geojson_data[0]["features"]) == 2
+content = re.sub(
+    r'widget_instance\.geojson_data\["features"\]',
+    r'widget_instance.geojson_data[0]["features"]',
+    content
+)
+
+# Write back
+with open('tests/test_methods.py', 'w') as f:
+    f.write(content)
+
+print("Fixed test_methods.py")
+
+# Also fix test_widget.py
+with open('tests/test_widget.py', 'r') as f:
+    content = f.read()
+
+# Change: assert widget_instance.geojson_data is None
+# To:     assert widget_instance.geojson_data == []
+content = re.sub(
+    r'assert widget_instance\.geojson_data is None',
+    r'assert widget_instance.geojson_data == []',
+    content
+)
+
+with open('tests/test_widget.py', 'w') as f:
+    f.write(content)
+
+print("Fixed test_widget.py")
+
+# Fix test_integration.py
+with open('tests/test_integration.py', 'r') as f:
+    content = f.read()
+
+# Change: assert widget_instance.geojson_data == geojson
+# To:     assert widget_instance.geojson_data == [geojson]
+content = re.sub(
+    r'assert widget_instance\.geojson_data == (empty_geojson|geojson)([^\[])',
+    r'assert widget_instance.geojson_data == [\1]\2',
+    content
+)
+
+with open('tests/test_integration.py', 'w') as f:
+    f.write(content)
+
+print("Fixed test_integration.py")

{cesiumjs_anywidget-0.2.4 → cesiumjs_anywidget-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cesiumjs-anywidget"
-version = "0.2.4"
+version = "0.4.0"
 description = "A Jupyter widget for CesiumJS 3D globe visualization using anywidget"
 readme = "README.md"
 license = { file = "LICENSE" }

{cesiumjs_anywidget-0.2.4 → cesiumjs_anywidget-0.4.0}/src/cesiumjs_anywidget/index.js

@@ -85,64 +85,318 @@ function setupViewerListeners(viewer, model, container, Cesium) {
       return;
     viewer.animation.container.style.visibility = model.get("show_animation") ? "visible" : "hidden";
   });
+  model.on("change:atmosphere_settings", () => {
+    if (!viewer || !viewer.scene || !viewer.scene.atmosphere)
+      return;
+    const settings = model.get("atmosphere_settings");
+    if (!settings || Object.keys(settings).length === 0)
+      return;
+    const atmosphere = viewer.scene.atmosphere;
+    if (settings.brightnessShift !== void 0) {
+      atmosphere.brightnessShift = settings.brightnessShift;
+    }
+    if (settings.hueShift !== void 0) {
+      atmosphere.hueShift = settings.hueShift;
+    }
+    if (settings.saturationShift !== void 0) {
+      atmosphere.saturationShift = settings.saturationShift;
+    }
+    if (settings.lightIntensity !== void 0) {
+      atmosphere.lightIntensity = settings.lightIntensity;
+    }
+    if (settings.rayleighCoefficient !== void 0 && Array.isArray(settings.rayleighCoefficient) && settings.rayleighCoefficient.length === 3) {
+      atmosphere.rayleighCoefficient = new Cesium.Cartesian3(
+        settings.rayleighCoefficient[0],
+        settings.rayleighCoefficient[1],
+        settings.rayleighCoefficient[2]
+      );
+    }
+    if (settings.rayleighScaleHeight !== void 0) {
+      atmosphere.rayleighScaleHeight = settings.rayleighScaleHeight;
+    }
+    if (settings.mieCoefficient !== void 0 && Array.isArray(settings.mieCoefficient) && settings.mieCoefficient.length === 3) {
+      atmosphere.mieCoefficient = new Cesium.Cartesian3(
+        settings.mieCoefficient[0],
+        settings.mieCoefficient[1],
+        settings.mieCoefficient[2]
+      );
+    }
+    if (settings.mieScaleHeight !== void 0) {
+      atmosphere.mieScaleHeight = settings.mieScaleHeight;
+    }
+    if (settings.mieAnisotropy !== void 0) {
+      atmosphere.mieAnisotropy = settings.mieAnisotropy;
+    }
+  });
+  model.on("change:sky_atmosphere_settings", () => {
+    if (!viewer || !viewer.scene || !viewer.scene.skyAtmosphere)
+      return;
+    const settings = model.get("sky_atmosphere_settings");
+    if (!settings || Object.keys(settings).length === 0)
+      return;
+    const skyAtmosphere = viewer.scene.skyAtmosphere;
+    if (settings.show !== void 0) {
+      skyAtmosphere.show = settings.show;
+    }
+    if (settings.brightnessShift !== void 0) {
+      skyAtmosphere.brightnessShift = settings.brightnessShift;
+    }
+    if (settings.hueShift !== void 0) {
+      skyAtmosphere.hueShift = settings.hueShift;
+    }
+    if (settings.saturationShift !== void 0) {
+      skyAtmosphere.saturationShift = settings.saturationShift;
+    }
+    if (settings.atmosphereLightIntensity !== void 0) {
+      skyAtmosphere.atmosphereLightIntensity = settings.atmosphereLightIntensity;
+    }
+    if (settings.atmosphereRayleighCoefficient !== void 0 && Array.isArray(settings.atmosphereRayleighCoefficient) && settings.atmosphereRayleighCoefficient.length === 3) {
+      skyAtmosphere.atmosphereRayleighCoefficient = new Cesium.Cartesian3(
+        settings.atmosphereRayleighCoefficient[0],
+        settings.atmosphereRayleighCoefficient[1],
+        settings.atmosphereRayleighCoefficient[2]
+      );
+    }
+    if (settings.atmosphereRayleighScaleHeight !== void 0) {
+      skyAtmosphere.atmosphereRayleighScaleHeight = settings.atmosphereRayleighScaleHeight;
+    }
+    if (settings.atmosphereMieCoefficient !== void 0 && Array.isArray(settings.atmosphereMieCoefficient) && settings.atmosphereMieCoefficient.length === 3) {
+      skyAtmosphere.atmosphereMieCoefficient = new Cesium.Cartesian3(
+        settings.atmosphereMieCoefficient[0],
+        settings.atmosphereMieCoefficient[1],
+        settings.atmosphereMieCoefficient[2]
+      );
+    }
+    if (settings.atmosphereMieScaleHeight !== void 0) {
+      skyAtmosphere.atmosphereMieScaleHeight = settings.atmosphereMieScaleHeight;
+    }
+    if (settings.atmosphereMieAnisotropy !== void 0) {
+      skyAtmosphere.atmosphereMieAnisotropy = settings.atmosphereMieAnisotropy;
+    }
+    if (settings.perFragmentAtmosphere !== void 0) {
+      skyAtmosphere.perFragmentAtmosphere = settings.perFragmentAtmosphere;
+    }
+  });
+  model.on("change:skybox_settings", () => {
+    if (!viewer || !viewer.scene || !viewer.scene.skyBox)
+      return;
+    const settings = model.get("skybox_settings");
+    if (!settings || Object.keys(settings).length === 0)
+      return;
+    const skyBox = viewer.scene.skyBox;
+    if (settings.show !== void 0) {
+      skyBox.show = settings.show;
+    }
+    if (settings.sources !== void 0 && settings.sources !== null) {
+      const sources = settings.sources;
+      if (sources.positiveX && sources.negativeX && sources.positiveY && sources.negativeY && sources.positiveZ && sources.negativeZ) {
+        viewer.scene.skyBox = new Cesium.SkyBox({
+          sources: {
+            positiveX: sources.positiveX,
+            negativeX: sources.negativeX,
+            positiveY: sources.positiveY,
+            negativeY: sources.negativeY,
+            positiveZ: sources.positiveZ,
+            negativeZ: sources.negativeZ
+          }
+        });
+        if (settings.show !== void 0) {
+          viewer.scene.skyBox.show = settings.show;
+        }
+      }
+    }
+  });
+  function getCameraState() {
+    const cartographic = viewer.camera.positionCartographic;
+    return {
+      latitude: Cesium.Math.toDegrees(cartographic.latitude),
+      longitude: Cesium.Math.toDegrees(cartographic.longitude),
+      altitude: cartographic.height,
+      heading: Cesium.Math.toDegrees(viewer.camera.heading),
+      pitch: Cesium.Math.toDegrees(viewer.camera.pitch),
+      roll: Cesium.Math.toDegrees(viewer.camera.roll)
+    };
+  }
+  function getClockState() {
+    if (!viewer.clock)
+      return null;
+    return {
+      current_time: Cesium.JulianDate.toIso8601(viewer.clock.currentTime),
+      multiplier: viewer.clock.multiplier,
+      is_animating: viewer.clock.shouldAnimate
+    };
+  }
+  function sendInteractionEvent(type, additionalData = {}) {
+    const event = {
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      camera: getCameraState(),
+      clock: getClockState(),
+      ...additionalData
+    };
+    console.log("[CesiumWidget] Interaction event:", type, event);
+    model.set("interaction_event", event);
+    model.save_changes();
+  }
+  const camera = viewer.camera;
+  camera.moveEnd.addEventListener(() => {
+    sendInteractionEvent("camera_move");
+  });
+  const scene = viewer.scene;
+  const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+  handler.setInputAction((click) => {
+    const pickedData = {};
+    const ray = viewer.camera.getPickRay(click.position);
+    const cartesian = viewer.scene.globe.pick(ray, viewer.scene);
+    if (cartesian) {
+      const cartographic = Cesium.Cartographic.fromCartesian(cartesian);
+      pickedData.picked_position = {
+        latitude: Cesium.Math.toDegrees(cartographic.latitude),
+        longitude: Cesium.Math.toDegrees(cartographic.longitude),
+        altitude: cartographic.height
+      };
+    }
+    const pickedObject = viewer.scene.pick(click.position);
+    if (Cesium.defined(pickedObject) && Cesium.defined(pickedObject.id)) {
+      const entity = pickedObject.id;
+      pickedData.picked_entity = {
+        id: entity.id,
+        name: entity.name || null
+      };
+      if (entity.properties) {
+        const props = {};
+        const propertyNames = entity.properties.propertyNames;
+        if (propertyNames && propertyNames.length > 0) {
+          propertyNames.forEach((name) => {
+            try {
+              props[name] = entity.properties[name].getValue(viewer.clock.currentTime);
+            } catch (e) {
+            }
+          });
+          if (Object.keys(props).length > 0) {
+            pickedData.picked_entity.properties = props;
+          }
+        }
+      }
+    }
+    sendInteractionEvent("left_click", pickedData);
+  }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  handler.setInputAction((click) => {
+    const pickedData = {};
+    const ray = viewer.camera.getPickRay(click.position);
+    const cartesian = viewer.scene.globe.pick(ray, viewer.scene);
+    if (cartesian) {
+      const cartographic = Cesium.Cartographic.fromCartesian(cartesian);
+      pickedData.picked_position = {
+        latitude: Cesium.Math.toDegrees(cartographic.latitude),
+        longitude: Cesium.Math.toDegrees(cartographic.longitude),
+        altitude: cartographic.height
+      };
+    }
+    sendInteractionEvent("right_click", pickedData);
+  }, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
+  if (viewer.timeline) {
+    let timelineScrubbing = false;
+    let scrubTimeout = null;
+    viewer.clock.onTick.addEventListener(() => {
+      if (viewer.timeline) {
+        if (scrubTimeout) {
+          clearTimeout(scrubTimeout);
+        }
+        scrubTimeout = setTimeout(() => {
+          if (timelineScrubbing) {
+            timelineScrubbing = false;
+            sendInteractionEvent("timeline_scrub");
+          }
+        }, 500);
+        timelineScrubbing = true;
+      }
+    });
+  }
 }
 function setupGeoJSONLoader(viewer, model, Cesium) {
-  let geojsonDataSource = null;
+  let geojsonDataSources = [];
   model.on("change:geojson_data", async () => {
-    if (!viewer)
+    if (!viewer || !viewer.dataSources)
       return;
-    const geojsonData = model.get("geojson_data");
-    if (geojsonDataSource) {
-      viewer.dataSources.remove(geojsonDataSource);
-      geojsonDataSource = null;
-    }
-    if (geojsonData) {
-      try {
-        geojsonDataSource = await Cesium.GeoJsonDataSource.load(geojsonData, {
-          stroke: Cesium.Color.HOTPINK,
-          fill: Cesium.Color.PINK.withAlpha(0.5),
-          strokeWidth: 3
-        });
-        viewer.dataSources.add(geojsonDataSource);
-        viewer.flyTo(geojsonDataSource);
-      } catch (error) {
-        console.error("Error loading GeoJSON:", error);
+    const geojsonDataArray = model.get("geojson_data");
+    geojsonDataSources.forEach((dataSource) => {
+      if (viewer && viewer.dataSources) {
+        viewer.dataSources.remove(dataSource);
+      }
+    });
+    geojsonDataSources = [];
+    if (geojsonDataArray && Array.isArray(geojsonDataArray)) {
+      for (const geojsonData of geojsonDataArray) {
+        try {
+          const dataSource = await Cesium.GeoJsonDataSource.load(geojsonData, {
+            stroke: Cesium.Color.HOTPINK,
+            fill: Cesium.Color.PINK.withAlpha(0.5),
+            strokeWidth: 3
+          });
+          if (viewer && viewer.dataSources) {
+            viewer.dataSources.add(dataSource);
+            geojsonDataSources.push(dataSource);
+          }
+        } catch (error) {
+          console.error("Error loading GeoJSON:", error);
+        }
+      }
+      if (geojsonDataSources.length > 0 && viewer && viewer.flyTo) {
+        viewer.flyTo(geojsonDataSources[0]);
       }
     }
   });
   return {
     destroy: () => {
-      if (geojsonDataSource && viewer) {
-        viewer.dataSources.remove(geojsonDataSource);
-      }
+      geojsonDataSources.forEach((dataSource) => {
+        if (viewer) {
+          viewer.dataSources.remove(dataSource);
+        }
+      });
+      geojsonDataSources = [];
     }
   };
 }
 function setupCZMLLoader(viewer, model, Cesium) {
-  let czmlDataSource = null;
+  let czmlDataSources = [];
   model.on("change:czml_data", async () => {
-    if (!viewer)
+    if (!viewer || !viewer.dataSources)
       return;
-    const czmlData = model.get("czml_data");
-    if (czmlDataSource) {
-      viewer.dataSources.remove(czmlDataSource);
-      czmlDataSource = null;
-    }
-    if (czmlData && Array.isArray(czmlData) && czmlData.length > 0) {
-      try {
-        czmlDataSource = await Cesium.CzmlDataSource.load(czmlData);
-        viewer.dataSources.add(czmlDataSource);
-        viewer.flyTo(czmlDataSource);
-      } catch (error) {
-        console.error("Error loading CZML:", error);
+    const czmlDataArray = model.get("czml_data");
+    czmlDataSources.forEach((dataSource) => {
+      if (viewer && viewer.dataSources) {
+        viewer.dataSources.remove(dataSource);
+      }
+    });
+    czmlDataSources = [];
+    if (czmlDataArray && Array.isArray(czmlDataArray)) {
+      for (const czmlData of czmlDataArray) {
+        if (Array.isArray(czmlData) && czmlData.length > 0) {
+          try {
+            const dataSource = await Cesium.CzmlDataSource.load(czmlData);
+            if (viewer && viewer.dataSources) {
+              viewer.dataSources.add(dataSource);
+              czmlDataSources.push(dataSource);
+            }
+          } catch (error) {
+            console.error("Error loading CZML:", error);
+          }
+        }
+      }
+      if (czmlDataSources.length > 0 && viewer && viewer.flyTo) {
+        viewer.flyTo(czmlDataSources[0]);
       }
     }
   });
   return {
     destroy: () => {
-      if (czmlDataSource && viewer) {
-        viewer.dataSources.remove(czmlDataSource);
-      }
+      czmlDataSources.forEach((dataSource) => {
+        if (viewer) {
+          viewer.dataSources.remove(dataSource);
+        }
+      });
+      czmlDataSources = [];
     }
   };
 }
@@ -194,6 +448,99 @@ function initializeCameraSync(viewer, model) {
   model.on("change:heading", updateCameraFromModel);
   model.on("change:pitch", updateCameraFromModel);
   model.on("change:roll", updateCameraFromModel);
+  model.on("change:camera_command", () => {
+    const command = model.get("camera_command");
+    if (!command || !command.command || !command.timestamp)
+      return;
+    const cmd = command.command;
+    try {
+      switch (cmd) {
+        case "flyTo":
+          viewer.camera.flyTo({
+            destination: Cesium.Cartesian3.fromDegrees(
+              command.longitude,
+              command.latitude,
+              command.altitude
+            ),
+            orientation: {
+              heading: Cesium.Math.toRadians(command.heading || 0),
+              pitch: Cesium.Math.toRadians(command.pitch || -15),
+              roll: Cesium.Math.toRadians(command.roll || 0)
+            },
+            duration: command.duration || 3
+          });
+          break;
+        case "setView":
+          viewer.camera.setView({
+            destination: Cesium.Cartesian3.fromDegrees(
+              command.longitude,
+              command.latitude,
+              command.altitude
+            ),
+            orientation: {
+              heading: Cesium.Math.toRadians(command.heading || 0),
+              pitch: Cesium.Math.toRadians(command.pitch || -15),
+              roll: Cesium.Math.toRadians(command.roll || 0)
+            }
+          });
+          break;
+        case "lookAt":
+          const target = Cesium.Cartesian3.fromDegrees(
+            command.targetLongitude,
+            command.targetLatitude,
+            command.targetAltitude || 0
+          );
+          const offset = new Cesium.HeadingPitchRange(
+            Cesium.Math.toRadians(command.offsetHeading || 0),
+            Cesium.Math.toRadians(command.offsetPitch || -45),
+            command.offsetRange || 1e3
+          );
+          viewer.camera.lookAt(target, offset);
+          viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+          break;
+        case "moveForward":
+          viewer.camera.moveForward(command.distance || 100);
+          break;
+        case "moveBackward":
+          viewer.camera.moveBackward(command.distance || 100);
+          break;
+        case "moveUp":
+          viewer.camera.moveUp(command.distance || 100);
+          break;
+        case "moveDown":
+          viewer.camera.moveDown(command.distance || 100);
+          break;
+        case "moveLeft":
+          viewer.camera.moveLeft(command.distance || 100);
+          break;
+        case "moveRight":
+          viewer.camera.moveRight(command.distance || 100);
+          break;
+        case "rotateLeft":
+          viewer.camera.rotateLeft(Cesium.Math.toRadians(command.angle || 15));
+          break;
+        case "rotateRight":
+          viewer.camera.rotateRight(Cesium.Math.toRadians(command.angle || 15));
+          break;
+        case "rotateUp":
+          viewer.camera.rotateUp(Cesium.Math.toRadians(command.angle || 15));
+          break;
+        case "rotateDown":
+          viewer.camera.rotateDown(Cesium.Math.toRadians(command.angle || 15));
+          break;
+        case "zoomIn":
+          viewer.camera.zoomIn(command.distance || 100);
+          break;
+        case "zoomOut":
+          viewer.camera.zoomOut(command.distance || 100);
+          break;
+        default:
+          console.warn(`Unknown camera command: ${cmd}`);
+      }
+    } catch (error) {
+      console.error(`Error executing camera command ${cmd}:`, error);
+    }
+  });
   return {
     updateCameraFromModel,
     updateModelFromCamera,
@@ -588,23 +935,42 @@ function initializeMeasurementTools(viewer, model, container) {
       </button>
     `;
     editorPanel.style.display = "block";
-    document.getElementById("apply-coords").onclick = () => {
-      const lon = parseFloat(document.getElementById("edit-lon").value);
-      const lat = parseFloat(document.getElementById("edit-lat").value);
-      const alt = parseFloat(document.getElementById("edit-alt").value);
-      const newPosition = Cesium.Cartesian3.fromDegrees(lon, lat, alt);
-      updatePointPosition(newPosition);
-      finalizeMeasurementUpdate();
-    };
-    document.getElementById("close-editor").onclick = () => {
-      deselectPoint();
-    };
-    ["edit-lon", "edit-lat", "edit-alt"].forEach((id) => {
-      document.getElementById(id).onkeypress = (e) => {
-        if (e.key === "Enter") {
-          document.getElementById("apply-coords").click();
+    const applyBtn = document.getElementById("apply-coords");
+    const closeBtn = document.getElementById("close-editor");
+    const editLonInput = document.getElementById("edit-lon");
+    const editLatInput = document.getElementById("edit-lat");
+    const editAltInput = document.getElementById("edit-alt");
+    if (!applyBtn || !closeBtn || !editLonInput || !editLatInput || !editAltInput) {
+      console.warn("[CesiumWidget] Editor panel input elements not found in DOM");
+    }
+    if (applyBtn) {
+      applyBtn.onclick = () => {
+        if (!editLonInput || !editLatInput || !editAltInput) {
+          console.warn("[CesiumWidget] Editor input fields not available");
+          return;
         }
+        const lon = parseFloat(editLonInput.value);
+        const lat = parseFloat(editLatInput.value);
+        const alt = parseFloat(editAltInput.value);
+        const newPosition = Cesium.Cartesian3.fromDegrees(lon, lat, alt);
+        updatePointPosition(newPosition);
+        finalizeMeasurementUpdate();
       };
+    }
+    if (closeBtn) {
+      closeBtn.onclick = () => {
+        deselectPoint();
+      };
+    }
+    ["edit-lon", "edit-lat", "edit-alt"].forEach((id) => {
+      const element = document.getElementById(id);
+      if (element) {
+        element.onkeypress = (e) => {
+          if (e.key === "Enter" && applyBtn) {
+            applyBtn.click();
+          }
+        };
+      }
     });
   }
   function updatePointPosition(newPosition) {
@@ -758,6 +1124,10 @@ function initializeMeasurementTools(viewer, model, container) {
   function updateMeasurementsList() {
     const results = model.get("measurement_results") || [];
     const listContent = document.getElementById("measurements-list-content");
+    if (!listContent) {
+      console.warn("[CesiumWidget] Measurements list content element not found in DOM");
+      return;
+    }
     if (results.length === 0) {
       listContent.innerHTML = '<div style="color: #888; font-style: italic;">No measurements yet</div>';
       return;
@@ -808,10 +1178,15 @@ function initializeMeasurementTools(viewer, model, container) {
         }
       };
       listContent.appendChild(measurementDiv);
-      document.getElementById(`rename-${index}`).onclick = (e) => {
-        e.stopPropagation();
-        renameMeasurement(index, name);
-      };
+      const renameBtn = document.getElementById(`rename-${index}`);
+      if (renameBtn) {
+        renameBtn.onclick = (e) => {
+          e.stopPropagation();
+          renameMeasurement(index, name);
+        };
+      } else {
+        console.warn(`[CesiumWidget] Rename button not found for measurement ${index}`);
+      }
     });
   }
   function getMeasurementColor(type) {