@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/map/shared/controllers/geolocation.mjs

@@ -0,0 +1,431 @@
+import { BehaviorSubject, interval } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import olGeolocation from 'ol/Geolocation';
+import * as olproj from 'ol/proj';
+import olFeature from 'ol/Feature';
+import { MapController } from './controller';
+import { Point } from 'ol/geom';
+import { fromCircle } from 'ol/geom/Polygon';
+import * as olSphere from 'ol/sphere';
+import OlCircle from 'ol/geom/Circle';
+import * as olstyle from 'ol/style';
+import { Overlay } from '../../../overlay/shared/overlay';
+import { FeatureMotion } from '../../../feature/shared/feature.enums';
+import { computeOlFeaturesExtent, featuresAreOutOfView, hideOlFeature, moveToOlFeatures } from '../../../feature/shared/feature.utils';
+import { GeolocationOverlayType } from './geolocation.interface';
+/**
+ * Controller to handle map view interactions
+ */
+export class MapGeolocationController extends MapController {
+    map;
+    options;
+    storageService;
+    configService;
+    arrowRotation;
+    subscriptions$$ = [];
+    geolocationOverlay;
+    positionFeatureStyle = new olstyle.Style({
+        image: new olstyle.Circle({
+            radius: 6,
+            fill: new olstyle.Fill({
+                color: '#3399CC'
+            }),
+            stroke: new olstyle.Stroke({
+                color: '#fff',
+                width: 2
+            })
+        })
+    });
+    accuracyFeatureStyle = new olstyle.Style({
+        stroke: new olstyle.Stroke({
+            color: 'rgba(120, 120, 120, 0.4)',
+            width: 1
+        }),
+        fill: new olstyle.Fill({
+            color: 'rgba(120, 120, 120, 0.4)'
+        })
+    });
+    get bufferStyle() {
+        return new olstyle.Style({
+            stroke: new olstyle.Stroke({ width: 2, color: this.buffer.bufferStroke }),
+            fill: new olstyle.Fill({ color: this.buffer.bufferFill }),
+            text: new olstyle.Text({
+                textAlign: 'left',
+                offsetX: 10,
+                offsetY: -10,
+                font: '12px Calibri,sans-serif',
+                text: this.buffer.showBufferRadius
+                    ? `${this.buffer.bufferRadius}m`
+                    : '',
+                fill: new olstyle.Fill({ color: '#000' }),
+                stroke: new olstyle.Stroke({ color: '#fff', width: 3 })
+            })
+        });
+    }
+    get arrowStyle() {
+        return new olstyle.Style({
+            image: new olstyle.RegularShape({
+                radius: 5.5,
+                fill: new olstyle.Fill({
+                    color: 'rgba(0, 132, 202)'
+                }),
+                stroke: new olstyle.Stroke({
+                    color: '#fff',
+                    width: 1.5
+                }),
+                points: 3,
+                displacement: [0, 9],
+                rotation: this.arrowRotation,
+                rotateWithView: true
+            })
+        });
+    }
+    geolocation;
+    /**
+     * Observable of the current emission interval of the position. In seconds
+     */
+    emissionIntervalSeconds$ = new BehaviorSubject(5);
+    /**
+     * Observable of the current position
+     */
+    position$ = new BehaviorSubject(undefined);
+    /**
+     * Observable of the tracking state
+     */
+    tracking$ = new BehaviorSubject(undefined);
+    /**
+     * Observable of the follow position state
+     */
+    followPosition$ = new BehaviorSubject(undefined);
+    lastPosition;
+    /**
+     * Whether the geolocate should show a buffer around the current position
+     */
+    set buffer(value) {
+        this._buffer = value;
+        this.handleFeatureCreation(this.position$.value);
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    _buffer;
+    /**
+     * Whether the geolocate controller accuracy threshold to store/show the position.
+     */
+    set accuracyThreshold(value) {
+        this._accuracyThreshold = value;
+        this.handleFeatureCreation(this.position$.value);
+    }
+    get accuracyThreshold() {
+        return this._accuracyThreshold;
+    }
+    _accuracyThreshold;
+    get olGeolocation() {
+        return this.geolocation;
+    }
+    /**
+     * Whether the activate the geolocation.
+     */
+    get tracking() {
+        return this.geolocation.getTracking();
+    }
+    set tracking(value) {
+        this.geolocation.setTracking(value || false);
+        this.tracking$.next(value);
+        if (this.storageService && value !== undefined) {
+            this.storageService.set('geolocation.tracking', value);
+        }
+        if (!value) {
+            this.position$.next(undefined);
+        }
+    }
+    /**
+     * Whether the activate the view tracking of the current position
+     */
+    set followPosition(value) {
+        this._followPosition = value;
+        this.followPosition$.next(value);
+        if (this.configService?.getConfig('geolocate.followPosition') === false) {
+            this._followPosition = false;
+            this.followPosition$.next(false);
+        }
+        this.handleFeatureCreation(this.position$.value);
+        if (this.storageService && value !== undefined) {
+            this.storageService.set('geolocation.followPosition', value);
+        }
+    }
+    get followPosition() {
+        return this._followPosition;
+    }
+    _followPosition;
+    constructor(map, options, storageService, configService) {
+        super();
+        this.map = map;
+        this.options = options;
+        this.storageService = storageService;
+        this.configService = configService;
+        this.geolocationOverlay = new Overlay(this.map);
+        this._followPosition =
+            this.options && this.options.followPosition
+                ? this.options.followPosition
+                : false;
+        this._buffer =
+            this.options && this.options.buffer ? this.options.buffer : undefined;
+        this._accuracyThreshold =
+            this.options && this.options.accuracyThreshold
+                ? this.options.accuracyThreshold
+                : 5000;
+    }
+    /**
+     * Add or remove this controller to/from a map.
+     * @param map OL Map
+     */
+    setOlMap(olMap) {
+        super.setOlMap(olMap);
+        this.setupObservers();
+    }
+    deleteGeolocationFeatures() {
+        this.deleteFeatureByType(GeolocationOverlayType.Position);
+        this.deleteFeatureByType(GeolocationOverlayType.PositionDirection);
+        this.deleteFeatureByType(GeolocationOverlayType.Accuracy);
+        this.deleteFeatureByType(GeolocationOverlayType.Buffer);
+    }
+    setupObservers() {
+        this.tracking$.subscribe((tracking) => {
+            if (tracking) {
+                this.onPositionChange(true, true);
+            }
+            else {
+                this.deleteGeolocationFeatures();
+            }
+        });
+        this.geolocation = new olGeolocation({
+            // enableHighAccuracy must be set to true to have the heading value.
+            trackingOptions: {
+                enableHighAccuracy: true,
+                maximumAge: 10000,
+                timeout: 600000
+            },
+            projection: this.options.projection
+        });
+        let tracking = false;
+        this.subscriptions$$.push(this.emissionIntervalSeconds$
+            .pipe(switchMap((value) => interval(value * 1000)))
+            .subscribe(() => {
+            if (tracking === this.tracking) {
+                this.onPositionChange(true);
+            }
+            else {
+                tracking = this.tracking;
+                this.onPositionChange(true, true);
+            }
+        }));
+        this.geolocation.on('change', (evt) => {
+            this.onPositionChange(false, false);
+        });
+    }
+    updateArrowFeatureOrientation(position) {
+        const position4326 = olproj.transform(position.position, position.projection, 'EPSG:4326');
+        if (!this.lastPosition) {
+            this.lastPosition = { coordinates: position4326, dateTime: new Date() };
+            return;
+        }
+        const arrowFeature = this.getFeatureByType(GeolocationOverlayType.PositionDirection);
+        const isMoving = position?.speed > 1.25 &&
+            this.distanceBetweenPoints(this.lastPosition.coordinates, position4326) >
+                0.003;
+        if (position.accuracy <= this.accuracyThreshold && isMoving) {
+            // Calculate the heading using current position and last recorded
+            // because ol heading not returning right value
+            var dx = position4326[1] - this.lastPosition.coordinates[1];
+            var dy = position4326[0] - this.lastPosition.coordinates[0];
+            var theta = Math.atan2(dy, dx);
+            if (theta < 0)
+                theta = 2 * Math.PI + theta;
+            this.arrowRotation = theta;
+            if (arrowFeature) {
+                arrowFeature.setStyle(this.arrowStyle);
+            }
+            this.lastPosition = { coordinates: position4326, dateTime: new Date() };
+        }
+        else {
+            if (arrowFeature &&
+                new Date().getTime() - this.lastPosition.dateTime.getTime() > 3000)
+                hideOlFeature(arrowFeature);
+        }
+    }
+    /**
+     * @returns distance in km between coord1 and coord2
+     */
+    distanceBetweenPoints(coord1, coord2) {
+        return olSphere.getDistance(coord1, coord2) / 1000;
+    }
+    addOnChangedListener(event) {
+        let listener = () => {
+            event(this.geolocation);
+        };
+        this.geolocation.on('change', listener);
+        return listener;
+    }
+    deleteChangedListener(event) {
+        this.geolocation.un('change', event);
+    }
+    updateGeolocationOptions(options) {
+        if (!options) {
+            return;
+        }
+        // todo maybe a dedicated interface for geolocation should be defined instead of putting these inside the mapviewoptions?
+        let tracking = options.geolocate;
+        let followPosition = options.alwaysTracking;
+        if (this.storageService) {
+            const storedTracking = this.storageService.get('geolocation.tracking');
+            if (storedTracking !== null && storedTracking !== undefined) {
+                tracking = storedTracking;
+            }
+            const storedFollowPosition = this.storageService.get('geolocation.followPosition');
+            if (storedFollowPosition !== null && storedFollowPosition !== undefined) {
+                followPosition = storedFollowPosition;
+            }
+        }
+        this.tracking = tracking;
+        this.followPosition = followPosition;
+        this.buffer = options.buffer;
+    }
+    /**
+     * Teardown any observers
+     */
+    teardownObservers() {
+        if (this.subscriptions$$.length) {
+            this.subscriptions$$.map((s) => s.unsubscribe());
+        }
+        super.teardownObservers();
+    }
+    /**
+     * On position change, get the position, show it on the map and record it.
+     * @param emitEvent Map event
+     */
+    onPositionChange(emitEvent = false, zoomTo = false) {
+        if (!this.tracking) {
+            return;
+        }
+        const geolocateProperties = this.geolocation.getProperties();
+        if (geolocateProperties.accuracy > this.accuracyThreshold) {
+            console.warn('Poor geolocation accuracy. No position are stored/shown');
+            this.position$.next(undefined);
+            return;
+        }
+        const position = {
+            position: geolocateProperties.position,
+            projection: this.geolocation.getProjection().getCode(),
+            accuracy: geolocateProperties.accuracy,
+            altitude: geolocateProperties.altitude,
+            altitudeAccuracy: geolocateProperties.altitudeAccuracy,
+            heading: geolocateProperties.heading,
+            speed: geolocateProperties.speed,
+            enableHighAccuracy: geolocateProperties.trackingOptions
+                ?.enableHighAccuracy
+                ? true
+                : false,
+            timestamp: new Date()
+        };
+        this.handleFeatureCreation(position);
+        this.handleViewFromFeatures(position, zoomTo);
+        if (emitEvent) {
+            this.position$.next(position);
+        }
+    }
+    getFeatureByType(type) {
+        return this.geolocationOverlay.dataSource.ol.getFeatureById(type);
+    }
+    deleteFeatureByType(type) {
+        const featureById = this.geolocationOverlay?.dataSource.ol.getFeatureById(type);
+        if (featureById) {
+            this.geolocationOverlay.dataSource.ol.removeFeature(featureById);
+        }
+    }
+    handleFeatureCreation(position) {
+        if (!position || !position.position) {
+            return;
+        }
+        const positionGeometry = new Point(position.position);
+        const accuracyGeometry = fromCircle(new OlCircle(position.position, position.accuracy || 0));
+        let positionFeature = this.getFeatureByType(GeolocationOverlayType.Position);
+        let positionFeatureArrow = this.getFeatureByType(GeolocationOverlayType.PositionDirection);
+        let accuracyFeature = this.getFeatureByType(GeolocationOverlayType.Accuracy);
+        const positionFeatureExists = positionFeature ? true : false;
+        const positionFeatureArrowExists = positionFeatureArrow ? true : false;
+        const accuracyFeatureExists = accuracyFeature ? true : false;
+        if (!positionFeatureArrowExists) {
+            positionFeatureArrow = new olFeature({
+                geometry: positionGeometry
+            });
+            positionFeatureArrow.setId(GeolocationOverlayType.PositionDirection);
+            hideOlFeature(positionFeatureArrow);
+        }
+        if (!positionFeatureExists) {
+            positionFeature = new olFeature({ geometry: positionGeometry });
+            positionFeature.setId(GeolocationOverlayType.Position);
+            positionFeature.setStyle(this.positionFeatureStyle);
+        }
+        if (!accuracyFeatureExists) {
+            accuracyFeature = new olFeature({ geometry: accuracyGeometry });
+            accuracyFeature.setId(GeolocationOverlayType.Accuracy);
+            accuracyFeature.setStyle(this.accuracyFeatureStyle);
+        }
+        if (positionGeometry) {
+            positionFeatureExists
+                ? positionFeature.setGeometry(positionGeometry)
+                : this.geolocationOverlay.addOlFeature(positionFeature, FeatureMotion.None);
+            positionFeatureArrowExists
+                ? positionFeatureArrow.setGeometry(positionGeometry)
+                : this.geolocationOverlay.addOlFeature(positionFeatureArrow, FeatureMotion.None);
+            this.updateArrowFeatureOrientation(position);
+            accuracyFeatureExists
+                ? accuracyFeature.setGeometry(accuracyGeometry)
+                : this.geolocationOverlay.addOlFeature(accuracyFeature, FeatureMotion.None);
+            if (this.buffer) {
+                let bufferFeature = this.getFeatureByType(GeolocationOverlayType.Buffer);
+                const bufferFeatureExists = bufferFeature ? true : false;
+                const bufferGeometry = new OlCircle(position.position, this.buffer.bufferRadius);
+                if (!bufferFeatureExists) {
+                    bufferFeature = new olFeature(bufferGeometry);
+                    bufferFeature.setId(GeolocationOverlayType.Buffer);
+                    bufferFeature.setStyle(this.positionFeatureStyle);
+                }
+                bufferFeature.setStyle(this.bufferStyle);
+                bufferFeatureExists
+                    ? bufferFeature.setGeometry(bufferGeometry)
+                    : this.geolocationOverlay.addOlFeature(bufferFeature, FeatureMotion.None);
+            }
+        }
+    }
+    handleViewFromFeatures(position, zoomTo = false) {
+        let positionFeature = this.getFeatureByType(GeolocationOverlayType.Position);
+        let positionFeatureArrow = this.getFeatureByType(GeolocationOverlayType.PositionDirection);
+        let accuracyFeature = this.getFeatureByType(GeolocationOverlayType.Accuracy);
+        let bufferFeature = this.getFeatureByType(GeolocationOverlayType.Buffer);
+        const features = [
+            positionFeature,
+            positionFeatureArrow,
+            accuracyFeature,
+            bufferFeature
+        ].filter((f) => f);
+        if (features.length > 0) {
+            const featuresExtent = computeOlFeaturesExtent(features, this.map.viewProjection);
+            const edgeRatios = position?.speed > 12.5
+                ? [0.25, 0.25, 0.25, 0.25]
+                : [0.15, 0.1, 0.1, 0.1];
+            const areOutOfView = featuresAreOutOfView(this.map.getExtent(), featuresExtent, edgeRatios);
+            let motion = this.followPosition && areOutOfView
+                ? FeatureMotion.Move
+                : FeatureMotion.None;
+            if (zoomTo) {
+                motion = FeatureMotion.Zoom;
+            }
+            motion !== FeatureMotion.None
+                ? moveToOlFeatures(this.map.viewController, features, motion)
+                : undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geolocation.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/map/shared/controllers/geolocation.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, interval, Subscription } from 'rxjs';\nimport { switchMap } from 'rxjs/operators';\nimport OlMap from 'ol/Map';\nimport olGeolocation from 'ol/Geolocation';\nimport Geometry from 'ol/geom/Geometry';\nimport * as olproj from 'ol/proj';\nimport olFeature from 'ol/Feature';\nimport { MapController } from './controller';\nimport { Point, Polygon } from 'ol/geom';\nimport { fromCircle } from 'ol/geom/Polygon';\nimport * as olSphere from 'ol/sphere';\nimport OlCircle from 'ol/geom/Circle';\nimport * as olstyle from 'ol/style';\nimport { StorageService, ConfigService } from '@igo2/core';\nimport { Overlay } from '../../../overlay/shared/overlay';\nimport { FeatureMotion } from '../../../feature/shared/feature.enums';\nimport { MapViewOptions } from '../map.interface';\nimport { MapBase } from '../map.abstract';\nimport {\n  computeOlFeaturesExtent,\n  featuresAreOutOfView,\n  hideOlFeature,\n  moveToOlFeatures\n} from '../../../feature/shared/feature.utils';\nimport {\n  GeolocationBuffer,\n  GeolocationOverlayType,\n  MapGeolocationControllerOptions,\n  MapGeolocationState\n} from './geolocation.interface';\n\n/**\n * Controller to handle map view interactions\n */\nexport class MapGeolocationController extends MapController {\n  private arrowRotation: number;\n  private subscriptions$$: Subscription[] = [];\n  private geolocationOverlay: Overlay;\n  private positionFeatureStyle: olstyle.Style | olstyle.Style[] =\n    new olstyle.Style({\n      image: new olstyle.Circle({\n        radius: 6,\n        fill: new olstyle.Fill({\n          color: '#3399CC'\n        }),\n        stroke: new olstyle.Stroke({\n          color: '#fff',\n          width: 2\n        })\n      })\n    });\n  private accuracyFeatureStyle: olstyle.Style | olstyle.Style[] =\n    new olstyle.Style({\n      stroke: new olstyle.Stroke({\n        color: 'rgba(120, 120, 120, 0.4)',\n        width: 1\n      }),\n      fill: new olstyle.Fill({\n        color: 'rgba(120, 120, 120, 0.4)'\n      })\n    });\n\n  private get bufferStyle(): olstyle.Style {\n    return new olstyle.Style({\n      stroke: new olstyle.Stroke({ width: 2, color: this.buffer.bufferStroke }),\n      fill: new olstyle.Fill({ color: this.buffer.bufferFill }),\n      text: new olstyle.Text({\n        textAlign: 'left',\n        offsetX: 10,\n        offsetY: -10,\n        font: '12px Calibri,sans-serif',\n        text: this.buffer.showBufferRadius\n          ? `${this.buffer.bufferRadius}m`\n          : '',\n        fill: new olstyle.Fill({ color: '#000' }),\n        stroke: new olstyle.Stroke({ color: '#fff', width: 3 })\n      })\n    });\n  }\n\n  private get arrowStyle(): olstyle.Style {\n    return new olstyle.Style({\n      image: new olstyle.RegularShape({\n        radius: 5.5,\n        fill: new olstyle.Fill({\n          color: 'rgba(0, 132, 202)'\n        }),\n        stroke: new olstyle.Stroke({\n          color: '#fff',\n          width: 1.5\n        }),\n        points: 3,\n        displacement: [0, 9],\n        rotation: this.arrowRotation,\n        rotateWithView: true\n      })\n    });\n  }\n\n  private geolocation: olGeolocation;\n\n  /**\n   * Observable of the current emission interval of the position. In seconds\n   */\n  public readonly emissionIntervalSeconds$: BehaviorSubject<number> =\n    new BehaviorSubject(5);\n\n  /**\n   * Observable of the current position\n   */\n  public readonly position$ = new BehaviorSubject<MapGeolocationState>(\n    undefined\n  );\n  /**\n   * Observable of the tracking state\n   */\n  public readonly tracking$ = new BehaviorSubject<boolean>(undefined);\n  /**\n   * Observable of the follow position state\n   */\n  public readonly followPosition$ = new BehaviorSubject<boolean>(undefined);\n\n  private lastPosition: { coordinates: number[]; dateTime: Date };\n\n  /**\n   * Whether the geolocate should show a buffer around the current position\n   */\n  set buffer(value: GeolocationBuffer) {\n    this._buffer = value;\n    this.handleFeatureCreation(this.position$.value);\n  }\n  get buffer(): GeolocationBuffer {\n    return this._buffer;\n  }\n  private _buffer: GeolocationBuffer;\n\n  /**\n   * Whether the geolocate controller accuracy threshold to store/show the position.\n   */\n  set accuracyThreshold(value: number) {\n    this._accuracyThreshold = value;\n    this.handleFeatureCreation(this.position$.value);\n  }\n\n  get accuracyThreshold(): number {\n    return this._accuracyThreshold;\n  }\n  private _accuracyThreshold;\n\n  get olGeolocation() {\n    return this.geolocation;\n  }\n\n  /**\n   * Whether the activate the geolocation.\n   */\n  get tracking() {\n    return this.geolocation.getTracking();\n  }\n\n  set tracking(value: boolean) {\n    this.geolocation.setTracking(value || false);\n    this.tracking$.next(value);\n    if (this.storageService && value !== undefined) {\n      this.storageService.set('geolocation.tracking', value);\n    }\n    if (!value) {\n      this.position$.next(undefined);\n    }\n  }\n\n  /**\n   * Whether the activate the view tracking of the current position\n   */\n  set followPosition(value: boolean) {\n    this._followPosition = value;\n    this.followPosition$.next(value);\n    if (this.configService?.getConfig('geolocate.followPosition') === false) {\n      this._followPosition = false;\n      this.followPosition$.next(false);\n    }\n    this.handleFeatureCreation(this.position$.value);\n    if (this.storageService && value !== undefined) {\n      this.storageService.set('geolocation.followPosition', value);\n    }\n  }\n\n  get followPosition() {\n    return this._followPosition;\n  }\n\n  private _followPosition;\n\n  constructor(\n    private map: MapBase,\n    private options?: MapGeolocationControllerOptions,\n    private storageService?: StorageService,\n    private configService?: ConfigService\n  ) {\n    super();\n    this.geolocationOverlay = new Overlay(this.map);\n    this._followPosition =\n      this.options && this.options.followPosition\n        ? this.options.followPosition\n        : false;\n\n    this._buffer =\n      this.options && this.options.buffer ? this.options.buffer : undefined;\n    this._accuracyThreshold =\n      this.options && this.options.accuracyThreshold\n        ? this.options.accuracyThreshold\n        : 5000;\n  }\n\n  /**\n   * Add or remove this controller to/from a map.\n   * @param map OL Map\n   */\n  setOlMap(olMap: OlMap | undefined) {\n    super.setOlMap(olMap);\n    this.setupObservers();\n  }\n\n  private deleteGeolocationFeatures() {\n    this.deleteFeatureByType(GeolocationOverlayType.Position);\n    this.deleteFeatureByType(GeolocationOverlayType.PositionDirection);\n    this.deleteFeatureByType(GeolocationOverlayType.Accuracy);\n    this.deleteFeatureByType(GeolocationOverlayType.Buffer);\n  }\n\n  setupObservers() {\n    this.tracking$.subscribe((tracking) => {\n      if (tracking) {\n        this.onPositionChange(true, true);\n      } else {\n        this.deleteGeolocationFeatures();\n      }\n    });\n\n    this.geolocation = new olGeolocation({\n      // enableHighAccuracy must be set to true to have the heading value.\n      trackingOptions: {\n        enableHighAccuracy: true,\n        maximumAge: 10000,\n        timeout: 600000\n      },\n      projection: this.options.projection\n    });\n    let tracking = false;\n    this.subscriptions$$.push(\n      this.emissionIntervalSeconds$\n        .pipe(switchMap((value) => interval(value * 1000)))\n        .subscribe(() => {\n          if (tracking === this.tracking) {\n            this.onPositionChange(true);\n          } else {\n            tracking = this.tracking;\n            this.onPositionChange(true, true);\n          }\n        })\n    );\n\n    this.geolocation.on('change', (evt) => {\n      this.onPositionChange(false, false);\n    });\n  }\n\n  updateArrowFeatureOrientation(position: MapGeolocationState) {\n    const position4326 = olproj.transform(\n      position.position,\n      position.projection,\n      'EPSG:4326'\n    );\n    if (!this.lastPosition) {\n      this.lastPosition = { coordinates: position4326, dateTime: new Date() };\n      return;\n    }\n    const arrowFeature = this.getFeatureByType(\n      GeolocationOverlayType.PositionDirection\n    );\n    const isMoving =\n      position?.speed > 1.25 &&\n      this.distanceBetweenPoints(this.lastPosition.coordinates, position4326) >\n        0.003;\n    if (position.accuracy <= this.accuracyThreshold && isMoving) {\n      // Calculate the heading using current position and last recorded\n      // because ol heading not returning right value\n      var dx = position4326[1] - this.lastPosition.coordinates[1];\n      var dy = position4326[0] - this.lastPosition.coordinates[0];\n      var theta = Math.atan2(dy, dx);\n      if (theta < 0) theta = 2 * Math.PI + theta;\n      this.arrowRotation = theta;\n      if (arrowFeature) {\n        arrowFeature.setStyle(this.arrowStyle);\n      }\n      this.lastPosition = { coordinates: position4326, dateTime: new Date() };\n    } else {\n      if (\n        arrowFeature &&\n        new Date().getTime() - this.lastPosition.dateTime.getTime() > 3000\n      )\n        hideOlFeature(arrowFeature);\n    }\n  }\n\n  /**\n   * @returns distance in km between coord1 and coord2\n   */\n  private distanceBetweenPoints(coord1: number[], coord2: number[]): number {\n    return olSphere.getDistance(coord1, coord2) / 1000;\n  }\n\n  public addOnChangedListener(event: (geo: olGeolocation) => any) {\n    let listener = () => {\n      event(this.geolocation);\n    };\n    this.geolocation.on('change', listener);\n    return listener;\n  }\n\n  public deleteChangedListener(event: () => any) {\n    this.geolocation.un('change', event);\n  }\n\n  public updateGeolocationOptions(options: MapViewOptions) {\n    if (!options) {\n      return;\n    }\n    // todo maybe a dedicated interface for geolocation should be defined instead of putting these inside the mapviewoptions?\n    let tracking = options.geolocate;\n    let followPosition = options.alwaysTracking;\n    if (this.storageService) {\n      const storedTracking = this.storageService.get(\n        'geolocation.tracking'\n      ) as boolean;\n      if (storedTracking !== null && storedTracking !== undefined) {\n        tracking = storedTracking;\n      }\n\n      const storedFollowPosition = this.storageService.get(\n        'geolocation.followPosition'\n      ) as boolean;\n      if (storedFollowPosition !== null && storedFollowPosition !== undefined) {\n        followPosition = storedFollowPosition;\n      }\n    }\n    this.tracking = tracking;\n    this.followPosition = followPosition;\n    this.buffer = options.buffer;\n  }\n\n  /**\n   * Teardown any observers\n   */\n  teardownObservers() {\n    if (this.subscriptions$$.length) {\n      this.subscriptions$$.map((s) => s.unsubscribe());\n    }\n    super.teardownObservers();\n  }\n\n  /**\n   * On position change, get the position, show it on the map and record it.\n   * @param emitEvent Map event\n   */\n  private onPositionChange(\n    emitEvent: boolean = false,\n    zoomTo: boolean = false\n  ) {\n    if (!this.tracking) {\n      return;\n    }\n    const geolocateProperties = this.geolocation.getProperties();\n\n    if (geolocateProperties.accuracy > this.accuracyThreshold) {\n      console.warn('Poor geolocation accuracy. No position are stored/shown');\n      this.position$.next(undefined);\n      return;\n    }\n\n    const position: MapGeolocationState = {\n      position: geolocateProperties.position,\n      projection: this.geolocation.getProjection().getCode(),\n      accuracy: geolocateProperties.accuracy,\n      altitude: geolocateProperties.altitude,\n      altitudeAccuracy: geolocateProperties.altitudeAccuracy,\n      heading: geolocateProperties.heading,\n      speed: geolocateProperties.speed,\n      enableHighAccuracy: geolocateProperties.trackingOptions\n        ?.enableHighAccuracy\n        ? true\n        : false,\n      timestamp: new Date()\n    };\n    this.handleFeatureCreation(position);\n    this.handleViewFromFeatures(position, zoomTo);\n    if (emitEvent) {\n      this.position$.next(position);\n    }\n  }\n\n  private getFeatureByType(type: GeolocationOverlayType): olFeature<Geometry> {\n    return this.geolocationOverlay.dataSource.ol.getFeatureById(type);\n  }\n\n  private deleteFeatureByType(type: GeolocationOverlayType) {\n    const featureById =\n      this.geolocationOverlay?.dataSource.ol.getFeatureById(type);\n    if (featureById) {\n      this.geolocationOverlay.dataSource.ol.removeFeature(featureById);\n    }\n  }\n\n  private handleFeatureCreation(position: MapGeolocationState) {\n    if (!position || !position.position) {\n      return;\n    }\n    const positionGeometry = new Point(position.position);\n    const accuracyGeometry = fromCircle(\n      new OlCircle(position.position, position.accuracy || 0)\n    );\n    let positionFeature = this.getFeatureByType(\n      GeolocationOverlayType.Position\n    );\n    let positionFeatureArrow = this.getFeatureByType(\n      GeolocationOverlayType.PositionDirection\n    );\n    let accuracyFeature = this.getFeatureByType(\n      GeolocationOverlayType.Accuracy\n    );\n    const positionFeatureExists = positionFeature ? true : false;\n    const positionFeatureArrowExists = positionFeatureArrow ? true : false;\n    const accuracyFeatureExists = accuracyFeature ? true : false;\n    if (!positionFeatureArrowExists) {\n      positionFeatureArrow = new olFeature<Point>({\n        geometry: positionGeometry\n      });\n      positionFeatureArrow.setId(GeolocationOverlayType.PositionDirection);\n      hideOlFeature(positionFeatureArrow);\n    }\n    if (!positionFeatureExists) {\n      positionFeature = new olFeature<Point>({ geometry: positionGeometry });\n      positionFeature.setId(GeolocationOverlayType.Position);\n      positionFeature.setStyle(this.positionFeatureStyle);\n    }\n    if (!accuracyFeatureExists) {\n      accuracyFeature = new olFeature<Polygon>({ geometry: accuracyGeometry });\n      accuracyFeature.setId(GeolocationOverlayType.Accuracy);\n      accuracyFeature.setStyle(this.accuracyFeatureStyle);\n    }\n\n    if (positionGeometry) {\n      positionFeatureExists\n        ? positionFeature.setGeometry(positionGeometry)\n        : this.geolocationOverlay.addOlFeature(\n            positionFeature,\n            FeatureMotion.None\n          );\n      positionFeatureArrowExists\n        ? positionFeatureArrow.setGeometry(positionGeometry)\n        : this.geolocationOverlay.addOlFeature(\n            positionFeatureArrow,\n            FeatureMotion.None\n          );\n      this.updateArrowFeatureOrientation(position);\n      accuracyFeatureExists\n        ? accuracyFeature.setGeometry(accuracyGeometry)\n        : this.geolocationOverlay.addOlFeature(\n            accuracyFeature,\n            FeatureMotion.None\n          );\n\n      if (this.buffer) {\n        let bufferFeature = this.getFeatureByType(\n          GeolocationOverlayType.Buffer\n        );\n        const bufferFeatureExists = bufferFeature ? true : false;\n        const bufferGeometry = new OlCircle(\n          position.position,\n          this.buffer.bufferRadius\n        );\n        if (!bufferFeatureExists) {\n          bufferFeature = new olFeature(bufferGeometry);\n          bufferFeature.setId(GeolocationOverlayType.Buffer);\n          bufferFeature.setStyle(this.positionFeatureStyle);\n        }\n        bufferFeature.setStyle(this.bufferStyle);\n        bufferFeatureExists\n          ? bufferFeature.setGeometry(bufferGeometry)\n          : this.geolocationOverlay.addOlFeature(\n              bufferFeature,\n              FeatureMotion.None\n            );\n      }\n    }\n  }\n  handleViewFromFeatures(\n    position: MapGeolocationState,\n    zoomTo: boolean = false\n  ) {\n    let positionFeature = this.getFeatureByType(\n      GeolocationOverlayType.Position\n    );\n    let positionFeatureArrow = this.getFeatureByType(\n      GeolocationOverlayType.PositionDirection\n    );\n    let accuracyFeature = this.getFeatureByType(\n      GeolocationOverlayType.Accuracy\n    );\n    let bufferFeature = this.getFeatureByType(GeolocationOverlayType.Buffer);\n    const features = [\n      positionFeature,\n      positionFeatureArrow,\n      accuracyFeature,\n      bufferFeature\n    ].filter((f) => f);\n    if (features.length > 0) {\n      const featuresExtent = computeOlFeaturesExtent(\n        features,\n        this.map.viewProjection\n      );\n      const edgeRatios =\n        position?.speed > 12.5\n          ? [0.25, 0.25, 0.25, 0.25]\n          : [0.15, 0.1, 0.1, 0.1];\n      const areOutOfView = featuresAreOutOfView(\n        this.map.getExtent(),\n        featuresExtent,\n        edgeRatios\n      );\n      let motion =\n        this.followPosition && areOutOfView\n          ? FeatureMotion.Move\n          : FeatureMotion.None;\n      if (zoomTo) {\n        motion = FeatureMotion.Zoom;\n      }\n      motion !== FeatureMotion.None\n        ? moveToOlFeatures(this.map.viewController, features, motion)\n        : undefined;\n    }\n  }\n}\n"]}

package/esm2022/lib/map/shared/controllers/index.mjs

@@ -0,0 +1,5 @@
+export * from './controller';
+export * from './geolocation';
+export * from './geolocation.interface';
+export * from './view';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tYXAvc2hhcmVkL2NvbnRyb2xsZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRyb2xsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9nZW9sb2NhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2dlb2xvY2F0aW9uLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL3ZpZXcnO1xuIl19