bruce-models 3.4.3 → 3.4.5

package/dist/bruce-models.umd.js

@@ -2436,6 +2436,128 @@
         Color.ColorFromStr = ColorFromStr;
     })(exports.Color || (exports.Color = {}));
 
+    /**
+     * Describes vector geometry that Bruce uses.
+     */
+    (function (Geometry) {
+        let EPolygonRingType;
+        (function (EPolygonRingType) {
+            EPolygonRingType["Boundaries"] = "out";
+            EPolygonRingType["Hole"] = "in";
+        })(EPolygonRingType = Geometry.EPolygonRingType || (Geometry.EPolygonRingType = {}));
+        /**
+         * Turns an array of points into string vector geometry that Bruce can use.
+         * This is used for saving polyline and polygon data.
+         * @param points
+         * @returns
+         */
+        function LineStrFromPoints(points) {
+            if (!points.length) {
+                throw ("points is empty.");
+            }
+            let carto = points[0];
+            let lineString = `${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
+            for (let i = 1; i < points.length; i++) {
+                carto = points[i];
+                lineString += ` ${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
+            }
+            return lineString;
+        }
+        Geometry.LineStrFromPoints = LineStrFromPoints;
+        /**
+         * Removes same points that occur in a row.
+         * This will not modify the original array.
+         * @param positions
+         * @returns
+         */
+        function RemoveRepeatPoints(positions) {
+            const filteredList = [];
+            for (let i = 0; i < positions.length; i++) {
+                const pos = positions[i];
+                const lastPos = filteredList.length > 0 ? filteredList[filteredList.length - 1] : null;
+                if (!lastPos || (pos.latitude != lastPos.latitude || pos.longitude != lastPos.longitude || pos.altitude != lastPos.altitude)) {
+                    filteredList.push(pos);
+                }
+            }
+            return filteredList;
+        }
+        Geometry.RemoveRepeatPoints = RemoveRepeatPoints;
+        /**
+         * Parses a string of points into an array of points.
+         * @param pointsStr
+         * @returns
+         */
+        function ParsePoints(pointsStr) {
+            pointsStr = pointsStr.replace(/[^\d.,-\s]/g, "");
+            let splitterCoordinates = " ";
+            let splitterAxis = ",";
+            const commaIndex = pointsStr.indexOf(",");
+            const spaceIndex = pointsStr.indexOf(" ");
+            if ((spaceIndex > -1 && commaIndex > spaceIndex) || commaIndex <= -1) {
+                splitterCoordinates = ",";
+                splitterAxis = " ";
+            }
+            let points = pointsStr.trim().split(splitterCoordinates);
+            points = points.filter(a => a != "");
+            const result = [];
+            for (let i = 0; i < points.length; i++) {
+                const pointData = points[i];
+                const coords = pointData.trim().split(splitterAxis);
+                if (coords.length == 2 || coords.length == 3) {
+                    const longitude = Number(coords[0]);
+                    const latitude = Number(coords[1]);
+                    const altitude = Number(coords.length >= 3 ? coords[2] : 0);
+                    if (longitude != null && latitude != null) {
+                        result.push({
+                            altitude: altitude,
+                            latitude: latitude,
+                            longitude: longitude
+                        });
+                    }
+                    else {
+                        console.warn("Invalid point data detected.", pointData);
+                    }
+                }
+            }
+            return result;
+        }
+        Geometry.ParsePoints = ParsePoints;
+        /**
+         * Parses both string and object Bruce geometry.
+         * String geometry is legacy Bruce data.
+         * @param geometry
+         * @returns
+         */
+        function ParseGeometry(geometry) {
+            if (typeof geometry == "string") {
+                let positions = [];
+                const geometryParsed = (geometry || "").split(";");
+                for (let i = 0; i < geometryParsed.length; i++) {
+                    const data = geometryParsed[i];
+                    const points = ParsePoints(data);
+                    if (points && points.length > 0) {
+                        positions = positions.concat(points);
+                    }
+                }
+                positions = RemoveRepeatPoints(positions);
+                const newGeometry = {};
+                if (positions.length > 0) {
+                    const topPoint = positions[0];
+                    newGeometry.Point = `${topPoint.latitude},${topPoint.longitude}` + (topPoint.altitude != null ? `,${topPoint.altitude}` : "");
+                    if (positions.length > 1) {
+                        newGeometry.Polygon = [{ Facing: EPolygonRingType.Boundaries, LinearRing: LineStrFromPoints(positions) }];
+                    }
+                    if (positions.length > 2) {
+                        newGeometry.LineString = LineStrFromPoints(positions);
+                    }
+                }
+                return newGeometry;
+            }
+            return geometry;
+        }
+        Geometry.ParseGeometry = ParseGeometry;
+    })(exports.Geometry || (exports.Geometry = {}));
+
     (function (ObjectUtils) {
         const DEFAULT_LENGTH = 36;
         /**
@@ -2701,6 +2823,27 @@
         PathUtils.ParseLegacy = ParseLegacy;
     })(exports.PathUtils || (exports.PathUtils = {}));
 
+    /**
+     * Describes an expectation on what should be rendered for a menu item-
+     * between a min-max distance of an entity to the camera.
+     */
+    (function (ZoomControl) {
+        /**
+         * Available display types for a menu item.
+         */
+        let EDisplayType;
+        (function (EDisplayType) {
+            // Hidden means it will not be rendered.
+            EDisplayType["Hidden"] = "hidden";
+            // Point will try render a point based on any available Entity data.
+            EDisplayType["Point"] = "point";
+            // Geometry means it will try render multi-geometry, polygon, polyline, or point in order of priority.
+            EDisplayType["Geometry"] = "geometry";
+            // 3D means it will try render 3D model, multi-geometry, polygon, polyline, or point in order of priority.
+            EDisplayType["Model3D"] = "3d";
+        })(EDisplayType = ZoomControl.EDisplayType || (ZoomControl.EDisplayType = {}));
+    })(exports.ZoomControl || (exports.ZoomControl = {}));
+
     (function (Entity) {
         /**
          * Returns cache identifier for an entity record.
@@ -3214,6 +3357,121 @@
             });
         }
         Entity.GetList = GetList;
+        function ToGeoJson(params) {
+            const { entities, excludeAltitude, altitude, includeUserData, allowedDisplayTypes } = params;
+            const features = [];
+            const allowPoint = allowedDisplayTypes == null || allowedDisplayTypes.includes(exports.ZoomControl.EDisplayType.Point);
+            const allowGeometry = allowedDisplayTypes == null || allowedDisplayTypes.includes(exports.ZoomControl.EDisplayType.Geometry);
+            const cloneObj = (obj) => {
+                return JSON.parse(JSON.stringify(obj));
+            };
+            const areCoordinatesEqual = (coord1, coord2) => {
+                return coord1[0] === coord2[0] && coord1[1] === coord2[1] && (coord1[2] === coord2[2] || (coord1.length < 3 && coord2.length < 3));
+            };
+            const removeConsecutiveDuplicates = (coordinates) => {
+                return coordinates.filter((coord, index, array) => {
+                    return index === 0 || !areCoordinatesEqual(coord, array[index - 1]);
+                });
+            };
+            const closePolygonCoordinates = (coordinates) => {
+                if (coordinates.length > 0 && !areCoordinatesEqual(coordinates[0], coordinates[coordinates.length - 1])) {
+                    const firstPointCopy = [...coordinates[0]];
+                    coordinates.push(firstPointCopy);
+                }
+                return coordinates;
+            };
+            const populateProperties = (feature, entity) => {
+                let properties = null;
+                // All properties.
+                if (includeUserData != false) {
+                    properties = cloneObj(entity);
+                    // We exclude geometry since the geojson is supposed to represent that attribute.
+                    delete properties.geometry;
+                }
+                // Only specific internal properties.
+                else {
+                    properties = {
+                        Bruce: entity.Bruce ? cloneObj(entity.Bruce) : null,
+                        location: entity.location ? cloneObj(entity.location) : null,
+                        transform: entity.transform ? cloneObj(entity.transform) : null,
+                        boundaries: entity.boundaries ? cloneObj(entity.boundaries) : null,
+                    };
+                }
+                feature.properties = properties;
+            };
+            const processGeometry = (geometry, entity) => {
+                var _a, _b;
+                const feature = {
+                    type: "Feature",
+                    properties: {},
+                    geometry: null
+                };
+                populateProperties(feature, entity);
+                if (((_a = geometry.MultiGeometry) === null || _a === void 0 ? void 0 : _a.length) && allowGeometry) {
+                    geometry.MultiGeometry.forEach(geo => processGeometry(geo, entity));
+                    return;
+                }
+                else if (((_b = geometry.Polygon) === null || _b === void 0 ? void 0 : _b.length) && allowGeometry) {
+                    const sortedPolygons = geometry.Polygon.sort((a, b) => a.Facing === exports.Geometry.EPolygonRingType.Boundaries ? -1 : 1);
+                    const coordinates = sortedPolygons.map(polygonRing => closePolygonCoordinates(removeConsecutiveDuplicates(polygonRing.LinearRing.split(' ').map(coord => {
+                        const [lon, lat, alt] = coord.split(',').map(Number);
+                        return excludeAltitude ? [lon, lat] : [lon, lat, altitude !== undefined ? altitude : (alt !== undefined ? alt : [])];
+                    }))));
+                    // Check if the polygon has at least 4 points.
+                    const isValidPolygon = coordinates.every(polygon => polygon.length >= 4);
+                    if (!isValidPolygon) {
+                        // Perhaps try other geometry instead of returning?
+                        return;
+                    }
+                    feature.geometry = {
+                        type: "Polygon",
+                        coordinates: coordinates,
+                    };
+                }
+                else if (geometry.LineString && (allowedDisplayTypes == null || allowedDisplayTypes.includes(exports.ZoomControl.EDisplayType.Geometry))) {
+                    const coordinates = removeConsecutiveDuplicates(geometry.LineString.split(' ').map(coord => {
+                        const [lon, lat, alt] = coord.split(',').map(Number);
+                        return excludeAltitude ? [lon, lat] : [lon, lat, altitude !== undefined ? altitude : (alt !== undefined ? alt : [])];
+                    }));
+                    // Check if the polyline has at least 2 points.
+                    if (coordinates.length < 2) {
+                        // Perhaps try other geometry instead of returning?
+                        return;
+                    }
+                    feature.geometry = {
+                        type: "LineString",
+                        coordinates,
+                    };
+                }
+                else if (geometry.Point && allowPoint) {
+                    const [lon, lat, alt] = geometry.Point.split(',').map(Number);
+                    const coordinates = excludeAltitude ? [lon, lat] : [lon, lat, altitude !== undefined ? altitude : (alt !== undefined ? alt : [])];
+                    feature.geometry = {
+                        type: "Point",
+                        coordinates,
+                    };
+                }
+                features.push(feature);
+            };
+            entities.forEach(entity => {
+                var _a, _b, _c;
+                if (!((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID)) {
+                    return;
+                }
+                let geometry = entity.geometry;
+                if (!geometry && (((_b = entity.location) === null || _b === void 0 ? void 0 : _b.longitude) && ((_c = entity.location) === null || _c === void 0 ? void 0 : _c.latitude))) {
+                    geometry = {
+                        Point: `${entity.location.longitude},${entity.location.latitude}` + (entity.location.altitude != null ? `,${entity.location.altitude}` : ""),
+                    };
+                }
+                processGeometry(geometry, entity);
+            });
+            return {
+                type: "FeatureCollection",
+                features,
+            };
+        }
+        Entity.ToGeoJson = ToGeoJson;
     })(exports.Entity || (exports.Entity = {}));
 
     /**
@@ -3710,196 +3968,6 @@
         Calculator.GetInputValue = GetInputValue;
     })(exports.Calculator || (exports.Calculator = {}));
 
-    /**
-     * Describes vector geometry that Bruce uses.
-     */
-    (function (Geometry) {
-        let EPolygonRingType;
-        (function (EPolygonRingType) {
-            EPolygonRingType["Boundaries"] = "out";
-            EPolygonRingType["Hole"] = "in";
-        })(EPolygonRingType = Geometry.EPolygonRingType || (Geometry.EPolygonRingType = {}));
-        /**
-         * Turns an array of points into string vector geometry that Bruce can use.
-         * This is used for saving polyline and polygon data.
-         * @param points
-         * @returns
-         */
-        function LineStrFromPoints(points) {
-            if (!points.length) {
-                throw ("points is empty.");
-            }
-            let carto = points[0];
-            let lineString = `${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
-            for (let i = 1; i < points.length; i++) {
-                carto = points[i];
-                lineString += ` ${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
-            }
-            return lineString;
-        }
-        Geometry.LineStrFromPoints = LineStrFromPoints;
-        /**
-         * Removes same points that occur in a row.
-         * This will not modify the original array.
-         * @param positions
-         * @returns
-         */
-        function RemoveRepeatPoints(positions) {
-            const filteredList = [];
-            for (let i = 0; i < positions.length; i++) {
-                const pos = positions[i];
-                const lastPos = filteredList.length > 0 ? filteredList[filteredList.length - 1] : null;
-                if (!lastPos || (pos.latitude != lastPos.latitude || pos.longitude != lastPos.longitude || pos.altitude != lastPos.altitude)) {
-                    filteredList.push(pos);
-                }
-            }
-            return filteredList;
-        }
-        Geometry.RemoveRepeatPoints = RemoveRepeatPoints;
-        /**
-         * Parses a string of points into an array of points.
-         * @param pointsStr
-         * @returns
-         */
-        function ParsePoints(pointsStr) {
-            pointsStr = pointsStr.replace(/[^\d.,-\s]/g, "");
-            let splitterCoordinates = " ";
-            let splitterAxis = ",";
-            const commaIndex = pointsStr.indexOf(",");
-            const spaceIndex = pointsStr.indexOf(" ");
-            if ((spaceIndex > -1 && commaIndex > spaceIndex) || commaIndex <= -1) {
-                splitterCoordinates = ",";
-                splitterAxis = " ";
-            }
-            let points = pointsStr.trim().split(splitterCoordinates);
-            points = points.filter(a => a != "");
-            const result = [];
-            for (let i = 0; i < points.length; i++) {
-                const pointData = points[i];
-                const coords = pointData.trim().split(splitterAxis);
-                if (coords.length == 2 || coords.length == 3) {
-                    const longitude = Number(coords[0]);
-                    const latitude = Number(coords[1]);
-                    const altitude = Number(coords.length >= 3 ? coords[2] : 0);
-                    if (longitude != null && latitude != null) {
-                        result.push({
-                            altitude: altitude,
-                            latitude: latitude,
-                            longitude: longitude
-                        });
-                    }
-                    else {
-                        console.warn("Invalid point data detected.", pointData);
-                    }
-                }
-            }
-            return result;
-        }
-        Geometry.ParsePoints = ParsePoints;
-        /**
-         * Parses both string and object Bruce geometry.
-         * String geometry is legacy Bruce data.
-         * @param geometry
-         * @returns
-         */
-        function ParseGeometry(geometry) {
-            if (typeof geometry == "string") {
-                let positions = [];
-                const geometryParsed = (geometry || "").split(";");
-                for (let i = 0; i < geometryParsed.length; i++) {
-                    const data = geometryParsed[i];
-                    const points = ParsePoints(data);
-                    if (points && points.length > 0) {
-                        positions = positions.concat(points);
-                    }
-                }
-                positions = RemoveRepeatPoints(positions);
-                const newGeometry = {};
-                if (positions.length > 0) {
-                    const topPoint = positions[0];
-                    newGeometry.Point = `${topPoint.latitude},${topPoint.longitude}` + (topPoint.altitude != null ? `,${topPoint.altitude}` : "");
-                    if (positions.length > 1) {
-                        newGeometry.Polygon = [{ Facing: EPolygonRingType.Boundaries, LinearRing: LineStrFromPoints(positions) }];
-                    }
-                    if (positions.length > 2) {
-                        newGeometry.LineString = LineStrFromPoints(positions);
-                    }
-                }
-                return newGeometry;
-            }
-            return geometry;
-        }
-        Geometry.ParseGeometry = ParseGeometry;
-        function ToGeoJson(params) {
-            const { entities, excludeAltitude } = params;
-            const features = [];
-            const processGeometry = (geometry, ID) => {
-                if (geometry.Polygon) {
-                    const sortedPolygons = geometry.Polygon.sort((a, b) => a.Facing === EPolygonRingType.Boundaries ? -1 : 1);
-                    const coordinates = sortedPolygons.map(polygonRing => polygonRing.LinearRing.split(' ').map(coord => {
-                        const [lon, lat, alt] = coord.split(',').map(Number);
-                        return excludeAltitude ? [lon, lat] : [lon, lat, ...(alt ? [alt] : [])];
-                    }));
-                    features.push({
-                        type: 'Feature',
-                        properties: { ID },
-                        geometry: {
-                            type: 'Polygon',
-                            coordinates: coordinates,
-                        }
-                    });
-                }
-                if (geometry.Point) {
-                    const [lon, lat, alt] = geometry.Point.split(',').map(Number);
-                    const coordinates = excludeAltitude ? [lon, lat] : [lon, lat, ...(alt ? [alt] : [])];
-                    features.push({
-                        type: 'Feature',
-                        properties: { ID },
-                        geometry: {
-                            type: 'Point',
-                            coordinates,
-                        }
-                    });
-                }
-                if (geometry.LineString) {
-                    const coordinates = geometry.LineString.split(' ').map(coord => {
-                        const [lon, lat, alt] = coord.split(',').map(Number);
-                        return excludeAltitude ? [lon, lat] : [lon, lat, ...(alt ? [alt] : [])];
-                    });
-                    features.push({
-                        type: 'Feature',
-                        properties: { ID },
-                        geometry: {
-                            type: 'LineString',
-                            coordinates,
-                        }
-                    });
-                }
-                if (geometry.MultiGeometry) {
-                    geometry.MultiGeometry.forEach(geo => processGeometry(geo, ID));
-                }
-            };
-            entities.forEach(entity => {
-                var _a, _b, _c;
-                if (!((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID)) {
-                    return;
-                }
-                let geometry = entity.geometry;
-                if (!geometry && (((_b = entity.location) === null || _b === void 0 ? void 0 : _b.longitude) && ((_c = entity.location) === null || _c === void 0 ? void 0 : _c.latitude))) {
-                    geometry = {
-                        Point: `${entity.location.longitude},${entity.location.latitude}` + (entity.location.altitude != null ? `,${entity.location.altitude}` : ""),
-                    };
-                }
-                processGeometry(geometry, entity.Bruce.ID);
-            });
-            return {
-                type: 'FeatureCollection',
-                features,
-            };
-        }
-        Geometry.ToGeoJson = ToGeoJson;
-    })(exports.Geometry || (exports.Geometry = {}));
-
     (function (Bounds) {
         /**
          * Calculates boundaries from entity.
@@ -6908,27 +6976,6 @@
         ProgramKey.Update = Update;
     })(exports.ProgramKey || (exports.ProgramKey = {}));
 
-    /**
-     * Describes an expectation on what should be rendered for a menu item-
-     * between a min-max distance of an entity to the camera.
-     */
-    (function (ZoomControl) {
-        /**
-         * Available display types for a menu item.
-         */
-        let EDisplayType;
-        (function (EDisplayType) {
-            // Hidden means it will not be rendered.
-            EDisplayType["Hidden"] = "hidden";
-            // Point will try render a point based on any available Entity data.
-            EDisplayType["Point"] = "point";
-            // Geometry means it will try render multi-geometry, polygon, polyline, or point in order of priority.
-            EDisplayType["Geometry"] = "geometry";
-            // 3D means it will try render 3D model, multi-geometry, polygon, polyline, or point in order of priority.
-            EDisplayType["Model3D"] = "3d";
-        })(EDisplayType = ZoomControl.EDisplayType || (ZoomControl.EDisplayType = {}));
-    })(exports.ZoomControl || (exports.ZoomControl = {}));
-
     (function (Tileset) {
         /**
          * Returns cache identifier for a tileset.
@@ -10525,7 +10572,7 @@
         DataSource.GetList = GetList;
     })(exports.DataSource || (exports.DataSource = {}));
 
-    const VERSION = "3.4.3";
+    const VERSION = "3.4.5";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;