@masterportal/masterportalapi 2.47.0 → 2.48.0

package/CHANGELOG.md

@@ -3,19 +3,10 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
-## Unreleased - in development
-
-### __Breaking Changes__
-
-### Added
-
-### Changed
-
-### Deprecated
-
-### Removed
+## 2.48.0 - 2025-04-01
 
 ### Fixed
+- olcsMap: fixed function setCameraParameter.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.47.0",
+  "version": "2.48.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {

package/src/maps/olcs/olcsMap.js

@@ -9,91 +9,84 @@ import defaults from "../../defaults";
 let mapIdCounter = 0;
 
 /**
- * Recursive function.
- * Sets the cesium default scene params.
- * @param {Cesium.scene} scene The cesium scene.
- * @param {Object} params Optional configuration parameters.
+ * Recursively sets parameters on the Cesium scene.
+ *
+ * Certain keys are excluded from being set directly on the scene object:
+ * - "0", "1", "2": These is placeholder keys or indices from certain configurations that should not be interpreted as scene properties.
+ * - "heading", "tilt", "altitude": These are camera-related properties and should be handled separately via specific camera functions.
+ *
+ * @param {Cesium.Scene} scene - The Cesium scene instance.
+ * @param {Object} params - Configuration parameters.
  * @returns {void}
  */
 export function setCesiumSceneParams (scene, params) {
-    Object.keys(params).forEach(paramKey => {
-        const paramValue = params[paramKey];
-
-        if (typeof paramValue === "object") {
-            Object.keys(paramValue).forEach(paramSubKey => {
-                if (paramSubKey !== "heading" && paramSubKey !== "tilt" && paramSubKey !== "altitude") {
-                    setCesiumSceneParams(scene[paramKey], paramValue);
-                }
-            });
+    if (!scene || !params || typeof params !== "object") {
+        console.warn("setCesiumSceneParams: Invalid scene or params.");
+        return;
+    }
+
+    Object.entries(params).forEach(([key, value]) => {
+        if (["0", "1", "2", "heading", "tilt", "altitude"].includes(key)) {
+            return;
+        }
+
+        if (typeof value === "object" && scene[key]) {
+            setCesiumSceneParams(scene[key], value);
         }
         else {
-            scene[paramKey] = paramValue;
+            scene[key] = value;
         }
     });
 }
 /**
  * Sets the camera parameters either from config or from an trigger.
- * @param {Object} params Params.
- * @param {Object} map3D olcs map.
- * @param {Cesium} cesium cesium.
+ * @param {Object} params - Parameters for setting the camera.
+ * @param {Object} map3D - olcs map instance.
+ * @param {Cesium} cesium - Cesium instance.
  * @returns {void}
  */
 export function setCameraParameter (params, map3D, cesium) {
-    let camera,
-        destination,
-        orientation,
-        heading;
-
-    if (params && map3D) {
-        if (typeof params.heading !== "undefined") {
-            heading = parseFloat(params.heading);
-        }
-        else if (typeof params.camera?.heading !== "undefined") {
-            heading = parseFloat(params.camera?.heading);
-        }
-        // if the cameraPosition is given, directly set the cesium camera position, otherwise use olcesium Camera
-        if (params.cameraPosition) {
-            camera = map3D.getCesiumScene().camera;
-            destination = cesium.Cartesian3.fromDegrees(params.cameraPosition[0], params.cameraPosition[1], params.cameraPosition[2]);
+    if (!params || !map3D) {
+        console.warn("setCameraParameter: Missing parameters or map3D instance.");
+        return;
+    }
+
+    let camera = map3D.getCesiumScene()?.camera;
+    const heading = parseFloat(params.heading ?? params.camera?.heading ?? 0),
+        pitch = parseFloat(params.pitch ?? params.camera?.pitch ?? 0),
+        roll = parseFloat(params.roll ?? 0),
+        tilt = parseFloat(params.tilt ?? params.camera?.tilt ?? 0),
+        altitude = parseFloat(params.altitude ?? params.camera?.altitude ?? 0);
+
+    if (params.cameraPosition || params.camera?.cameraPosition) {
+        const cameraPosition = params.cameraPosition ?? params.camera.cameraPosition,
+            destination = cesium.Cartesian3.fromDegrees(cameraPosition[0], cameraPosition[1], cameraPosition[2]),
             orientation = {
                 heading: cesium.Math.toRadians(heading),
-                pitch: cesium.Math.toRadians(parseFloat(params.pitch)),
-                roll: cesium.Math.toRadians(parseFloat(params.roll))
+                pitch: cesium.Math.toRadians(pitch),
+                roll: cesium.Math.toRadians(roll)
             };
 
-            camera.setView({
-                destination,
-                orientation
-            });
+        if (params.cameraPosition) {
+            camera.setView({destination, orientation});
         }
         else {
-            let tilt,
-                altitude;
+            camera.flyTo({destination, orientation});
+        }
 
-            if (typeof params.tilt !== "undefined") {
-                tilt = parseFloat(params.tilt);
-            }
-            else if (typeof params.camera?.tilt !== "undefined") {
-                tilt = parseFloat(params.camera?.tilt);
-            }
-            if (typeof params.altitude !== "undefined") {
-                altitude = parseFloat(params.altitude);
-            }
-            else if (typeof params.camera?.altitude !== "undefined") {
-                altitude = parseFloat(params.camera?.altitude);
-            }
-            camera = map3D.getCamera();
+        return;
+    }
 
-            if (tilt) {
-                camera.setTilt(tilt);
-            }
-            if (heading) {
-                camera.setHeading(heading);
-            }
-            if (altitude) {
-                camera.setAltitude(altitude);
-            }
-        }
+    camera = map3D.getCamera();
+
+    if (tilt) {
+        camera.setTilt(tilt);
+    }
+    if (heading) {
+        camera.setHeading(heading);
+    }
+    if (altitude) {
+        camera.setAltitude(altitude);
     }
 }
 

package/test/map.test.js

@@ -72,7 +72,7 @@ describe("map.js", function () {
                         };
                     }
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -165,7 +165,7 @@ describe("map.js", function () {
                     heading: -0.30858728378862876,
                     tilt: 0.9321791580603296
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -200,7 +200,7 @@ describe("map.js", function () {
                         tilt: 0.9321791580603296
                     }
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -213,48 +213,108 @@ describe("map.js", function () {
             });
         });
         it("set the camera from viewpoint parameter", function () {
-            const config = {
-                map2D: {
-                    getView: () => {
-                        return {
-                            getProjection: () => {
-                                return {getCode: () => "code"};
-                            }
-                        };
+            const mockFlyTo = jest.fn(),
+                config = {
+                    map2D: {
+                        getView: () => {
+                            return {
+                                getProjection: () => {
+                                    return {getCode: () => "code"};
+                                }
+                            };
+                        },
+                        getViewport: () => {
+                            return {
+                                appendChild: jest.fn()
+                            };
+                        }
                     },
-                    getViewport: () => {
-                        return {
-                            appendChild: jest.fn()
-                        };
-                    }
-                },
-                viewpoint: [{"distance": 1660.0290142521517,
-                    "cameraPosition": [
-                        9.982163927085617,
-                        53.532817572762475,
-                        1180.9805498821436
-                    ],
-                    "groundPosition": [
-                        9.983171185370468,
-                        53.54328139366739,
-                        -0.00449886760542777
-                    ],
-                    "heading": 3.281512334248587,
-                    "pitch": -45.35612834848329,
-                    "roll": 0.015054499334397243,
-                    "animate": false,
-                    "duration": 6.006336273348537
-                }],
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
-            };
+                    viewpoint: [{
+                        "distance": 1660.0290142521517,
+                        "cameraPosition": [
+                            9.982163927085617,
+                            53.532817572762475,
+                            1180.9805498821436
+                        ],
+                        "heading": 3.281512334248587,
+                        "pitch": -45.35612834848329,
+                        "roll": 0.015054499334397243
+                    }],
+                    cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
+                };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
-                const map3D = map.createMap(config, "3D");
+                const mockMap3D = {
+                    mapMode: "3D",
+                    getCesiumScene: () => ({
+                        camera: {
+                            flyTo: mockFlyTo
+                        }
+                    })
+                };
 
-                expect(map3D.mapMode).toBe("3D");
-                map.setCameraParameter(config.viewpoint, map3D, config.cesiumLib);
+                map.setCameraParameter(config.viewpoint, mockMap3D, config.cesiumLib);
 
-                // missing test, if the passed parameters are also in the 3D map
+                expect(mockFlyTo).toHaveBeenCalledWith(expect.objectContaining({
+                    destination: expect.any(Object),
+                    orientation: {
+                        heading: expect.any(Number),
+                        pitch: expect.any(Number),
+                        roll: expect.any(Number)
+                    },
+                    duration: config.viewpoint[0].duration
+                }));
+            });
+        });
+
+        it("sets the camera parameters when cameraPosition is not provided", function () {
+            const mockFlyTo = jest.fn(),
+                config = {
+                    map2D: {
+                        getView: () => {
+                            return {
+                                getProjection: () => {
+                                    return {getCode: () => "code"};
+                                }
+                            };
+                        },
+                        getViewport: () => {
+                            return {
+                                appendChild: jest.fn()
+                            };
+                        }
+                    },
+                    viewpoint: [{
+                        "distance": 1660.0290142521517,
+                        "heading": 3.281512334248587,
+                        "pitch": -45.35612834848329,
+                        "roll": 0.015054499334397243,
+                        "tilt": 10,
+                        "altitude": 1500
+                    }],
+                    cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
+                };
+
+            load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
+                const mockMap3D = {
+                    mapMode: "3D",
+                    getCesiumScene: () => ({
+                        camera: {
+                            flyTo: mockFlyTo,
+                            setTilt: jest.fn(),
+                            setHeading: jest.fn(),
+                            setAltitude: jest.fn()
+                        }
+                    })
+                };
+
+                map.setCameraParameter(config.viewpoint[0], mockMap3D, config.cesiumLib);
+
+                expect(mockFlyTo).not.toHaveBeenCalled();
+
+                expect(mockMap3D.getCesiumScene().camera.setTilt).toHaveBeenCalledWith(10);
+                expect(mockMap3D.getCesiumScene().camera.setHeading).toHaveBeenCalledWith(3.281512334248587);
+                expect(mockMap3D.getCesiumScene().camera.setAltitude).toHaveBeenCalledWith(1500);
             });
         });
     });
@@ -281,7 +341,7 @@ describe("map.js", function () {
                     heading: -0.30858728378862876,
                     tilt: 0.9321791580603296
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -339,7 +399,7 @@ describe("map.js", function () {
                         undergroundColor: undefined
                     }
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -355,5 +415,4 @@ describe("map.js", function () {
             });
         });
     });
-
 });