proximiio-js-library 1.16.2 → 1.17.0

package/assets/wayfinding.js

@@ -847,19 +847,25 @@ export class Wayfinding {
     return path;
   }
   _calculateWallOffsetPointList(currentPoint, previousPoint) {
-    const pointList = this._getPointList();
+    let pointList = this._getPointList();
     let currentPointIndex = pointList.indexOf(currentPoint);
-    const previousPointIndex = pointList.indexOf(previousPoint);
-    const offsetPointList = [];
+    let previousPointIndex = pointList.indexOf(previousPoint);
+    let offsetPointList = [];
     let currentOffsetPoint = currentPoint;
     // a) offset current point
     if (currentPointIndex >= 0 && this.wallOffsets[currentPointIndex]) {
       currentOffsetPoint = this.wallOffsets[currentPointIndex];
     }
     offsetPointList.push(currentOffsetPoint);
+
+    const visitedIndices = new Set(); // <-- track visited offset indices
+    if (currentPointIndex >= 0) {
+      visitedIndices.add(currentPointIndex);
+    }
+
     let potentialOffsetPoints;
     do {
-      const line = turf.lineString([previousPoint.geometry.coordinates, currentOffsetPoint.geometry.coordinates]);
+      let line = turf.lineString([previousPoint.geometry.coordinates, currentOffsetPoint.geometry.coordinates]);
       potentialOffsetPoints = [];
       this.wallOffsetLineList.forEach((wallOffsetLine, index) => {
         // Do not process wall offsets from another floor
@@ -870,9 +876,13 @@ export class Wayfinding {
         if (index === previousPointIndex || index === currentPointIndex) {
           return;
         }
-        const intersection = turf.lineIntersect(line, wallOffsetLine);
+        // Do not process already visited offset points  // <-- skip visited
+        if (visitedIndices.has(index)) {
+          return;
+        }
+        let intersection = turf.lineIntersect(line, wallOffsetLine);
         if (intersection.features.length > 0) {
-          const offsetPoint = this.wallOffsets[index];
+          let offsetPoint = this.wallOffsets[index];
           // store distance to previousPoint
           offsetPoint.properties.distance = this._distance(intersection.features[0], currentOffsetPoint);
           offsetPoint.properties.offsetIndex = index;
@@ -883,9 +893,11 @@ export class Wayfinding {
         potentialOffsetPoints.sort((a, b) => a.properties.distance - b.properties.distance);
         currentOffsetPoint = potentialOffsetPoints[0];
         currentPointIndex = currentOffsetPoint.properties.offsetIndex;
+        visitedIndices.add(currentPointIndex); // <-- mark as visited
         offsetPointList.push(currentOffsetPoint);
       }
     } while (potentialOffsetPoints.length > 0);
+
     return offsetPointList.reverse();
   }
   _getIntersectingOffsetPoints(current, previous) {
@@ -1203,56 +1215,53 @@ export class Wayfinding {
   _getNeighbours(point, startPoint, endPoint) {
     let neighbours = [];
     if (point === startPoint) {
-      const levelPoints = this._getPointList().filter((proposedPoint) =>
+      let levelPoints = this._getPointList().filter((proposedPoint) =>
         this._isPointOnLevel(proposedPoint, point.properties.level),
       );
       neighbours = this._findNeighbours(point, startPoint, endPoint, levelPoints);
       neighbours = neighbours.filter((neighbourPoint) => {
-        const level = point.properties.level;
-        const revolvingDoorBlock =
+        //                if (neighbourPoint === endPoint) {
+        //                    console.log('testing endPoint');
+        //                }
+        let level = point.properties.level;
+        let revolvingDoorBlock =
           this.configuration.avoidRevolvingDoors &&
           this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.REVOLVING_DOOR);
-        const ticketGateBlock =
+        let ticketGateBlock =
           this.configuration.avoidTicketGates &&
           this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.TICKET_GATE);
-        const isCrossingTwoPolygon = this._checkIfCrossingTwoPolygon(point, neighbourPoint);
-        return !revolvingDoorBlock && !ticketGateBlock && !isCrossingTwoPolygon;
+        return !revolvingDoorBlock && !ticketGateBlock;
       });
     } else {
       // Gather neighbours over all levels
-      const points = this._getPointList();
-      const pointIndex = points.indexOf(point);
-      if (pointIndex >= 0) {
-        this.floorData.forEach((_, level) => {
-          const levelNeighbourMap = this.neighbourMap[level];
-          if (levelNeighbourMap.hasOwnProperty(pointIndex)) {
-            levelNeighbourMap[pointIndex].forEach((neighbourIndex) => {
-              const neighbourPoint = points[neighbourIndex];
-              const revolvingDoorBlock =
-                this.configuration.avoidRevolvingDoors &&
-                this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.REVOLVING_DOOR);
-              const ticketGateBlock =
-                this.configuration.avoidTicketGates &&
-                this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.TICKET_GATE);
-              const isCrossingTwoPolygon = this._checkIfCrossingTwoPolygon(point, neighbourPoint);
-              if (
-                !neighbours.includes(neighbourPoint) &&
-                !revolvingDoorBlock &&
-                !ticketGateBlock &&
-                !isCrossingTwoPolygon
-              ) {
-                neighbours.push(neighbourPoint);
-              }
-            });
-          }
-        });
-      }
+      let points = this._getPointList();
+      let pointIndex = points.indexOf(point);
+      this.floorData.forEach((_, level) => {
+        let levelNeighbourMap = this.neighbourMap[level];
+        if (Object.prototype.hasOwnProperty.call(levelNeighbourMap, pointIndex)) {
+          levelNeighbourMap[pointIndex].forEach((neighbourIndex) => {
+            let neighbourPoint = points[neighbourIndex];
+
+            let revolvingDoorBlock =
+              this.configuration.avoidRevolvingDoors &&
+              this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.REVOLVING_DOOR);
+            let ticketGateBlock =
+              this.configuration.avoidTicketGates &&
+              this._testAccessibilityPoiNeighbourhood(point, neighbourPoint, level, this.POI_TYPE.TICKET_GATE);
+
+            if (!neighbours.includes(neighbourPoint) && !revolvingDoorBlock && !ticketGateBlock) {
+              neighbours.push(neighbourPoint);
+            }
+          });
+        }
+      });
+
       // Test if endpoint is neighbour
       if (
         (point.properties.level !== undefined && point.properties.level === endPoint.properties.level) ||
         (point.properties.fixedPointMap != undefined && point.properties.fixedPointMap.has(endPoint.properties.level))
       ) {
-        const revolvingDoorBlock =
+        let revolvingDoorBlock =
           this.configuration.avoidRevolvingDoors &&
           this._testAccessibilityPoiNeighbourhood(
             point,
@@ -1260,7 +1269,7 @@ export class Wayfinding {
             endPoint.properties.level,
             this.POI_TYPE.REVOLVING_DOOR,
           );
-        const ticketGateBlock =
+        let ticketGateBlock =
           this.configuration.avoidTicketGates &&
           this._testAccessibilityPoiNeighbourhood(
             point,
@@ -1268,8 +1277,8 @@ export class Wayfinding {
             endPoint.properties.level,
             this.POI_TYPE.TICKET_GATE,
           );
-        const isCrossingTwoPolygon = this._checkIfCrossingTwoPolygon(point, endPoint);
-        if (!revolvingDoorBlock && !ticketGateBlock && !isCrossingTwoPolygon) {
+
+        if (!revolvingDoorBlock && !ticketGateBlock) {
           // Endpoint is fixed on corridor
           if (endPoint.properties.onCorridor) {
             if (endPoint.properties.neighbours.includes(point)) {
@@ -1282,9 +1291,10 @@ export class Wayfinding {
             ) {
               neighbours.push(endPoint);
             }
+
             // End point is not on corridor, therefore should be in the area
           } else {
-            const unwrapped = this._unwrapLevelChangerPoint(point, endPoint.properties.level);
+            let unwrapped = this._unwrapLevelChangerPoint(point, endPoint.properties.level);
             let allowedIntersections = 1;
             if (unwrapped.properties.isCorridorPoint || unwrapped.properties.onCorridor) {
               allowedIntersections--;
@@ -1296,7 +1306,9 @@ export class Wayfinding {
         }
       }
     }
-    return neighbours.filter((neighbour) => {
+
+    const beforeFilterCount = neighbours.length;
+    const filteredNeighbours = neighbours.filter((neighbour) => {
       if (this.configuration.avoidElevators && neighbour.properties.type === this.POI_TYPE.ELEVATOR) {
         return false;
       } else if (this.configuration.avoidEscalators && neighbour.properties.type === this.POI_TYPE.ESCALATOR) {
@@ -1307,11 +1319,11 @@ export class Wayfinding {
         return false;
       } else if (this.configuration.avoidRamps && neighbour.properties.ramp) {
         return false;
-      } else if (this.configuration.avoidHills && neighbour.properties.hill) {
-        return false;
       }
       return true;
     });
+
+    return filteredNeighbours;
   }
   /**
    *
@@ -1682,58 +1694,59 @@ export class Wayfinding {
     return this._getFixPointInArea(endPoint);
   }
   _getFixPointInArea(point) {
-    const floorData = this.floorData.get(point.properties.level);
-    // If point is located without accessible area, do nothing
-    let pointFound = undefined;
-    if (floorData?.areas.length > 0) {
-      floorData.areas.forEach((polygon) => {
-        if (turf.booleanContains(polygon, point)) {
-          pointFound = point;
-          return;
-        }
-      });
+    let floorData = this.floorData.get(point.properties.level);
+
+    if (!floorData) {
+      return point;
     }
-    if (pointFound !== undefined) {
-      return pointFound;
+
+    // If point is located without accessible area, do nothing
+    let areaList = floorData.areas;
+    for (let index in areaList) {
+      let polygon = areaList[index];
+      if (turf.booleanContains(polygon, point)) {
+        return point;
+      }
     }
+
     // Find nearest wall to stick to
     let bestWall = null;
     let bestWallDistance = Infinity;
-    if (floorData?.wallFeatures.length > 0) {
-      floorData.wallFeatures.forEach((wall) => {
-        const distance = turf.pointToLineDistance(point.geometry.coordinates, wall, { units: this.UNIT_TYPE });
-        if (distance <= bestWallDistance) {
-          bestWall = wall;
-          bestWallDistance = distance;
-        }
-      });
-    }
-    const levelCorridorFeatures = this.corridorLineFeatures.filter(
+    floorData.wallFeatures.forEach((wall) => {
+      let distance = turf.pointToLineDistance(point.geometry.coordinates, wall, { units: 'meters' });
+      if (distance < bestWallDistance) {
+        bestWall = wall;
+        bestWallDistance = distance;
+      }
+    });
+
+    let levelCorridorFeatures = this.corridorLineFeatures.filter(
       (corridorLine) => corridorLine.properties.level === point.properties.level,
     );
     let bestCorridorIndex = null;
     let bestCorridorDistance = Infinity;
     levelCorridorFeatures.forEach((corridor) => {
-      const corridorIndex = this.corridorLineFeatures.indexOf(corridor);
-      const corridorDistance = turf.pointToLineDistance(point.geometry.coordinates, corridor, {
-        units: this.UNIT_TYPE,
-      });
+      let corridorIndex = this.corridorLineFeatures.indexOf(corridor);
+      let corridorDistance = turf.pointToLineDistance(point.geometry.coordinates, corridor, { units: 'meters' });
       if (corridorDistance < bestCorridorDistance) {
         bestCorridorIndex = corridorIndex;
         bestCorridorDistance = corridorDistance;
       }
     });
+
     // Test if area or corridor is closer, create appropriate fixed point
     if (bestWall === null && bestCorridorIndex === null) {
       // could not find neither close area or corridor
       return point;
     } else {
       let fixedPoint;
+
       // Corridor is closer
-      if (bestCorridorIndex !== undefined && bestCorridorDistance < bestWallDistance) {
+      if (bestCorridorIndex !== null && bestCorridorDistance < bestWallDistance) {
         // Create fixed point on line itself
-        const line = this.corridorLineFeatures[bestCorridorIndex];
+        let line = this.corridorLineFeatures[bestCorridorIndex];
         fixedPoint = turf.nearestPointOnLine(line, point);
+
         // Mark this fixed point is on corridor, preset neighbours
         fixedPoint.properties.onCorridor = true;
         fixedPoint.properties.corridorIndex = bestCorridorIndex;
@@ -1754,11 +1767,11 @@ export class Wayfinding {
         } else if (this.corridorLineFeatures[bestCorridorIndex].properties.swapDirection != true) {
           fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][0]);
           // include only intersection points after this point
-          const distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
-          const pointsBefore = line.properties.intersectionPointList.filter(
+          let distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
+          let pointsBefore = line.properties.intersectionPointList.filter(
             (point) => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) < distance,
           );
-          const pointsAfter = line.properties.intersectionPointList.filter(
+          let pointsAfter = line.properties.intersectionPointList.filter(
             (point) => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) >= distance,
           );
           fixedPoint.properties.neighbours.push(...pointsAfter);
@@ -1766,11 +1779,11 @@ export class Wayfinding {
         } else {
           fixedPoint.properties.neighbours.push(this.corridorLinePointPairs[bestCorridorIndex][1]);
           // include only intersection points before this point
-          const distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
-          const pointsBefore = line.properties.intersectionPointList.filter(
+          let distance = this._distance(fixedPoint, this.corridorLinePointPairs[bestCorridorIndex][0]);
+          let pointsBefore = line.properties.intersectionPointList.filter(
             (point) => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) <= distance,
           );
-          const pointsAfter = line.properties.intersectionPointList.filter(
+          let pointsAfter = line.properties.intersectionPointList.filter(
             (point) => this._distance(point, this.corridorLinePointPairs[bestCorridorIndex][0]) > distance,
           );
           fixedPoint.properties.neighbours.push(...pointsBefore);
@@ -1779,12 +1792,16 @@ export class Wayfinding {
         // Wall is closer
       } else if (bestWall !== null) {
         // Create fixed point inside area
-        const nearestPoint = turf.nearestPointOnLine(bestWall, point);
-        const bearing = turf.bearing(point, nearestPoint);
-        fixedPoint = turf.destination(point.geometry.coordinates, bestWallDistance + 0.05, bearing, this.UNIT_TYPE);
+        let nearestPoint = turf.nearestPointOnLine(bestWall, point);
+        let bearing = turf.bearing(point, nearestPoint);
+        fixedPoint = turf.destination(point.geometry.coordinates, bestWallDistance + 0.05, bearing, {
+          units: 'meters',
+        });
       }
+
       // Mark level of fixed point
       fixedPoint.properties.level = point.properties.level;
+
       // Return created point
       return fixedPoint;
     }

package/lib/assets/wayfinding.js

@@ -72,11 +72,13 @@ if(e.properties.level!==i.properties.level)continue;const o=this._distance(e,i);
 .5>o&&p.push(e)}t=t.filter(e=>!p.includes(e)),p=[];// Simplify the route by omitting corners that are basically straight
 for(let s=1;s<t.length-1;s++){const e=t[s-1],i=t[s],n=t[s+1];// Different floors nothing to do
 if(e.properties.level!==i.properties.level||e.properties.level!==n.properties.level)continue;const a=this.bearing(e.geometry.coordinates,i.geometry.coordinates),l=this.bearing(i.geometry.coordinates,n.geometry.coordinates);let d=o(a-l);d>r&&(d-=r),.03488888>d&&p.push(i)}// let pathCoordinates = path.map(point => point.geometry.coordinates);
-return t=t.filter(e=>!p.includes(e)),t}_calculateWallOffsetPointList(e,r){const i=this._getPointList();let o=i.indexOf(e);const t=i.indexOf(r),s=[];let p=e;// a) offset current point
-0<=o&&this.wallOffsets[o]&&(p=this.wallOffsets[o]),s.push(p);let n;do{const i=turf.lineString([r.geometry.coordinates,p.geometry.coordinates]);n=[],this.wallOffsetLineList.forEach((r,s)=>{// Do not process wall offsets from another floor
-if(r.properties.level===e.properties.level&&s!==t&&s!==o)// Do not process wall offsets with previous or current point
-{const e=turf.lineIntersect(i,r);if(0<e.features.length){const r=this.wallOffsets[s];// store distance to previousPoint
-r.properties.distance=this._distance(e.features[0],p),r.properties.offsetIndex=s,n.push(r)}}}),0<n.length&&(n.sort((e,r)=>e.properties.distance-r.properties.distance),p=n[0],o=p.properties.offsetIndex,s.push(p))}while(0<n.length);return s.reverse()}_getIntersectingOffsetPoints(e,r){if(e===r||e.properties.level!==r.properties.level)return[];const i=turf.lineString([e.geometry.coordinates,r.geometry.coordinates]),o=[];return this.wallOffsetLineList.forEach((r,t)=>{if(r.properties.level===e.properties.level&&0<turf.lineIntersect(i,r).features.length){const i=this.wallOffsets[t];i.properties.distance=turf.pointToLineDistance(e.geometry.coordinates,r,{units:this.UNIT_TYPE}),o.push(i)}}),o.sort((e,r)=>r.properties.distance-r.properties.distance),o}clearData(){this.floorData&&this.floorData.forEach(e=>{for(const r in e.points){const i=e.points[r];delete i.properties.cameFrom,delete i.properties.gscore,delete i.properties.fscore}}),this.levelChangerList&&this.levelChangerList.forEach(e=>{e.properties.fixedPointMap.forEach(e=>{delete e.properties.cameFrom,delete e.properties.gscore,delete e.properties.fscore})}),this.corridorLinePoints&&this.corridorLinePoints.forEach(e=>{delete e.properties.cameFrom,delete e.properties.gscore,delete e.properties.fscore})}/**
+return t=t.filter(e=>!p.includes(e)),t}_calculateWallOffsetPointList(e,r){let i=this._getPointList(),o=i.indexOf(e),t=i.indexOf(r),s=[],p=e;// a) offset current point
+0<=o&&this.wallOffsets[o]&&(p=this.wallOffsets[o]),s.push(p);const n=new Set;// <-- track visited offset indices
+0<=o&&n.add(o);let a;do{let i=turf.lineString([r.geometry.coordinates,p.geometry.coordinates]);a=[],this.wallOffsetLineList.forEach((r,s)=>{// Do not process wall offsets from another floor
+if(r.properties.level===e.properties.level&&s!==t&&s!==o&&!n.has(s))// Do not process already visited offset points  // <-- skip visited
+// Do not process wall offsets with previous or current point
+{let e=turf.lineIntersect(i,r);if(0<e.features.length){let r=this.wallOffsets[s];// store distance to previousPoint
+r.properties.distance=this._distance(e.features[0],p),r.properties.offsetIndex=s,a.push(r)}}}),0<a.length&&(a.sort((e,r)=>e.properties.distance-r.properties.distance),p=a[0],o=p.properties.offsetIndex,n.add(o),s.push(p))}while(0<a.length);return s.reverse()}_getIntersectingOffsetPoints(e,r){if(e===r||e.properties.level!==r.properties.level)return[];const i=turf.lineString([e.geometry.coordinates,r.geometry.coordinates]),o=[];return this.wallOffsetLineList.forEach((r,t)=>{if(r.properties.level===e.properties.level&&0<turf.lineIntersect(i,r).features.length){const i=this.wallOffsets[t];i.properties.distance=turf.pointToLineDistance(e.geometry.coordinates,r,{units:this.UNIT_TYPE}),o.push(i)}}),o.sort((e,r)=>r.properties.distance-r.properties.distance),o}clearData(){this.floorData&&this.floorData.forEach(e=>{for(const r in e.points){const i=e.points[r];delete i.properties.cameFrom,delete i.properties.gscore,delete i.properties.fscore}}),this.levelChangerList&&this.levelChangerList.forEach(e=>{e.properties.fixedPointMap.forEach(e=>{delete e.properties.cameFrom,delete e.properties.gscore,delete e.properties.fscore})}),this.corridorLinePoints&&this.corridorLinePoints.forEach(e=>{delete e.properties.cameFrom,delete e.properties.gscore,delete e.properties.fscore})}/**
    *
    * @param startPoint {Feature<Point>}
    * @param endPoint {Feature<Point>}
@@ -142,10 +144,13 @@ if(null===p)break;if(p===o){let t;try{t=this.reconstructPath(p)}catch(e){return}
    * @param endPoint {Feature<Point>}
    * @return {Point[]}
    * @private
-   */_getNeighbours(e,r,i){let o=[];if(e===r){const t=this._getPointList().filter(r=>this._isPointOnLevel(r,e.properties.level));o=this._findNeighbours(e,r,i,t),o=o.filter(r=>{const i=e.properties.level,o=this.configuration.avoidRevolvingDoors&&this._testAccessibilityPoiNeighbourhood(e,r,i,this.POI_TYPE.REVOLVING_DOOR),t=this.configuration.avoidTicketGates&&this._testAccessibilityPoiNeighbourhood(e,r,i,this.POI_TYPE.TICKET_GATE),s=this._checkIfCrossingTwoPolygon(e,r);return!o&&!t&&!s})}else{// Gather neighbours over all levels
-const r=this._getPointList(),t=r.indexOf(e);// Test if endpoint is neighbour
-if(0<=t&&this.floorData.forEach((i,s)=>{const p=this.neighbourMap[s];p.hasOwnProperty(t)&&p[t].forEach(i=>{const t=r[i],p=this.configuration.avoidRevolvingDoors&&this._testAccessibilityPoiNeighbourhood(e,t,s,this.POI_TYPE.REVOLVING_DOOR),n=this.configuration.avoidTicketGates&&this._testAccessibilityPoiNeighbourhood(e,t,s,this.POI_TYPE.TICKET_GATE),a=this._checkIfCrossingTwoPolygon(e,t);o.includes(t)||p||n||a||o.push(t)})}),void 0!==e.properties.level&&e.properties.level===i.properties.level||null!=e.properties.fixedPointMap&&e.properties.fixedPointMap.has(i.properties.level)){const r=this.configuration.avoidRevolvingDoors&&this._testAccessibilityPoiNeighbourhood(e,i,i.properties.level,this.POI_TYPE.REVOLVING_DOOR),t=this.configuration.avoidTicketGates&&this._testAccessibilityPoiNeighbourhood(e,i,i.properties.level,this.POI_TYPE.TICKET_GATE),s=this._checkIfCrossingTwoPolygon(e,i);if(!r&&!t&&!s)// Endpoint is fixed on corridor
-if(i.properties.onCorridor)i.properties.neighbours.includes(e)?!1!=this.corridorLineFeatures[i.properties.corridorIndex].properties.bidirectional&&o.push(i):void 0!==i.properties.neighboursLeadingTo&&i.properties.neighboursLeadingTo.includes(e)&&o.push(i);else{const r=this._unwrapLevelChangerPoint(e,i.properties.level);let t=1;(r.properties.isCorridorPoint||r.properties.onCorridor)&&t--,this._countIntersections(r,i,t)&&o.push(i)}}}return o.filter(e=>{if(this.configuration.avoidElevators&&e.properties.type===this.POI_TYPE.ELEVATOR)return!1;return!(this.configuration.avoidEscalators&&e.properties.type===this.POI_TYPE.ESCALATOR)&&!(this.configuration.avoidStaircases&&e.properties.type===this.POI_TYPE.STAIRCASE)&&!(this.configuration.avoidNarrowPaths&&e.properties.narrowPath)&&!(this.configuration.avoidRamps&&e.properties.ramp)&&!(this.configuration.avoidHills&&e.properties.hill)})}/**
+   */_getNeighbours(e,r,i){let o=[];if(e===r){let t=this._getPointList().filter(r=>this._isPointOnLevel(r,e.properties.level));o=this._findNeighbours(e,r,i,t),o=o.filter(r=>{//                if (neighbourPoint === endPoint) {
+//                    console.log('testing endPoint');
+//                }
+let i=e.properties.level,o=this.configuration.avoidRevolvingDoors&&this._testAccessibilityPoiNeighbourhood(e,r,i,this.POI_TYPE.REVOLVING_DOOR),t=this.configuration.avoidTicketGates&&this._testAccessibilityPoiNeighbourhood(e,r,i,this.POI_TYPE.TICKET_GATE);return!o&&!t})}else{// Gather neighbours over all levels
+let r=this._getPointList(),t=r.indexOf(e);// Test if endpoint is neighbour
+if(this.floorData.forEach((i,s)=>{let p=this.neighbourMap[s];Object.prototype.hasOwnProperty.call(p,t)&&p[t].forEach(i=>{let t=r[i],p=this.configuration.avoidRevolvingDoors&&this._testAccessibilityPoiNeighbourhood(e,t,s,this.POI_TYPE.REVOLVING_DOOR),n=this.configuration.avoidTicketGates&&this._testAccessibilityPoiNeighbourhood(e,t,s,this.POI_TYPE.TICKET_GATE);o.includes(t)||p||n||o.push(t)})}),void 0!==e.properties.level&&e.properties.level===i.properties.level||null!=e.properties.fixedPointMap&&e.properties.fixedPointMap.has(i.properties.level)){let r=this.configuration.avoidRevolvingDoors&&this._testAccessibilityPoiNeighbourhood(e,i,i.properties.level,this.POI_TYPE.REVOLVING_DOOR),t=this.configuration.avoidTicketGates&&this._testAccessibilityPoiNeighbourhood(e,i,i.properties.level,this.POI_TYPE.TICKET_GATE);if(!r&&!t)// Endpoint is fixed on corridor
+if(i.properties.onCorridor)i.properties.neighbours.includes(e)?!1!=this.corridorLineFeatures[i.properties.corridorIndex].properties.bidirectional&&o.push(i):void 0!==i.properties.neighboursLeadingTo&&i.properties.neighboursLeadingTo.includes(e)&&o.push(i);else{let r=this._unwrapLevelChangerPoint(e,i.properties.level),t=1;(r.properties.isCorridorPoint||r.properties.onCorridor)&&t--,this._countIntersections(r,i,t)&&o.push(i)}}}const t=o.length,s=o.filter(e=>{if(this.configuration.avoidElevators&&e.properties.type===this.POI_TYPE.ELEVATOR)return!1;return!(this.configuration.avoidEscalators&&e.properties.type===this.POI_TYPE.ESCALATOR)&&!(this.configuration.avoidStaircases&&e.properties.type===this.POI_TYPE.STAIRCASE)&&!(this.configuration.avoidNarrowPaths&&e.properties.narrowPath)&&!(this.configuration.avoidRamps&&e.properties.ramp)});return s}/**
    *
    * @param pointA {Feature<Point>}
    * @param pointB {Feature<Point>}
@@ -205,17 +210,17 @@ return i.forEach(i=>{const t=this._distance(e,i)+this._distance(i,r)+10;t<o&&(o=
    */_distance(e,r){let i=0;return r.properties.level!==e.properties.level&&(i=10),turf.distance(e,r,{units:this.UNIT_TYPE})+i}/**
    *
    * @private
-   */_getFixEndPoint(e,r){var i=Math.abs;const o=this.levelChangerList.find(r=>r.id===e.id);if(o!==void 0&&o.properties.fixedPointMap!==void 0){let t;o.properties.fixedPointMap.forEach((e,o)=>{(t===void 0||i(t-r)>i(o-r))&&(t=o)}),e=this._copyPoint(e),e.properties.level=t}return this._getFixPointInArea(e)}_getFixPointInArea(e){const r=this.floorData.get(e.properties.level);// If point is located without accessible area, do nothing
-let i;if(0<r?.areas.length&&r.areas.forEach(r=>{if(turf.booleanContains(r,e))return void(i=e)}),void 0!==i)return i;// Find nearest wall to stick to
-let o=null,t=1/0;0<r?.wallFeatures.length&&r.wallFeatures.forEach(r=>{const i=turf.pointToLineDistance(e.geometry.coordinates,r,{units:this.UNIT_TYPE});i<=t&&(o=r,t=i)});const s=this.corridorLineFeatures.filter(r=>r.properties.level===e.properties.level);let p=null,n=1/0;// Test if area or corridor is closer, create appropriate fixed point
-if(s.forEach(r=>{const i=this.corridorLineFeatures.indexOf(r),o=turf.pointToLineDistance(e.geometry.coordinates,r,{units:this.UNIT_TYPE});o<n&&(p=i,n=o)}),null===o&&null===p)// could not find neither close area or corridor
+   */_getFixEndPoint(e,r){var i=Math.abs;const o=this.levelChangerList.find(r=>r.id===e.id);if(o!==void 0&&o.properties.fixedPointMap!==void 0){let t;o.properties.fixedPointMap.forEach((e,o)=>{(t===void 0||i(t-r)>i(o-r))&&(t=o)}),e=this._copyPoint(e),e.properties.level=t}return this._getFixPointInArea(e)}_getFixPointInArea(e){let r=this.floorData.get(e.properties.level);if(!r)return e;// If point is located without accessible area, do nothing
+let i=r.areas;for(let r in i){let o=i[r];if(turf.booleanContains(o,e))return e}// Find nearest wall to stick to
+let o=null,t=1/0;r.wallFeatures.forEach(r=>{let i=turf.pointToLineDistance(e.geometry.coordinates,r,{units:"meters"});i<t&&(o=r,t=i)});let s=this.corridorLineFeatures.filter(r=>r.properties.level===e.properties.level),p=null,n=1/0;// Test if area or corridor is closer, create appropriate fixed point
+if(s.forEach(r=>{let i=this.corridorLineFeatures.indexOf(r),o=turf.pointToLineDistance(e.geometry.coordinates,r,{units:"meters"});o<n&&(p=i,n=o)}),null===o&&null===p)// could not find neither close area or corridor
 return e;else{let r;// Corridor is closer
-if(void 0!==p&&n<t){// Create fixed point on line itself
-const i=this.corridorLineFeatures[p];if(r=turf.nearestPointOnLine(i,e),r.properties.onCorridor=!0,r.properties.corridorIndex=p,r.properties.neighbours||(r.properties.neighbours=[]),!1!=this.corridorLineFeatures[p].properties.bidirectional)r.properties.neighbours.push(this.corridorLinePointPairs[p][0],this.corridorLinePointPairs[p][1]),r.properties.neighbours.push(...i.properties.intersectionPointList),r.properties.neighboursLeadingTo=[this.corridorLinePointPairs[p][0],this.corridorLinePointPairs[p][1],...i.properties.intersectionPointList];else if(!0!=this.corridorLineFeatures[p].properties.swapDirection){r.properties.neighbours.push(this.corridorLinePointPairs[p][0]);// include only intersection points after this point
-const e=this._distance(r,this.corridorLinePointPairs[p][0]),o=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])<e),t=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])>=e);r.properties.neighbours.push(...t),r.properties.neighboursLeadingTo=o}else{r.properties.neighbours.push(this.corridorLinePointPairs[p][1]);// include only intersection points before this point
-const e=this._distance(r,this.corridorLinePointPairs[p][0]),o=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])<=e),t=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])>e);r.properties.neighbours.push(...o),r.properties.neighboursLeadingTo=t}// Wall is closer
+if(null!==p&&n<t){// Create fixed point on line itself
+let i=this.corridorLineFeatures[p];if(r=turf.nearestPointOnLine(i,e),r.properties.onCorridor=!0,r.properties.corridorIndex=p,r.properties.neighbours||(r.properties.neighbours=[]),!1!=this.corridorLineFeatures[p].properties.bidirectional)r.properties.neighbours.push(this.corridorLinePointPairs[p][0],this.corridorLinePointPairs[p][1]),r.properties.neighbours.push(...i.properties.intersectionPointList),r.properties.neighboursLeadingTo=[this.corridorLinePointPairs[p][0],this.corridorLinePointPairs[p][1],...i.properties.intersectionPointList];else if(!0!=this.corridorLineFeatures[p].properties.swapDirection){r.properties.neighbours.push(this.corridorLinePointPairs[p][0]);// include only intersection points after this point
+let e=this._distance(r,this.corridorLinePointPairs[p][0]),o=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])<e),t=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])>=e);r.properties.neighbours.push(...t),r.properties.neighboursLeadingTo=o}else{r.properties.neighbours.push(this.corridorLinePointPairs[p][1]);// include only intersection points before this point
+let e=this._distance(r,this.corridorLinePointPairs[p][0]),o=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])<=e),t=i.properties.intersectionPointList.filter(r=>this._distance(r,this.corridorLinePointPairs[p][0])>e);r.properties.neighbours.push(...o),r.properties.neighboursLeadingTo=t}// Wall is closer
 }else if(null!==o){// Create fixed point inside area
-const i=turf.nearestPointOnLine(o,e),s=turf.bearing(e,i);r=turf.destination(e.geometry.coordinates,t+.05,s,this.UNIT_TYPE)}// Mark level of fixed point
+let i=turf.nearestPointOnLine(o,e),s=turf.bearing(e,i);r=turf.destination(e.geometry.coordinates,t+.05,s,{units:"meters"})}// Mark level of fixed point
 // Return created point
 return r.properties.level=e.properties.level,r}}/**
    * @param point {Feature <Point>}

package/lib/components/map/main.js

@@ -2330,7 +2330,6 @@ export class Map {
                     this.amenityIds.push(featureVar.id);
                     this.filteredAmenities.push(featureVar.id);
                 }
-                this.filterOutFeatures();
                 this.geojsonSource.update(featureVar);
             }
             if (!isTemporary) {
@@ -2339,6 +2338,7 @@ export class Map {
                     features: featureVars.map((f) => f.JsonDynamicStrip),
                 });
             }
+            this.filterOutFeatures();
             this.onFeaturesChange();
             this.onFeatureUpdateListener.next(featureVars);
             return featureVars;
@@ -3704,9 +3704,7 @@ export class Map {
                         startTime = currentTime;
                     const elapsedTime = currentTime - startTime;
                     const t = elapsedTime / (totalDuration > 0 ? totalDuration : 3);
-                    console.log('animate the position', t, elapsedTime, totalDuration);
                     if (t >= 1) {
-                        console.log('t >= 1, should continue on next step');
                         if (!this.useCustomPosition) {
                             // Stop the animation if we reached the end
                             if (this.defaultOptions.routeAnimation.looping &&

package/lib/controllers/geo.js

@@ -105,7 +105,7 @@ export const getFeatures = ({ initPolygons, polygonLayers, autoLabelLines, hidde
             };
         }
     }
-    originalFeatures = Object.assign({}, res.data);
+    originalFeatures = JSON.parse(JSON.stringify(res.data));
     if (polygonBufferDistance !== 0 && (polygonTypesToScale === null || polygonTypesToScale === void 0 ? void 0 : polygonTypesToScale.length) > 0) {
         res.data.features = res.data.features.map((feature) => {
             try {
@@ -123,7 +123,7 @@ export const getFeatures = ({ initPolygons, polygonLayers, autoLabelLines, hidde
         });
     }
     res.data.features = res.data.features.map((feature) => {
-        feature.geometry.coordinates = shortenCoordinates({ coords: feature.geometry.coordinates, decimals: 8 });
+        feature.geometry.coordinates = shortenCoordinates({ coords: feature.geometry.coordinates, decimals: 10 });
         rewind(feature, false);
         return feature;
     });