@igo2/geo 18.0.1-next.2 → 18.0.2

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

@@ -0,0 +1,361 @@
+import * as oleasing from 'ol/easing';
+import * as olproj from 'ol/proj';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { MapViewAction } from '../map.enums';
+import { getScaleFromResolution, viewStatesAreEqual } from '../map.utils';
+import { MapController } from './controller';
+/**
+ * Controller to handle map view interactions
+ */
+export class MapViewController extends MapController {
+    options;
+    /**
+     * Observable of the current rotation in radians
+     */
+    rotation$ = new BehaviorSubject(0);
+    /**
+     * Observable of the current resolution
+     */
+    resolution$ = new BehaviorSubject(undefined);
+    /**
+     * Observable of the current state
+     */
+    state$ = new BehaviorSubject(undefined);
+    /**
+     * View Padding
+     * Values in the array are top, right, bottom and left padding.
+     */
+    padding = [0, 0, 0, 0];
+    /**
+     * Max zoom after set extent
+     */
+    maxZoomOnExtent = 19;
+    /**
+     * Max extent possible when zooming
+     */
+    maxLayerZoomExtent;
+    /**
+     * Extent stream
+     */
+    extent$ = new Subject();
+    /**
+     * Subscription to the movement stream
+     */
+    extent$$;
+    /**
+     * History of states
+     */
+    states = [];
+    /**
+     * Current state index
+     */
+    stateIndex = 0;
+    /**
+     * Whether the view controller should keep the view's state history
+     */
+    get stateHistory() {
+        return this.options ? this.options.stateHistory === true : false;
+    }
+    /**
+     * OL View
+     */
+    get olView() {
+        return this.olMap.getView();
+    }
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    setPadding(padding) {
+        // Values in the array are top, right, bottom and left padding.
+        if (padding.top || padding.top === 0) {
+            this.padding[0] = padding.top;
+        }
+        if (padding.right || padding.right === 0) {
+            this.padding[1] = padding.right;
+        }
+        if (padding.bottom || padding.bottom === 0) {
+            this.padding[2] = padding.bottom;
+        }
+        if (padding.left || padding.left === 0) {
+            this.padding[3] = padding.left;
+        }
+    }
+    /**
+     * Add or remove this controller to/from a map.
+     * @param map OL Map
+     */
+    setOlMap(olMap) {
+        super.setOlMap(olMap);
+        this.setupObservers();
+    }
+    /**
+     * Observe move moveend and subscribe to the extent stream
+     */
+    setupObservers() {
+        if (this.stateHistory === true) {
+            this.observerKeys.push(this.olMap.on('moveend', () => this.onMoveEnd()));
+        }
+        this.extent$$ = this.extent$
+            .pipe(debounceTime(25))
+            .subscribe((value) => {
+            this.setExtent(value.extent, value.action);
+        });
+    }
+    monitorRotation() {
+        this.observerKeys.push(this.olMap.getView().on('change:rotation', (evt) => {
+            this.rotation$.next(evt.target.getRotation());
+        }));
+        this.rotation$.next(this.getRotation());
+    }
+    /**
+     * Teardown any observers
+     */
+    teardownObservers() {
+        super.teardownObservers();
+        if (this.extent$$ !== undefined) {
+            this.extent$$.unsubscribe();
+            this.extent$$ = undefined;
+        }
+    }
+    /**
+     * Get the view's OL projection
+     * @returns OL projection
+     */
+    getOlProjection() {
+        return this.olView.getProjection();
+    }
+    /**
+     * Get the current map view center
+     * @param projection Output projection
+     * @returns Center
+     */
+    getCenter(projection) {
+        let center = this.olView.getCenter();
+        if (projection && center) {
+            center = olproj.transform(center, this.getOlProjection(), projection);
+        }
+        return center;
+    }
+    /**
+     * Get the current view extent
+     * @param projection Output projection
+     * @returns Extent
+     */
+    getExtent(projection) {
+        let extent = this.olView.calculateExtent(this.olMap.getSize());
+        if (projection && extent) {
+            extent = olproj.transformExtent(extent, this.getOlProjection(), projection);
+        }
+        return extent;
+    }
+    /**
+     * Get the current scale
+     * @param dpi Dot per inches
+     * @returns View scale
+     */
+    getScale(dpi = 96) {
+        return getScaleFromResolution(this.getResolution(), this.getOlProjection().getUnits(), dpi);
+    }
+    /**
+     * Get the current resolution
+     * @returns Projection denominator
+     */
+    getResolution() {
+        return this.olView.getResolution();
+    }
+    /**
+     * Get the current zoom level
+     * @returns Zoom level
+     */
+    getZoom() {
+        return Math.round(this.olView.getZoom());
+    }
+    /**
+     * Zoom in
+     */
+    zoomIn() {
+        this.zoomTo(this.olView.getZoom() + 1);
+    }
+    /**
+     * Zoom out
+     */
+    zoomOut() {
+        this.zoomTo(this.olView.getZoom() - 1);
+    }
+    /**
+     * Zoom to specific zoom level
+     * @param zoom Zoom level
+     */
+    zoomTo(zoom) {
+        this.olView.cancelAnimations();
+        this.olView.animate({
+            zoom,
+            duration: 250,
+            easing: oleasing.easeOut
+        });
+    }
+    /**
+     * Move to extent after a short delay (100ms) unless
+     * a new movement gets registered in the meantime.
+     * @param extent Extent to move to
+     */
+    moveToExtent(extent) {
+        this.extent$.next({ extent, action: MapViewAction.Move });
+    }
+    /**
+     * Zoom to extent after a short delay (100ms) unless
+     * a new movement gets registered in the meantime.
+     * @param extent Extent to zoom to
+     */
+    zoomToExtent(extent) {
+        this.extent$.next({ extent, action: MapViewAction.Zoom });
+    }
+    /**
+     * Return the current view rotation
+     * @returns Rotation angle in radians
+     */
+    getRotation() {
+        return this.olView.getRotation();
+    }
+    /**
+     * Reset the view rotation to 0
+     */
+    resetRotation() {
+        this.olView.animate({ rotation: 0 });
+    }
+    /**
+     * Whether the view has a previous state
+     * @returns True if the view has a previous state
+     */
+    hasPreviousState() {
+        return this.states.length > 1 && this.stateIndex > 0;
+    }
+    /**
+     * Whether the view has a next state
+     * @returns True if the view has a next state
+     */
+    hasNextState() {
+        return this.states.length > 1 && this.stateIndex < this.states.length - 1;
+    }
+    /**
+     * Restore the previous view state
+     */
+    previousState() {
+        if (this.hasPreviousState()) {
+            this.setStateIndex(this.stateIndex - 1);
+        }
+    }
+    /**
+     * Restore the next view state
+     */
+    nextState() {
+        if (this.hasNextState()) {
+            this.setStateIndex(this.stateIndex + 1);
+        }
+    }
+    /**
+     * Clear the state history
+     */
+    clearStateHistory() {
+        this.states = [];
+        this.stateIndex = 0;
+    }
+    /**
+     * Update the the view to it's intial state
+     */
+    setInitialState() {
+        if (this.states.length > 0) {
+            this.setStateIndex(0);
+        }
+    }
+    /**
+     * Move to the extent retrieved from the stream
+     * @param extent Extent
+     * @param action Either zoom or move
+     * @param animation With or without animation to the target extent.
+     */
+    setExtent(extent, action, animation = true) {
+        const olView = this.olView;
+        olView.cancelAnimations();
+        const duration = animation ? 500 : 0;
+        const zoom = olView.getZoom();
+        const fromCenter = olView.getCenter();
+        const toCenter = [
+            extent[0] + (extent[2] - extent[0]) / 2,
+            extent[1] + (extent[3] - extent[1]) / 2
+        ];
+        const distCenter = Math.sqrt(Math.pow(fromCenter[0] - toCenter[0], 2) +
+            Math.pow(fromCenter[1] - toCenter[1], 2));
+        const fromExtent = olView.calculateExtent();
+        const fromSize = Math.sqrt(Math.pow(fromExtent[2] - fromExtent[0], 2) +
+            Math.pow(fromExtent[3] - fromExtent[1], 2));
+        const toSize = Math.sqrt(Math.pow(extent[2] - extent[0], 2) + Math.pow(extent[3] - extent[1], 2));
+        const moySize = (toSize + fromSize) / 2;
+        const xSize = distCenter / moySize;
+        const maxZoom = action === MapViewAction.Move || zoom > this.maxZoomOnExtent
+            ? zoom
+            : this.maxZoomOnExtent;
+        olView.fit(extent, {
+            size: this.olMap.getSize(),
+            maxZoom,
+            padding: this.padding,
+            duration: xSize > 4 ? 0 : duration,
+            callback: (isFinished) => {
+                if (!isFinished) {
+                    olView.fit(extent, {
+                        size: this.olMap.getSize(),
+                        maxZoom,
+                        padding: this.padding,
+                        duration: xSize > 4 ? 0 : duration
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Set the view state index
+     * @param index State index
+     */
+    setStateIndex(index) {
+        this.stateIndex = index;
+        this.setState(this.states[index]);
+    }
+    /**
+     * Set the view state
+     * @param state View state
+     */
+    setState(state) {
+        this.olView.animate({
+            resolution: state.resolution,
+            center: state.center,
+            duration: 0
+        });
+    }
+    /**
+     * On move end, get the view state and record it.
+     * @param event Map event
+     */
+    onMoveEnd() {
+        const resolution = this.getResolution();
+        if (this.resolution$.value !== resolution) {
+            this.resolution$.next(resolution);
+        }
+        const state = {
+            resolution,
+            center: this.getCenter(),
+            zoom: this.getZoom()
+        };
+        if (this.stateHistory === true) {
+            const stateIndex = this.stateIndex;
+            const stateAtIndex = this.states.length === 0 ? undefined : this.states[stateIndex];
+            if (!viewStatesAreEqual(state, stateAtIndex)) {
+                this.states = this.states.slice(0, stateIndex + 1).concat([state]);
+                this.stateIndex = this.states.length - 1;
+            }
+        }
+        this.state$.next(state);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/map/shared/controllers/view.ts"],"names":[],"mappings":"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","sourcesContent":["import OlMap from 'ol/Map';\nimport { ObjectEvent } from 'ol/Object';\nimport OlView from 'ol/View';\nimport * as oleasing from 'ol/easing';\nimport { EventsKey } from 'ol/events';\nimport * as olproj from 'ol/proj';\nimport OlProjection from 'ol/proj/Projection';\n\nimport { BehaviorSubject, Subject, Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport { MapViewAction } from '../map.enums';\nimport { MapExtent, MapViewState } from '../map.interface';\nimport { getScaleFromResolution, viewStatesAreEqual } from '../map.utils';\nimport { MapController } from './controller';\n\nexport interface MapViewControllerOptions {\n  stateHistory: boolean;\n}\n\n/**\n * Controller to handle map view interactions\n */\nexport class MapViewController extends MapController {\n  /**\n   * Observable of the current rotation in radians\n   */\n  readonly rotation$ = new BehaviorSubject<number>(0);\n\n  /**\n   * Observable of the current resolution\n   */\n  resolution$ = new BehaviorSubject<number>(undefined);\n\n  /**\n   * Observable of the current state\n   */\n  state$ = new BehaviorSubject<MapViewState>(undefined);\n\n  /**\n   * View Padding\n   * Values in the array are top, right, bottom and left padding.\n   */\n  padding = [0, 0, 0, 0];\n\n  /**\n   * Max zoom after set extent\n   */\n  maxZoomOnExtent = 19;\n\n  /**\n   * Max extent possible when zooming\n   */\n  maxLayerZoomExtent: MapExtent;\n\n  /**\n   * Extent stream\n   */\n  private extent$ = new Subject<{ extent: MapExtent; action: MapViewAction }>();\n\n  /**\n   * Subscription to the movement stream\n   */\n  private extent$$: Subscription;\n\n  /**\n   * History of states\n   */\n  private states: MapViewState[] = [];\n\n  /**\n   * Current state index\n   */\n  private stateIndex = 0;\n\n  /**\n   * Whether the view controller should keep the view's state history\n   */\n  get stateHistory(): boolean {\n    return this.options ? this.options.stateHistory === true : false;\n  }\n\n  /**\n   * OL View\n   */\n  get olView(): OlView {\n    return this.olMap.getView();\n  }\n\n  constructor(private options?: MapViewControllerOptions) {\n    super();\n  }\n\n  setPadding(padding: {\n    top?: number;\n    bottom?: number;\n    left?: number;\n    right?: number;\n  }) {\n    // Values in the array are top, right, bottom and left padding.\n    if (padding.top || padding.top === 0) {\n      this.padding[0] = padding.top;\n    }\n    if (padding.right || padding.right === 0) {\n      this.padding[1] = padding.right;\n    }\n    if (padding.bottom || padding.bottom === 0) {\n      this.padding[2] = padding.bottom;\n    }\n    if (padding.left || padding.left === 0) {\n      this.padding[3] = padding.left;\n    }\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  /**\n   * Observe move moveend and subscribe to the extent stream\n   */\n  setupObservers() {\n    if (this.stateHistory === true) {\n      this.observerKeys.push(\n        this.olMap.on('moveend', () => this.onMoveEnd()) as EventsKey\n      );\n    }\n\n    this.extent$$ = this.extent$\n      .pipe(debounceTime(25))\n      .subscribe((value: { extent: MapExtent; action: MapViewAction }) => {\n        this.setExtent(value.extent, value.action);\n      });\n  }\n\n  monitorRotation() {\n    this.observerKeys.push(\n      this.olMap.getView().on('change:rotation', (evt: ObjectEvent) => {\n        this.rotation$.next(evt.target.getRotation());\n      }) as EventsKey\n    );\n    this.rotation$.next(this.getRotation());\n  }\n\n  /**\n   * Teardown any observers\n   */\n  teardownObservers() {\n    super.teardownObservers();\n    if (this.extent$$ !== undefined) {\n      this.extent$$.unsubscribe();\n      this.extent$$ = undefined;\n    }\n  }\n\n  /**\n   * Get the view's OL projection\n   * @returns OL projection\n   */\n  getOlProjection(): OlProjection {\n    return this.olView.getProjection();\n  }\n\n  /**\n   * Get the current map view center\n   * @param projection Output projection\n   * @returns Center\n   */\n  getCenter(projection?: string | OlProjection): [number, number] {\n    let center = this.olView.getCenter() as [number, number];\n    if (projection && center) {\n      center = olproj.transform(center, this.getOlProjection(), projection) as [\n        number,\n        number\n      ];\n    }\n    return center;\n  }\n\n  /**\n   * Get the current view extent\n   * @param projection Output projection\n   * @returns Extent\n   */\n  getExtent(projection?: string | OlProjection): MapExtent {\n    let extent = this.olView.calculateExtent(this.olMap.getSize());\n    if (projection && extent) {\n      extent = olproj.transformExtent(\n        extent,\n        this.getOlProjection(),\n        projection\n      );\n    }\n    return extent as MapExtent;\n  }\n\n  /**\n   * Get the current scale\n   * @param dpi Dot per inches\n   * @returns View scale\n   */\n  getScale(dpi = 96) {\n    return getScaleFromResolution(\n      this.getResolution(),\n      this.getOlProjection().getUnits(),\n      dpi\n    );\n  }\n\n  /**\n   * Get the current resolution\n   * @returns Projection denominator\n   */\n  getResolution(): number {\n    return this.olView.getResolution();\n  }\n\n  /**\n   * Get the current zoom level\n   * @returns Zoom level\n   */\n  getZoom(): number {\n    return Math.round(this.olView.getZoom());\n  }\n\n  /**\n   * Zoom in\n   */\n  zoomIn() {\n    this.zoomTo(this.olView.getZoom() + 1);\n  }\n\n  /**\n   * Zoom out\n   */\n  zoomOut() {\n    this.zoomTo(this.olView.getZoom() - 1);\n  }\n\n  /**\n   * Zoom to specific zoom level\n   * @param zoom Zoom level\n   */\n  zoomTo(zoom: number) {\n    this.olView.cancelAnimations();\n    this.olView.animate({\n      zoom,\n      duration: 250,\n      easing: oleasing.easeOut\n    });\n  }\n\n  /**\n   * Move to extent after a short delay (100ms) unless\n   * a new movement gets registered in the meantime.\n   * @param extent Extent to move to\n   */\n  moveToExtent(extent: [number, number, number, number]) {\n    this.extent$.next({ extent, action: MapViewAction.Move });\n  }\n\n  /**\n   * Zoom to extent after a short delay (100ms) unless\n   * a new movement gets registered in the meantime.\n   * @param extent Extent to zoom to\n   */\n  zoomToExtent(extent: [number, number, number, number]) {\n    this.extent$.next({ extent, action: MapViewAction.Zoom });\n  }\n\n  /**\n   * Return the current view rotation\n   * @returns Rotation angle in radians\n   */\n  getRotation(): number {\n    return this.olView.getRotation();\n  }\n\n  /**\n   * Reset the view rotation to 0\n   */\n  resetRotation() {\n    this.olView.animate({ rotation: 0 });\n  }\n\n  /**\n   * Whether the view has a previous state\n   * @returns True if the view has a previous state\n   */\n  hasPreviousState(): boolean {\n    return this.states.length > 1 && this.stateIndex > 0;\n  }\n\n  /**\n   * Whether the view has a next state\n   * @returns True if the view has a next state\n   */\n  hasNextState(): boolean {\n    return this.states.length > 1 && this.stateIndex < this.states.length - 1;\n  }\n\n  /**\n   * Restore the previous view state\n   */\n  previousState() {\n    if (this.hasPreviousState()) {\n      this.setStateIndex(this.stateIndex - 1);\n    }\n  }\n\n  /**\n   * Restore the next view state\n   */\n  nextState() {\n    if (this.hasNextState()) {\n      this.setStateIndex(this.stateIndex + 1);\n    }\n  }\n\n  /**\n   * Clear the state history\n   */\n  clearStateHistory() {\n    this.states = [];\n    this.stateIndex = 0;\n  }\n\n  /**\n   * Update the the view to it's intial state\n   */\n  setInitialState() {\n    if (this.states.length > 0) {\n      this.setStateIndex(0);\n    }\n  }\n\n  /**\n   * Move to the extent retrieved from the stream\n   * @param extent Extent\n   * @param action Either zoom or move\n   * @param animation With or without animation to the target extent.\n   */\n  private setExtent(\n    extent: MapExtent,\n    action: MapViewAction,\n    animation = true\n  ) {\n    const olView = this.olView;\n    olView.cancelAnimations();\n    const duration = animation ? 500 : 0;\n    const zoom = olView.getZoom();\n\n    const fromCenter = olView.getCenter();\n    const toCenter = [\n      extent[0] + (extent[2] - extent[0]) / 2,\n      extent[1] + (extent[3] - extent[1]) / 2\n    ];\n    const distCenter = Math.sqrt(\n      Math.pow(fromCenter[0] - toCenter[0], 2) +\n        Math.pow(fromCenter[1] - toCenter[1], 2)\n    );\n    const fromExtent = olView.calculateExtent();\n    const fromSize = Math.sqrt(\n      Math.pow(fromExtent[2] - fromExtent[0], 2) +\n        Math.pow(fromExtent[3] - fromExtent[1], 2)\n    );\n    const toSize = Math.sqrt(\n      Math.pow(extent[2] - extent[0], 2) + Math.pow(extent[3] - extent[1], 2)\n    );\n    const moySize = (toSize + fromSize) / 2;\n    const xSize = distCenter / moySize;\n\n    const maxZoom =\n      action === MapViewAction.Move || zoom > this.maxZoomOnExtent\n        ? zoom\n        : this.maxZoomOnExtent;\n\n    olView.fit(extent, {\n      size: this.olMap.getSize(),\n      maxZoom,\n      padding: this.padding,\n      duration: xSize > 4 ? 0 : duration,\n      callback: (isFinished: boolean) => {\n        if (!isFinished) {\n          olView.fit(extent, {\n            size: this.olMap.getSize(),\n            maxZoom,\n            padding: this.padding,\n            duration: xSize > 4 ? 0 : duration\n          });\n        }\n      }\n    });\n  }\n\n  /**\n   * Set the view state index\n   * @param index State index\n   */\n  private setStateIndex(index: number) {\n    this.stateIndex = index;\n    this.setState(this.states[index]);\n  }\n\n  /**\n   * Set the view state\n   * @param state View state\n   */\n  private setState(state: MapViewState) {\n    this.olView.animate({\n      resolution: state.resolution,\n      center: state.center,\n      duration: 0\n    });\n  }\n\n  /**\n   * On move end, get the view state and record it.\n   * @param event Map event\n   */\n  private onMoveEnd() {\n    const resolution = this.getResolution();\n    if (this.resolution$.value !== resolution) {\n      this.resolution$.next(resolution);\n    }\n\n    const state = {\n      resolution,\n      center: this.getCenter(),\n      zoom: this.getZoom()\n    };\n\n    if (this.stateHistory === true) {\n      const stateIndex = this.stateIndex;\n      const stateAtIndex =\n        this.states.length === 0 ? undefined : this.states[stateIndex];\n      if (!viewStatesAreEqual(state, stateAtIndex)) {\n        this.states = this.states.slice(0, stateIndex + 1).concat([state]);\n        this.stateIndex = this.states.length - 1;\n      }\n    }\n\n    this.state$.next(state);\n  }\n}\n"]}