@igo2/geo 1.11.1 → 1.13.0-alpha.0

package/esm2020/lib/geometry/shared/controls/modify.mjs

@@ -0,0 +1,521 @@
+import OlFeature from 'ol/Feature';
+import OlVectorSource from 'ol/source/Vector';
+import OlVectorLayer from 'ol/layer/Vector';
+import OlModify from 'ol/interaction/Modify';
+import OlTranslate from 'ol/interaction/Translate';
+import OlDraw from 'ol/interaction/Draw';
+import OlPolygon from 'ol/geom/Polygon';
+import OlLinearRing from 'ol/geom/LinearRing';
+import OlDragBoxInteraction from 'ol/interaction/DragBox';
+import { unByKey } from 'ol/Observable';
+import { Subject, fromEvent } from 'rxjs';
+import { addLinearRingToOlPolygon, createDrawHoleInteractionStyle, getMousePositionFromOlGeometryEvent } from '../geometry.utils';
+/**
+ * Control to modify geometries
+ */
+export class ModifyControl {
+    constructor(options) {
+        this.options = options;
+        /**
+         * Modify start observable
+         */
+        this.start$ = new Subject();
+        /**
+         * Modify end observable
+         */
+        this.end$ = new Subject();
+        /**
+         * Geometry changes observable
+         */
+        this.changes$ = new Subject();
+        this.olModifyInteractionIsActive = false;
+        this.olTranslateInteractionIsActive = false;
+        this.olDrawInteractionIsActive = false;
+        this.removedOlInteractions = [];
+        /**
+         * Whether a modify control should be available
+         */
+        this.modify = true;
+        /**
+         * Whether a translate control should be available
+         */
+        this.translate = true;
+        if (options.modify !== undefined) {
+            this.modify = options.modify;
+        }
+        if (options.translate !== undefined) {
+            this.translate = options.translate;
+        }
+        if (options.layer !== undefined) {
+            this.olOverlayLayer = options.layer;
+        }
+        else {
+            this.olOverlayLayer = this.createOlInnerOverlayLayer();
+        }
+        this.olLinearRingsLayer = this.createOlLinearRingsLayer();
+    }
+    /**
+     * Wheter the control is active
+     */
+    get active() {
+        return this.olMap !== undefined;
+    }
+    /**
+     * OL overlay source
+     * @internal
+     */
+    get olOverlaySource() {
+        return this.olOverlayLayer.getSource();
+    }
+    /**
+     * OL linear rings source
+     * @internal
+     */
+    get olLinearRingsSource() {
+        return this.olLinearRingsLayer.getSource();
+    }
+    /**
+     * Add or remove this control to/from a map.
+     * @param map OL Map
+     */
+    setOlMap(olMap) {
+        if (olMap === undefined) {
+            this.clearOlInnerOverlaySource();
+            this.removeOlInnerOverlayLayer();
+            this.removeOlModifyInteraction();
+            this.removeOlTranslateInteraction();
+            this.removeOlDrawInteraction();
+            this.olMap = olMap;
+            return;
+        }
+        this.olMap = olMap;
+        this.addOlInnerOverlayLayer();
+        // The order in which these interactions
+        // are added is important
+        if (this.modify === true) {
+            this.addOlDrawInteraction();
+        }
+        if (this.translate === true) {
+            this.addOlTranslateInteraction();
+            this.activateTranslateInteraction();
+        }
+        if (this.modify === true) {
+            this.addOlModifyInteraction();
+            this.activateModifyInteraction();
+        }
+    }
+    /**
+     * Return the overlay source
+     */
+    getSource() {
+        return this.olOverlaySource;
+    }
+    /**
+     * Add an OL geometry to the overlay and start modifying it
+     * @param olGeometry Ol Geometry
+     */
+    setOlGeometry(olGeometry) {
+        const olFeature = new OlFeature({ geometry: olGeometry });
+        this.olOverlaySource.clear();
+        this.olOverlaySource.addFeature(olFeature);
+    }
+    /**
+     * Create an overlay source if none is defined in the options
+     */
+    createOlInnerOverlayLayer() {
+        return new OlVectorLayer({
+            source: this.options.source ? this.options.source : new OlVectorSource(),
+            style: this.options.layerStyle,
+            zIndex: 500
+        });
+    }
+    /**
+     * Add the overlay layer if it wasn't defined in the options
+     */
+    addOlInnerOverlayLayer() {
+        if (this.options.layer === undefined) {
+            this.olMap.addLayer(this.olOverlayLayer);
+        }
+    }
+    /**
+     * Clear the overlay layer if it wasn't defined in the options
+     */
+    removeOlInnerOverlayLayer() {
+        if (this.options.layer === undefined && this.olMap !== undefined) {
+            this.olMap.removeLayer(this.olOverlayLayer);
+        }
+    }
+    /**
+     * Clear the overlay source if it wasn't defined in the options
+     */
+    clearOlInnerOverlaySource() {
+        if (this.options.layer === undefined && this.options.source === undefined) {
+            this.olOverlaySource.clear(true);
+        }
+    }
+    createOlLinearRingsLayer() {
+        return new OlVectorLayer({
+            source: new OlVectorSource(),
+            style: createDrawHoleInteractionStyle(),
+            zIndex: 500
+        });
+    }
+    /**
+     * Add the linear rings layer
+     */
+    addOlLinearRingsLayer() {
+        this.olMap.addLayer(this.olLinearRingsLayer);
+    }
+    /**
+     * Clear the linear rings layer
+     */
+    removeOlLinearRingsLayer() {
+        this.olMap.removeLayer(this.olLinearRingsLayer);
+    }
+    /**
+     * Clear the linear rings source
+     */
+    clearOlLinearRingsSource() {
+        this.olLinearRingsSource.clear(true);
+    }
+    /**
+     * Add a modify interaction to the map an set up some listeners
+     */
+    addOlModifyInteraction() {
+        const olModifyInteraction = new OlModify({
+            source: this.olOverlaySource,
+            style: this.options.drawStyle
+        });
+        this.olModifyInteraction = olModifyInteraction;
+    }
+    /**
+     * Remove the modify interaction
+     */
+    removeOlModifyInteraction() {
+        if (this.olModifyInteraction === undefined) {
+            return;
+        }
+        this.deactivateModifyInteraction();
+        this.olModifyInteraction = undefined;
+    }
+    activateModifyInteraction() {
+        if (this.olModifyInteractionIsActive === true) {
+            return;
+        }
+        this.olModifyInteractionIsActive = true;
+        this.onModifyStartKey = this.olModifyInteraction.on('modifystart', (event) => this.onModifyStart(event));
+        this.onModifyEndKey = this.olModifyInteraction.on('modifyend', (event) => this.onModifyEnd(event));
+        this.olMap.addInteraction(this.olModifyInteraction);
+    }
+    deactivateModifyInteraction() {
+        if (this.olModifyInteractionIsActive === false) {
+            return;
+        }
+        this.olModifyInteractionIsActive = false;
+        unByKey([this.onModifyStartKey, this.onModifyEndKey, this.onModifyKey]);
+        if (this.olMap !== undefined) {
+            this.olMap.removeInteraction(this.olModifyInteraction);
+        }
+    }
+    /**
+     * When modifying starts, clear the overlay and start watching for changes
+     * @param event Modify start event
+     */
+    onModifyStart(event) {
+        const olGeometry = event.features.item(0).getGeometry();
+        this.start$.next(olGeometry);
+        this.onModifyKey = olGeometry.on('change', (olGeometryEvent) => {
+            this.mousePosition = getMousePositionFromOlGeometryEvent(olGeometryEvent);
+            this.changes$.next(olGeometryEvent.target);
+        });
+        this.subscribeToKeyDown();
+    }
+    /**
+     * When modifying ends, update the geometry observable and stop watching for changes
+     * @param event Modify end event
+     */
+    onModifyEnd(event) {
+        unByKey(this.onModifyKey);
+        this.end$.next(event.features.item(0).getGeometry());
+        this.unsubscribeToKeyDown();
+    }
+    /**
+     * Subscribe to space key down to pan the map
+     */
+    subscribeToKeyDown() {
+        this.keyDown$$ = fromEvent(document, 'keydown').subscribe((event) => {
+            if (event.key === ' ') {
+                // On space bar, pan to the current mouse position
+                this.olMap.getView().animate({
+                    center: this.mousePosition,
+                    duration: 0
+                });
+                return;
+            }
+        });
+    }
+    /**
+     * Unsubscribe to key down
+     */
+    unsubscribeToKeyDown() {
+        if (this.keyDown$$ !== undefined) {
+            this.keyDown$$.unsubscribe();
+        }
+    }
+    /**
+     * Add a translate interaction to the map an set up some listeners
+     */
+    addOlTranslateInteraction() {
+        const olTranslateInteraction = new OlTranslate({
+            layers: [this.olOverlayLayer]
+        });
+        this.olTranslateInteraction = olTranslateInteraction;
+    }
+    /**
+     * Remove the translate interaction
+     */
+    removeOlTranslateInteraction() {
+        if (this.olTranslateInteraction === undefined) {
+            return;
+        }
+        this.deactivateTranslateInteraction();
+        this.olTranslateInteraction = undefined;
+    }
+    activateTranslateInteraction() {
+        if (this.olTranslateInteractionIsActive === true) {
+            return;
+        }
+        this.olTranslateInteractionIsActive = true;
+        this.onTranslateStartKey = this.olTranslateInteraction.on('translatestart', (event) => this.onTranslateStart(event));
+        this.onTranslateEndKey = this.olTranslateInteraction.on('translateend', (event) => this.onTranslateEnd(event));
+        this.olMap.addInteraction(this.olTranslateInteraction);
+    }
+    deactivateTranslateInteraction() {
+        if (this.olTranslateInteractionIsActive === false) {
+            return;
+        }
+        this.olTranslateInteractionIsActive = false;
+        unByKey([
+            this.onTranslateStartKey,
+            this.onTranslateEndKey,
+            this.onTranslateKey
+        ]);
+        if (this.olMap !== undefined) {
+            this.olMap.removeInteraction(this.olTranslateInteraction);
+        }
+    }
+    /**
+     * When translation starts, clear the overlay and start watching for changes
+     * @param event Translate start event
+     */
+    onTranslateStart(event) {
+        const olGeometry = event.features.item(0).getGeometry();
+        this.start$.next(olGeometry);
+        this.onTranslateKey = olGeometry.on('change', (olGeometryEvent) => {
+            // this.changes$.next(olGeometryEvent.target);
+        });
+    }
+    /**
+     * When translation ends, update the geometry observable and stop watchign for changes
+     * @param event Translate end event
+     */
+    onTranslateEnd(event) {
+        unByKey(this.onTranslateKey);
+        this.end$.next(event.features.item(0).getGeometry());
+    }
+    /**
+     * Add a draw interaction to the map an set up some listeners
+     */
+    addOlDrawInteraction() {
+        const olDrawInteraction = new OlDraw({
+            type: 'Polygon',
+            source: this.olLinearRingsSource,
+            stopClick: true,
+            style: createDrawHoleInteractionStyle(),
+            condition: (event) => {
+                const olOuterGeometry = this.olOuterGeometry || this.getOlGeometry();
+                const intersects = olOuterGeometry.intersectsCoordinate(event.coordinate);
+                return intersects;
+            }
+        });
+        this.olDrawInteraction = olDrawInteraction;
+        this.subscribeToDrawKeyDown();
+    }
+    /**
+     * Subscribe to CTRL key down to activate the draw control
+     */
+    subscribeToDrawKeyDown() {
+        this.drawKeyDown$$ = fromEvent(document, 'keydown').subscribe((event) => {
+            if (event.key !== 'Control') {
+                return;
+            }
+            this.unsubscribeToDrawKeyDown();
+            const olGeometry = this.getOlGeometry();
+            if (!olGeometry || !(olGeometry instanceof OlPolygon)) {
+                return;
+            }
+            this.subscribeToDrawKeyUp();
+            this.deactivateModifyInteraction();
+            this.deactivateTranslateInteraction();
+            this.activateDrawInteraction();
+        });
+    }
+    /**
+     * Subscribe to CTRL key up to deactivate the draw control
+     */
+    subscribeToDrawKeyUp() {
+        this.drawKeyUp$$ = fromEvent(document, 'keyup').subscribe((event) => {
+            if (event.key !== 'Control') {
+                return;
+            }
+            this.unsubscribeToDrawKeyUp();
+            this.unsubscribeToKeyDown();
+            this.deactivateDrawInteraction();
+            this.activateModifyInteraction();
+            if (this.translate === true) {
+                this.activateTranslateInteraction();
+            }
+            this.subscribeToDrawKeyDown();
+            this.olOuterGeometry = undefined;
+            this.clearOlLinearRingsSource();
+            this.end$.next(this.getOlGeometry());
+        });
+    }
+    /**
+     * Unsubscribe to draw key down
+     */
+    unsubscribeToDrawKeyDown() {
+        if (this.drawKeyDown$$ !== undefined) {
+            this.drawKeyDown$$.unsubscribe();
+        }
+    }
+    /**
+     * Unsubscribe to key up
+     */
+    unsubscribeToDrawKeyUp() {
+        if (this.drawKeyUp$$ !== undefined) {
+            this.drawKeyUp$$.unsubscribe();
+        }
+    }
+    /**
+     * Remove the draw interaction
+     */
+    removeOlDrawInteraction() {
+        if (this.olDrawInteraction === undefined) {
+            return;
+        }
+        this.unsubscribeToKeyDown();
+        this.unsubscribeToDrawKeyUp();
+        this.unsubscribeToDrawKeyDown();
+        this.deactivateDrawInteraction();
+        this.clearOlLinearRingsSource();
+        this.olDrawInteraction = undefined;
+    }
+    /**
+     * Activate the draw interaction
+     */
+    activateDrawInteraction() {
+        if (this.olDrawInteractionIsActive === true) {
+            return;
+        }
+        this.clearOlLinearRingsSource();
+        this.addOlLinearRingsLayer();
+        this.olMap.getInteractions().forEach((olInteraction) => {
+            if (olInteraction instanceof OlDragBoxInteraction) {
+                this.olMap.removeInteraction(olInteraction);
+                this.removedOlInteractions.push(olInteraction);
+            }
+        });
+        this.olDrawInteractionIsActive = true;
+        this.onDrawStartKey = this.olDrawInteraction.on('drawstart', (event) => this.onDrawStart(event));
+        this.onDrawEndKey = this.olDrawInteraction.on('drawend', (event) => this.onDrawEnd(event));
+        this.olMap.addInteraction(this.olDrawInteraction);
+    }
+    /**
+     * Deactivate the draw interaction
+     */
+    deactivateDrawInteraction() {
+        if (this.olDrawInteractionIsActive === false) {
+            return;
+        }
+        this.removeOlLinearRingsLayer();
+        this.removedOlInteractions.forEach((olInteraction) => {
+            this.olMap.addInteraction(olInteraction);
+        });
+        this.removedOlInteractions = [];
+        this.olDrawInteractionIsActive = false;
+        unByKey([this.onDrawStartKey, this.onDrawEndKey, this.onDrawKey]);
+        if (this.olMap !== undefined) {
+            this.olMap.removeInteraction(this.olDrawInteraction);
+        }
+    }
+    /**
+     * When draw start, add a new linerar ring to the geometry and start watching for changes
+     * @param event Draw start event
+     */
+    onDrawStart(event) {
+        const olGeometry = event.feature.getGeometry();
+        this.olOuterGeometry = this.getOlGeometry().clone();
+        const linearRingCoordinates = olGeometry.getLinearRing().getCoordinates();
+        this.addLinearRingToOlGeometry(linearRingCoordinates);
+        this.start$.next(this.getOlGeometry());
+        this.onDrawKey = olGeometry.on('change', (olGeometryEvent) => {
+            this.mousePosition = getMousePositionFromOlGeometryEvent(olGeometryEvent);
+            const olGeometryTarget = olGeometryEvent.target;
+            const _linearRingCoordinates = olGeometryTarget
+                .getLinearRing(0)
+                .getCoordinates();
+            this.updateLinearRingOfOlGeometry(_linearRingCoordinates);
+            this.changes$.next(this.getOlGeometry());
+        });
+        this.subscribeToKeyDown();
+    }
+    /**
+     * When translation ends, update the geometry observable and stop watchign for changes
+     * @param event Draw end event
+     */
+    onDrawEnd(event) {
+        unByKey(this.onDrawKey);
+        this.olOuterGeometry = undefined;
+        const linearRingCoordinates = event.feature
+            .getGeometry()
+            .getLinearRing()
+            .getCoordinates();
+        this.updateLinearRingOfOlGeometry(linearRingCoordinates);
+        this.clearOlLinearRingsSource();
+        this.end$.next(this.getOlGeometry());
+        this.unsubscribeToKeyDown();
+    }
+    /**
+     * Add a linear ring to the geometry being modified
+     * @param coordinates Linear ring coordinates
+     */
+    addLinearRingToOlGeometry(coordinates) {
+        const olGeometry = this.getOlGeometry();
+        const olLinearRing = new OlLinearRing(coordinates);
+        addLinearRingToOlPolygon(olGeometry, olLinearRing);
+    }
+    /**
+     * Update the last linear ring of the geometry being modified
+     * @param coordinates Linear ring coordinates
+     */
+    updateLinearRingOfOlGeometry(coordinates) {
+        const olGeometry = this.getOlGeometry();
+        // Remove the last linear ring (the one we are updating)
+        const olLinearRings = olGeometry.getLinearRings().slice(0, -1);
+        const newCoordinates = olLinearRings.map((olLinearRing) => {
+            return olLinearRing.getCoordinates();
+        });
+        newCoordinates.push(coordinates);
+        olGeometry.setCoordinates(newCoordinates);
+    }
+    /**
+     * Get the geometry being modified
+     * @returns OL Geometry
+     */
+    getOlGeometry() {
+        const olFeatures = this.olOverlaySource.getFeatures();
+        return olFeatures.length > 0 ? olFeatures[0].getGeometry() : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modify.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/geometry/shared/controls/modify.ts"],"names":[],"mappings":"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","sourcesContent":["import OlMap from 'ol/Map';\r\nimport OlFeature from 'ol/Feature';\r\nimport * as OlStyle from 'ol/style';\r\nimport { StyleLike as OlStyleLike } from 'ol/style/Style';\r\nimport OlVectorSource from 'ol/source/Vector';\r\nimport OlVectorLayer from 'ol/layer/Vector';\r\nimport OlModify from 'ol/interaction/Modify';\r\nimport OlTranslate from 'ol/interaction/Translate';\r\nimport OlDraw from 'ol/interaction/Draw';\r\nimport OlPolygon from 'ol/geom/Polygon';\r\nimport OlLineString from 'ol/geom/LineString';\r\nimport OlCircle from 'ol/geom/Circle';\r\nimport OlLinearRing from 'ol/geom/LinearRing';\r\nimport OlInteraction from 'ol/interaction/Interaction';\r\nimport OlDragBoxInteraction from 'ol/interaction/DragBox';\r\nimport MapBrowserEvent from 'ol/MapBrowserEvent';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport BasicEvent from 'ol/events/Event';\r\nimport { ModifyEvent as OlModifyEvent } from 'ol/interaction/Modify';\r\nimport { TranslateEvent as OlTranslateEvent } from 'ol/interaction/Translate';\r\nimport { DrawEvent as OlDrawEvent } from 'ol/interaction/Draw';\r\nimport { unByKey } from 'ol/Observable';\r\n\r\nimport { Subject, Subscription, fromEvent } from 'rxjs';\r\n\r\nimport {\r\n  addLinearRingToOlPolygon,\r\n  createDrawHoleInteractionStyle,\r\n  getMousePositionFromOlGeometryEvent\r\n} from '../geometry.utils';\r\n\r\nexport interface ModifyControlOptions {\r\n  source?: OlVectorSource<any>;\r\n  layer?: OlVectorLayer<any>;\r\n  layerStyle?: OlStyleLike;\r\n  drawStyle?: OlStyleLike;\r\n  modify?: boolean;\r\n  translate?: boolean;\r\n}\r\n\r\n/**\r\n * Control to modify geometries\r\n */\r\nexport class ModifyControl {\r\n  /**\r\n   * Modify start observable\r\n   */\r\n  public start$: Subject<OlGeometry> = new Subject();\r\n\r\n  /**\r\n   * Modify end observable\r\n   */\r\n  public end$: Subject<OlGeometry> = new Subject();\r\n\r\n  /**\r\n   * Geometry changes observable\r\n   */\r\n  public changes$: Subject<OlGeometry> = new Subject();\r\n\r\n  private olMap: OlMap;\r\n  private olOverlayLayer: OlVectorLayer<any>;\r\n  public olModifyInteraction: OlModify;\r\n  private onModifyStartKey: any;\r\n  private onModifyEndKey: any;\r\n  private onModifyKey: any;\r\n  private olModifyInteractionIsActive: boolean = false;\r\n  private olTranslateInteraction: OlTranslate;\r\n  private onTranslateStartKey: any;\r\n  private onTranslateEndKey: any;\r\n  private onTranslateKey: any;\r\n  private olTranslateInteractionIsActive: boolean = false;\r\n  private olDrawInteraction: OlDraw;\r\n  private onDrawStartKey: any;\r\n  private onDrawEndKey: any;\r\n  private onDrawKey: any;\r\n  private olDrawInteractionIsActive: boolean = false;\r\n\r\n  private mousePosition: [number, number];\r\n\r\n  private keyDown$$: Subscription;\r\n  private drawKeyUp$$: Subscription;\r\n  private drawKeyDown$$: Subscription;\r\n\r\n  private removedOlInteractions: OlInteraction[] = [];\r\n  private olLinearRingsLayer: OlVectorLayer<any>;\r\n\r\n  // This is the geometry to test against when drawing holes\r\n  private olOuterGeometry: OlGeometry;\r\n\r\n  /**\r\n   * Wheter the control is active\r\n   */\r\n  get active(): boolean {\r\n    return this.olMap !== undefined;\r\n  }\r\n\r\n  /**\r\n   * OL overlay source\r\n   * @internal\r\n   */\r\n  get olOverlaySource(): OlVectorSource<any> {\r\n    return this.olOverlayLayer.getSource();\r\n  }\r\n\r\n  /**\r\n   * OL linear rings source\r\n   * @internal\r\n   */\r\n  get olLinearRingsSource(): OlVectorSource<any> {\r\n    return this.olLinearRingsLayer.getSource();\r\n  }\r\n\r\n  /**\r\n   * Whether a modify control should be available\r\n   */\r\n  private modify: boolean = true;\r\n\r\n  /**\r\n   * Whether a translate control should be available\r\n   */\r\n  private translate: boolean = true;\r\n\r\n  constructor(private options: ModifyControlOptions) {\r\n    if (options.modify !== undefined) {\r\n      this.modify = options.modify;\r\n    }\r\n    if (options.translate !== undefined) {\r\n      this.translate = options.translate;\r\n    }\r\n\r\n    if (options.layer !== undefined) {\r\n      this.olOverlayLayer = options.layer;\r\n    } else {\r\n      this.olOverlayLayer = this.createOlInnerOverlayLayer();\r\n    }\r\n    this.olLinearRingsLayer = this.createOlLinearRingsLayer();\r\n  }\r\n\r\n  /**\r\n   * Add or remove this control to/from a map.\r\n   * @param map OL Map\r\n   */\r\n  setOlMap(olMap: OlMap | undefined) {\r\n    if (olMap === undefined) {\r\n      this.clearOlInnerOverlaySource();\r\n      this.removeOlInnerOverlayLayer();\r\n      this.removeOlModifyInteraction();\r\n      this.removeOlTranslateInteraction();\r\n      this.removeOlDrawInteraction();\r\n      this.olMap = olMap;\r\n      return;\r\n    }\r\n\r\n    this.olMap = olMap;\r\n    this.addOlInnerOverlayLayer();\r\n\r\n    // The order in which these interactions\r\n    // are added is important\r\n    if (this.modify === true) {\r\n      this.addOlDrawInteraction();\r\n    }\r\n\r\n    if (this.translate === true) {\r\n      this.addOlTranslateInteraction();\r\n      this.activateTranslateInteraction();\r\n    }\r\n\r\n    if (this.modify === true) {\r\n      this.addOlModifyInteraction();\r\n      this.activateModifyInteraction();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Return the overlay source\r\n   */\r\n  getSource(): OlVectorSource<any> {\r\n    return this.olOverlaySource;\r\n  }\r\n\r\n  /**\r\n   * Add an OL geometry to the overlay and start modifying it\r\n   * @param olGeometry Ol Geometry\r\n   */\r\n  setOlGeometry(olGeometry: OlGeometry) {\r\n    const olFeature = new OlFeature({ geometry: olGeometry });\r\n    this.olOverlaySource.clear();\r\n    this.olOverlaySource.addFeature(olFeature);\r\n  }\r\n\r\n  /**\r\n   * Create an overlay source if none is defined in the options\r\n   */\r\n  private createOlInnerOverlayLayer(): OlVectorLayer<any> {\r\n    return new OlVectorLayer({\r\n      source: this.options.source ? this.options.source : new OlVectorSource(),\r\n      style: this.options.layerStyle,\r\n      zIndex: 500\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Add the overlay layer if it wasn't defined in the options\r\n   */\r\n  private addOlInnerOverlayLayer() {\r\n    if (this.options.layer === undefined) {\r\n      this.olMap.addLayer(this.olOverlayLayer);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clear the overlay layer if it wasn't defined in the options\r\n   */\r\n  private removeOlInnerOverlayLayer() {\r\n    if (this.options.layer === undefined && this.olMap !== undefined) {\r\n      this.olMap.removeLayer(this.olOverlayLayer);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clear the overlay source if it wasn't defined in the options\r\n   */\r\n  private clearOlInnerOverlaySource() {\r\n    if (this.options.layer === undefined && this.options.source === undefined) {\r\n      this.olOverlaySource.clear(true);\r\n    }\r\n  }\r\n\r\n  private createOlLinearRingsLayer(): OlVectorLayer<any> {\r\n    return new OlVectorLayer({\r\n      source: new OlVectorSource(),\r\n      style: createDrawHoleInteractionStyle(),\r\n      zIndex: 500\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Add the linear rings layer\r\n   */\r\n  private addOlLinearRingsLayer() {\r\n    this.olMap.addLayer(this.olLinearRingsLayer);\r\n  }\r\n\r\n  /**\r\n   * Clear the linear rings layer\r\n   */\r\n  private removeOlLinearRingsLayer() {\r\n    this.olMap.removeLayer(this.olLinearRingsLayer);\r\n  }\r\n\r\n  /**\r\n   * Clear the linear rings source\r\n   */\r\n  private clearOlLinearRingsSource() {\r\n    this.olLinearRingsSource.clear(true);\r\n  }\r\n\r\n  /**\r\n   * Add a modify interaction to the map an set up some listeners\r\n   */\r\n  private addOlModifyInteraction() {\r\n    const olModifyInteraction = new OlModify({\r\n      source: this.olOverlaySource,\r\n      style: this.options.drawStyle as OlStyle.Style\r\n    });\r\n    this.olModifyInteraction = olModifyInteraction;\r\n  }\r\n\r\n  /**\r\n   * Remove the modify interaction\r\n   */\r\n  private removeOlModifyInteraction() {\r\n    if (this.olModifyInteraction === undefined) {\r\n      return;\r\n    }\r\n\r\n    this.deactivateModifyInteraction();\r\n    this.olModifyInteraction = undefined;\r\n  }\r\n\r\n  private activateModifyInteraction() {\r\n    if (this.olModifyInteractionIsActive === true) {\r\n      return;\r\n    }\r\n\r\n    this.olModifyInteractionIsActive = true;\r\n    this.onModifyStartKey = this.olModifyInteraction.on(\r\n      'modifystart',\r\n      (event: OlModifyEvent) => this.onModifyStart(event)\r\n    );\r\n    this.onModifyEndKey = this.olModifyInteraction.on(\r\n      'modifyend',\r\n      (event: OlModifyEvent) => this.onModifyEnd(event)\r\n    );\r\n    this.olMap.addInteraction(this.olModifyInteraction);\r\n  }\r\n\r\n  private deactivateModifyInteraction() {\r\n    if (this.olModifyInteractionIsActive === false) {\r\n      return;\r\n    }\r\n\r\n    this.olModifyInteractionIsActive = false;\r\n\r\n    unByKey([this.onModifyStartKey, this.onModifyEndKey, this.onModifyKey]);\r\n    if (this.olMap !== undefined) {\r\n      this.olMap.removeInteraction(this.olModifyInteraction);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * When modifying starts, clear the overlay and start watching for changes\r\n   * @param event Modify start event\r\n   */\r\n  private onModifyStart(event: OlModifyEvent) {\r\n    const olGeometry = event.features.item(0).getGeometry() as OlGeometry;\r\n    this.start$.next(olGeometry);\r\n    this.onModifyKey = olGeometry.on(\r\n      'change',\r\n      (olGeometryEvent: BasicEvent) => {\r\n        this.mousePosition = getMousePositionFromOlGeometryEvent(\r\n          olGeometryEvent\r\n        );\r\n        this.changes$.next(olGeometryEvent.target as OlLineString | OlCircle | OlPolygon);\r\n      }\r\n    );\r\n    this.subscribeToKeyDown();\r\n  }\r\n\r\n  /**\r\n   * When modifying ends, update the geometry observable and stop watching for changes\r\n   * @param event Modify end event\r\n   */\r\n  private onModifyEnd(event: OlModifyEvent) {\r\n    unByKey(this.onModifyKey);\r\n    this.end$.next(event.features.item(0).getGeometry() as OlGeometry);\r\n    this.unsubscribeToKeyDown();\r\n  }\r\n\r\n  /**\r\n   * Subscribe to space key down to pan the map\r\n   */\r\n  private subscribeToKeyDown() {\r\n    this.keyDown$$ = fromEvent(document, 'keydown').subscribe(\r\n      (event: KeyboardEvent) => {\r\n        if (event.key === ' ') {\r\n          // On space bar, pan to the current mouse position\r\n          this.olMap.getView().animate({\r\n            center: this.mousePosition,\r\n            duration: 0\r\n          });\r\n          return;\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe to key down\r\n   */\r\n  private unsubscribeToKeyDown() {\r\n    if (this.keyDown$$ !== undefined) {\r\n      this.keyDown$$.unsubscribe();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add a translate interaction to the map an set up some listeners\r\n   */\r\n  private addOlTranslateInteraction() {\r\n    const olTranslateInteraction = new OlTranslate({\r\n      layers: [this.olOverlayLayer]\r\n    });\r\n    this.olTranslateInteraction = olTranslateInteraction;\r\n  }\r\n\r\n  /**\r\n   * Remove the translate interaction\r\n   */\r\n  private removeOlTranslateInteraction() {\r\n    if (this.olTranslateInteraction === undefined) {\r\n      return;\r\n    }\r\n\r\n    this.deactivateTranslateInteraction();\r\n    this.olTranslateInteraction = undefined;\r\n  }\r\n\r\n  private activateTranslateInteraction() {\r\n    if (this.olTranslateInteractionIsActive === true) {\r\n      return;\r\n    }\r\n\r\n    this.olTranslateInteractionIsActive = true;\r\n    this.onTranslateStartKey = this.olTranslateInteraction.on(\r\n      'translatestart',\r\n      (event: OlTranslateEvent) => this.onTranslateStart(event)\r\n    );\r\n    this.onTranslateEndKey = this.olTranslateInteraction.on(\r\n      'translateend',\r\n      (event: OlTranslateEvent) => this.onTranslateEnd(event)\r\n    );\r\n    this.olMap.addInteraction(this.olTranslateInteraction);\r\n  }\r\n\r\n  private deactivateTranslateInteraction() {\r\n    if (this.olTranslateInteractionIsActive === false) {\r\n      return;\r\n    }\r\n\r\n    this.olTranslateInteractionIsActive = false;\r\n    unByKey([\r\n      this.onTranslateStartKey,\r\n      this.onTranslateEndKey,\r\n      this.onTranslateKey\r\n    ]);\r\n    if (this.olMap !== undefined) {\r\n      this.olMap.removeInteraction(this.olTranslateInteraction);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * When translation starts, clear the overlay and start watching for changes\r\n   * @param event Translate start event\r\n   */\r\n  private onTranslateStart(event: OlTranslateEvent) {\r\n    const olGeometry = event.features.item(0).getGeometry() as OlGeometry;\r\n    this.start$.next(olGeometry);\r\n    this.onTranslateKey = olGeometry.on(\r\n      'change',\r\n      (olGeometryEvent: BasicEvent) => {\r\n        // this.changes$.next(olGeometryEvent.target);\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * When translation ends, update the geometry observable and stop watchign for changes\r\n   * @param event Translate end event\r\n   */\r\n  private onTranslateEnd(event: OlTranslateEvent) {\r\n    unByKey(this.onTranslateKey);\r\n    this.end$.next(event.features.item(0).getGeometry() as OlGeometry);\r\n  }\r\n\r\n  /**\r\n   * Add a draw interaction to the map an set up some listeners\r\n   */\r\n  private addOlDrawInteraction() {\r\n    const olDrawInteraction = new OlDraw({\r\n      type: 'Polygon',\r\n      source: this.olLinearRingsSource,\r\n      stopClick: true,\r\n      style: createDrawHoleInteractionStyle(),\r\n      condition: (event: MapBrowserEvent<any>) => {\r\n        const olOuterGeometry = this.olOuterGeometry || this.getOlGeometry();\r\n        const intersects = olOuterGeometry.intersectsCoordinate(\r\n          event.coordinate\r\n        );\r\n        return intersects;\r\n      }\r\n    });\r\n\r\n    this.olDrawInteraction = olDrawInteraction;\r\n    this.subscribeToDrawKeyDown();\r\n  }\r\n\r\n  /**\r\n   * Subscribe to CTRL key down to activate the draw control\r\n   */\r\n  private subscribeToDrawKeyDown() {\r\n    this.drawKeyDown$$ = fromEvent(document, 'keydown').subscribe(\r\n      (event: KeyboardEvent) => {\r\n        if (event.key !== 'Control') {\r\n          return;\r\n        }\r\n\r\n        this.unsubscribeToDrawKeyDown();\r\n\r\n        const olGeometry = this.getOlGeometry();\r\n        if (!olGeometry || !(olGeometry instanceof OlPolygon)) {\r\n          return;\r\n        }\r\n\r\n        this.subscribeToDrawKeyUp();\r\n\r\n        this.deactivateModifyInteraction();\r\n        this.deactivateTranslateInteraction();\r\n        this.activateDrawInteraction();\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Subscribe to CTRL key up to deactivate the draw control\r\n   */\r\n  private subscribeToDrawKeyUp() {\r\n    this.drawKeyUp$$ = fromEvent(document, 'keyup').subscribe(\r\n      (event: KeyboardEvent) => {\r\n        if (event.key !== 'Control') {\r\n          return;\r\n        }\r\n\r\n        this.unsubscribeToDrawKeyUp();\r\n        this.unsubscribeToKeyDown();\r\n        this.deactivateDrawInteraction();\r\n\r\n        this.activateModifyInteraction();\r\n        if (this.translate === true) {\r\n          this.activateTranslateInteraction();\r\n        }\r\n        this.subscribeToDrawKeyDown();\r\n\r\n        this.olOuterGeometry = undefined;\r\n        this.clearOlLinearRingsSource();\r\n        this.end$.next(this.getOlGeometry());\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe to draw key down\r\n   */\r\n  private unsubscribeToDrawKeyDown() {\r\n    if (this.drawKeyDown$$ !== undefined) {\r\n      this.drawKeyDown$$.unsubscribe();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe to key up\r\n   */\r\n  private unsubscribeToDrawKeyUp() {\r\n    if (this.drawKeyUp$$ !== undefined) {\r\n      this.drawKeyUp$$.unsubscribe();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove the draw interaction\r\n   */\r\n  private removeOlDrawInteraction() {\r\n    if (this.olDrawInteraction === undefined) {\r\n      return;\r\n    }\r\n\r\n    this.unsubscribeToKeyDown();\r\n    this.unsubscribeToDrawKeyUp();\r\n    this.unsubscribeToDrawKeyDown();\r\n    this.deactivateDrawInteraction();\r\n    this.clearOlLinearRingsSource();\r\n    this.olDrawInteraction = undefined;\r\n  }\r\n\r\n  /**\r\n   * Activate the draw interaction\r\n   */\r\n  private activateDrawInteraction() {\r\n    if (this.olDrawInteractionIsActive === true) {\r\n      return;\r\n    }\r\n\r\n    this.clearOlLinearRingsSource();\r\n    this.addOlLinearRingsLayer();\r\n\r\n    this.olMap.getInteractions().forEach((olInteraction: OlInteraction) => {\r\n      if (olInteraction instanceof OlDragBoxInteraction) {\r\n        this.olMap.removeInteraction(olInteraction);\r\n        this.removedOlInteractions.push(olInteraction);\r\n      }\r\n    });\r\n\r\n    this.olDrawInteractionIsActive = true;\r\n    this.onDrawStartKey = this.olDrawInteraction.on(\r\n      'drawstart',\r\n      (event: OlDrawEvent) => this.onDrawStart(event)\r\n    );\r\n    this.onDrawEndKey = this.olDrawInteraction.on(\r\n      'drawend',\r\n      (event: OlDrawEvent) => this.onDrawEnd(event)\r\n    );\r\n    this.olMap.addInteraction(this.olDrawInteraction);\r\n  }\r\n\r\n  /**\r\n   * Deactivate the draw interaction\r\n   */\r\n  private deactivateDrawInteraction() {\r\n    if (this.olDrawInteractionIsActive === false) {\r\n      return;\r\n    }\r\n\r\n    this.removeOlLinearRingsLayer();\r\n\r\n    this.removedOlInteractions.forEach((olInteraction: OlInteraction) => {\r\n      this.olMap.addInteraction(olInteraction);\r\n    });\r\n    this.removedOlInteractions = [];\r\n\r\n    this.olDrawInteractionIsActive = false;\r\n    unByKey([this.onDrawStartKey, this.onDrawEndKey, this.onDrawKey]);\r\n    if (this.olMap !== undefined) {\r\n      this.olMap.removeInteraction(this.olDrawInteraction);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * When draw start, add a new linerar ring to the geometry and start watching for changes\r\n   * @param event Draw start event\r\n   */\r\n  private onDrawStart(event: OlDrawEvent) {\r\n    const olGeometry = event.feature.getGeometry();\r\n    this.olOuterGeometry = this.getOlGeometry().clone();\r\n\r\n    const linearRingCoordinates = ((olGeometry as any).getLinearRing() as any).getCoordinates();\r\n    this.addLinearRingToOlGeometry(linearRingCoordinates);\r\n    this.start$.next(this.getOlGeometry());\r\n\r\n    this.onDrawKey = olGeometry.on(\r\n      'change',\r\n      (olGeometryEvent: BasicEvent) => {\r\n        this.mousePosition = getMousePositionFromOlGeometryEvent(\r\n          olGeometryEvent\r\n        );\r\n        const olGeometryTarget = olGeometryEvent.target as OlPolygon;\r\n        const _linearRingCoordinates = olGeometryTarget\r\n          .getLinearRing(0)\r\n          .getCoordinates();\r\n        this.updateLinearRingOfOlGeometry(_linearRingCoordinates);\r\n        this.changes$.next(this.getOlGeometry());\r\n      }\r\n    );\r\n    this.subscribeToKeyDown();\r\n  }\r\n\r\n  /**\r\n   * When translation ends, update the geometry observable and stop watchign for changes\r\n   * @param event Draw end event\r\n   */\r\n  private onDrawEnd(event: OlDrawEvent) {\r\n    unByKey(this.onDrawKey);\r\n    this.olOuterGeometry = undefined;\r\n\r\n    const linearRingCoordinates = ((event.feature\r\n      .getGeometry() as any)\r\n      .getLinearRing() as any)\r\n      .getCoordinates();\r\n    this.updateLinearRingOfOlGeometry(linearRingCoordinates);\r\n    this.clearOlLinearRingsSource();\r\n    this.end$.next(this.getOlGeometry());\r\n    this.unsubscribeToKeyDown();\r\n  }\r\n\r\n  /**\r\n   * Add a linear ring to the geometry being modified\r\n   * @param coordinates Linear ring coordinates\r\n   */\r\n  private addLinearRingToOlGeometry(coordinates: number[]) {\r\n    const olGeometry = this.getOlGeometry() as OlPolygon;\r\n    const olLinearRing = new OlLinearRing(coordinates);\r\n    addLinearRingToOlPolygon(olGeometry, olLinearRing);\r\n  }\r\n\r\n  /**\r\n   * Update the last linear ring of the geometry being modified\r\n   * @param coordinates Linear ring coordinates\r\n   */\r\n  private updateLinearRingOfOlGeometry(coordinates: number[][]) {\r\n    const olGeometry = this.getOlGeometry() as OlPolygon;\r\n    // Remove the last linear ring (the one we are updating)\r\n    const olLinearRings = olGeometry.getLinearRings().slice(0, -1);\r\n    const newCoordinates = olLinearRings.map((olLinearRing: OlLinearRing) => {\r\n      return olLinearRing.getCoordinates();\r\n    });\r\n    newCoordinates.push(coordinates);\r\n    olGeometry.setCoordinates(newCoordinates);\r\n  }\r\n\r\n  /**\r\n   * Get the geometry being modified\r\n   * @returns OL Geometry\r\n   */\r\n  private getOlGeometry(): OlGeometry {\r\n    const olFeatures = this.olOverlaySource.getFeatures();\r\n    return olFeatures.length > 0 ? olFeatures[0].getGeometry() : undefined;\r\n  }\r\n}\r\n"]}