@igo2/geo 1.12.1 → 1.13.0-alpha.0

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

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