@smarterplan/ngx-smarterplan-locations 0.2.44 → 0.2.45

package/esm2020/lib/components/zones/add-zone/sweep-plan-selection/sweep-plan-selection.component.mjs

@@ -0,0 +1,502 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { getCoefficientsForImage, getMetaForImage, showScanPointsOnPlanInDiv } from '@smarterplan/ngx-smarterplan-core';
+import panzoom from 'panzoom';
+import { buttonIsInSelection, isInPolygon, rotate, setVisuallySelected, styleButton, SweepState } from '../../../../helper.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@smarterplan/ngx-smarterplan-core";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "../selection/selection.component";
+import * as i4 from "../../../plan-legend/plan-legend.component";
+import * as i5 from "../../../../radio-button/radio-button.component";
+import * as i6 from "@ng-bootstrap/ng-bootstrap";
+import * as i7 from "@angular/common";
+export class SweepPlanSelectionComponent {
+    constructor(zoneService, navigationService, planService, translate) {
+        this.zoneService = zoneService;
+        this.navigationService = navigationService;
+        this.planService = planService;
+        this.translate = translate;
+        this.chosenScansOnPlan = [];
+        this.navIDsZoneEdit = [];
+        // sweeps belonging to any audio zone
+        this.occupiedSweeps = [];
+        // sweeps unavailable (cannot be chosen)
+        this.unavailableSweeps = [];
+        // if choosing sweeps for audio zone
+        this.editingAudioZone = false;
+        this.multipleFloors = false;
+        /** all scan buttons Element */
+        this.buttonElements = [];
+        /** Scan buttons that are in the current selection */
+        this.buttonsInSelection = [];
+        this.sweepsSelected = new EventEmitter();
+        this.isSettingStartSweep = false;
+        this.chosenSweepsPerFloor = new Map(); // map matching floorID to sweeps selected
+        this.inputSweepsPerFloor = new Map(); // map matching floorID to sweeps selected for zone in edition
+        this.selectionChanged = false;
+    }
+    async ngOnInit() {
+        await this.getPlans();
+        this.setSweepsOfInputZone();
+    }
+    ngOnChanges() {
+        if (this.chosenPlan) {
+            this.setSweepsOfInputZone();
+            this.chosenScansOnPlan = [];
+            this.clearDivPlan();
+            this.addScanPoints();
+        }
+    }
+    setSweepsOfInputZone() {
+        this.navIDsZoneEdit = this.inputZone ? this.inputZone.sweepIDs : [];
+        if (this.multipleFloors) {
+            this.plans.forEach((plan) => {
+                if (!this.inputSweepsPerFloor.get(plan.zoneID)) {
+                    this.inputSweepsPerFloor.set(plan.zoneID, this.navIDsZoneEdit.filter((sweep) => plan.zone.sweepIDs.includes(sweep)));
+                }
+            });
+        }
+        else {
+            if (this.inputZone) {
+                //filter plans only for the parent Zone
+                this.plans = this.plans.filter((p) => p.zoneID === this.inputZone.parentID);
+            }
+        }
+    }
+    async getPlans() {
+        this.plans = await this.planService.getSingedPlansForSpace(this.spaceID);
+    }
+    async onPlanClick(plan) {
+        const switchPlan = () => {
+            this.selectionChanged = false;
+            this.chosenPlan = plan;
+            this.chosenScansOnPlan = [];
+            this.clearDivPlan();
+            this.addScanPoints();
+        };
+        if (this.selectionChanged) {
+            const message = this.translate.instant("confirm.cancelModifZoneSweeps");
+            if (window.confirm(message)) {
+                switchPlan();
+            }
+        }
+        else {
+            switchPlan();
+        }
+    }
+    async addScanPoints() {
+        let wasModified = false;
+        if (this.multipleFloors) {
+            // check if we have already validated buttons for this floor
+            if (this.chosenSweepsPerFloor.get(this.chosenPlan.zoneID)) {
+                this.chosenScansOnPlan = this.chosenSweepsPerFloor.get(this.chosenPlan.zoneID);
+                wasModified = true;
+            }
+        }
+        this.divPlan = document.querySelector("#planDiv");
+        const zoneOfPlan = await this.zoneService.getZone(this.chosenPlan.zoneID);
+        const navigations = await this.navigationService.getNavigationsForZone(zoneOfPlan);
+        if (this.newZoneData)
+            await this.setScanByDraw(navigations);
+        this.buttonElements = await showScanPointsOnPlanInDiv(this.chosenPlan, this.divPlan, navigations);
+        for (const element of this.buttonElements) {
+            if (this.unavailableSweeps && this.unavailableSweeps.includes(element.id)) {
+                styleButton(element, SweepState.DISABLED);
+            }
+            else {
+                if (wasModified) {
+                    if (this.chosenScansOnPlan.includes(element.id)) {
+                        styleButton(element, SweepState.ADDED);
+                    }
+                    else {
+                        styleButton(element, SweepState.REMOVED);
+                    }
+                }
+                else {
+                    if (this.navIDsZoneEdit.length > 0 &&
+                        this.navIDsZoneEdit.includes(element.id)) {
+                        styleButton(element, SweepState.ADDED);
+                        if (!this.chosenScansOnPlan.includes(element.id)) {
+                            this.chosenScansOnPlan.push(element.id);
+                        }
+                    }
+                    else if (this.occupiedSweeps && this.occupiedSweeps.includes(element.id)) {
+                        styleButton(element, SweepState.OCCUPIED);
+                    }
+                    else {
+                        styleButton(element, SweepState.REMOVED);
+                    }
+                }
+                //start point should be last condition 
+                if (this.inputZone && this.inputZone.startSweepID === element.id) {
+                    console.log("setting start point");
+                    styleButton(element, SweepState.STARTPOINT);
+                }
+                element.addEventListener("click", (event) => this.onButtonScanClicked(event.target));
+            }
+        }
+        this.panZoom = panzoom(this.divPlan, {
+            bounds: true,
+            boundsPadding: 0,
+            maxZoom: 3.5,
+            beforeMouseDown(e) {
+                return (e.button === 2); /** Ignore event for right click (use for selecting) */
+            },
+        });
+        if (this.multipleFloors) {
+            this.chosenSweepsPerFloor.set(this.chosenPlan.zoneID, [...this.chosenScansOnPlan]);
+        }
+    }
+    /** Function if we are coming for svg editor workflow */
+    setScanByDraw(navigations) {
+        return new Promise(async (resolve) => {
+            const rect = {
+                width: this.newZoneData.width,
+                height: this.newZoneData.height,
+            };
+            const img = await getMetaForImage(this.chosenPlan.filepath);
+            const { coeffX, coeffY } = getCoefficientsForImage(img, rect);
+            const draw = this.newZoneData.elements;
+            draw.map(async (element) => {
+                switch (element.nodeName) {
+                    case "rect":
+                        await this.setScanInRect(img, coeffX, coeffY, element, navigations);
+                        break;
+                    case "ellipse":
+                        await this.setScanInCircle(img, coeffX, coeffY, element, navigations);
+                        break;
+                    case "path":
+                        await this.setScanInPolygon(img, coeffX, coeffY, element, navigations);
+                        break;
+                    default:
+                        break;
+                }
+            });
+            resolve();
+        });
+    }
+    async setScanInRect(img, coeffX, coeffY, element, navigations) {
+        const calibrage = JSON.parse(this.chosenPlan.calibration);
+        navigations.map((navigation) => {
+            const positionsOnPlan = navigation.positionOnPlan.map((entry) => JSON.parse(entry));
+            const positionOnPlan = positionsOnPlan.find((data) => data.planID === this.chosenPlan.id);
+            if (positionOnPlan) {
+                const realWidth = img.width / coeffX;
+                const realHeight = img.height / coeffY;
+                const navY = (positionOnPlan.y * realHeight) / calibrage.imgHeight;
+                const navX = (positionOnPlan.x * realWidth) / calibrage.imgWidth;
+                if (navX > element.x &&
+                    navX < element.x + element.width &&
+                    navY > element.y &&
+                    navY < element.y + element.height &&
+                    !this.navIDsZoneEdit.includes(navigation.id)) {
+                    this.navIDsZoneEdit.push(navigation.id);
+                }
+            }
+            // old calibration:
+            // const position = JSON.parse(navigation.position);
+            // let navX = (calibrage.offsetX + position.x * calibrage.x) / coeffX;
+            // let navY = (calibrage.offsetY + position.z * calibrage.y) / coeffY;
+            // if (element.angle) {
+            //     const rotatePos = rotate(
+            //         { x: navX, y: navY },
+            //         { x: element.cx, y: element.cy },
+            //         element.angle,
+            //     );
+            //     navX = rotatePos.x;
+            //     navY = rotatePos.y;
+            // }
+            /**
+             * TODO calculer la rotation du rectangle
+             */
+            // if (
+            //     navX > element.x &&
+            //     navX < element.x + element.width &&
+            //     navY > element.y &&
+            //     navY < element.y + element.height &&
+            //     !this.navIDsZoneEdit.includes(navigation.id)
+            // ) {
+            //     this.navIDsZoneEdit.push(navigation.id);
+            // }
+        });
+    } // EO
+    async setScanInCircle(img, coeffX, coeffY, element, navigations) {
+        const calibrage = JSON.parse(this.chosenPlan.calibration);
+        navigations.map(navigation => {
+            const positionsOnPlan = navigation.positionOnPlan.map((entry) => JSON.parse(entry));
+            const positionOnPlan = positionsOnPlan.find((data) => data.planID === this.chosenPlan.id);
+            if (positionOnPlan) {
+                const realWidth = img.width / coeffX;
+                const realHeight = img.height / coeffY;
+                let navY = (positionOnPlan.y * realHeight) / calibrage.imgHeight;
+                let navX = (positionOnPlan.x * realWidth) / calibrage.imgWidth;
+                if (element.angle) {
+                    const rotatePos = rotate({ x: navX, y: navY }, { x: element.cx, y: element.cy }, element.angle);
+                    navX = rotatePos.x;
+                    navY = rotatePos.y;
+                }
+                const valueX = Math.pow(navX - element.cx, 2) / Math.pow(element.rx, 2);
+                const valueY = Math.pow(navY - element.cy, 2) / Math.pow(element.ry, 2);
+                const result = valueX + valueY;
+                if (result <= 1 && !this.navIDsZoneEdit.includes(navigation.id)) {
+                    this.navIDsZoneEdit.push(navigation.id);
+                }
+            }
+            // old calibration
+            // const position = JSON.parse(navigation.position);
+            // let navX = (calibrage.offsetX + position.x * calibrage.x) / coeffX;
+            // let navY = (calibrage.offsetY + position.z * calibrage.y) / coeffY;
+            // if (element.angle) {
+            //     const rotatePos = rotate(
+            //         { x: navX, y: navY },
+            //         { x: element.cx, y: element.cy },
+            //         element.angle,
+            //     );
+            //     navX = rotatePos.x;
+            //     navY = rotatePos.y;
+            // }
+            // const valueX =
+            //     Math.pow(navX - element.cx, 2) / Math.pow(element.rx, 2);
+            // const valueY =
+            //     Math.pow(navY - element.cy, 2) / Math.pow(element.ry, 2);
+            // const result = valueX + valueY;
+            // if (result <= 1 && !this.navIDsZoneEdit.includes(navigation.id)) {
+            //     this.navIDsZoneEdit.push(navigation.id);
+            // }
+        });
+    } // EO
+    async setScanInPolygon(img, coeffX, coeffY, element, navigations) {
+        const calibrage = JSON.parse(this.chosenPlan.calibration);
+        navigations.map(async (navigation) => {
+            const positionsOnPlan = navigation.positionOnPlan.map((entry) => JSON.parse(entry));
+            const positionOnPlan = positionsOnPlan.find((data) => data.planID === this.chosenPlan.id);
+            if (positionOnPlan) {
+                const realWidth = img.width / coeffX;
+                const realHeight = img.height / coeffY;
+                let navY = (positionOnPlan.y * realHeight) / calibrage.imgHeight;
+                let navX = (positionOnPlan.x * realWidth) / calibrage.imgWidth;
+                const p = {
+                    x: navX,
+                    y: navY,
+                };
+                if (isInPolygon(p, element.segList) &&
+                    !this.navIDsZoneEdit.includes(navigation.id)) {
+                    this.navIDsZoneEdit.push(navigation.id);
+                }
+            }
+            // old calibration
+            // const position = JSON.parse(navigation.position);
+            // const p = {
+            //     x: (calibrage.offsetX + position.x * calibrage.x) / coeffX,
+            //     y: (calibrage.offsetY + position.z * calibrage.y) / coeffY,
+            // };
+            // if (element.angle) {
+            //     p = this.rotate(
+            //         p,
+            //         { x: element.cx, y: element.cy },
+            //         element.angle,
+            //     );
+            // }
+            // if (
+            //     isInPolygon(p, element.segList) &&
+            //     !this.navIDsZoneEdit.includes(navigation.id)
+            // ) {
+            //     this.navIDsZoneEdit.push(navigation.id);
+            // }
+        });
+    }
+    clearDivPlan() {
+        if (this.divPlan)
+            this.divPlan.innerHTML = "";
+    }
+    /**
+     * Trigger each by the selectionComponent when selection change
+     * Update the current selected scan buttons
+     * @param selection new selection
+     */
+    onSelectionChanged(selection) {
+        const unselectedButtons = [];
+        const newSelectedButtons = [];
+        /** For each button, decide whether will be add to selected list or unselected list */
+        for (const button of this.buttonElements) {
+            const isSelected = buttonIsInSelection(button, selection);
+            if (this.buttonsInSelection.includes(button)) {
+                /** If the button is already in the selected list, we check if it should be unselect */
+                if (!isSelected) {
+                    unselectedButtons.push(button);
+                }
+            }
+            else if (isSelected) {
+                newSelectedButtons.push(button);
+            }
+        }
+        /** Visually Update unselected list */
+        for (const button of unselectedButtons) {
+            setVisuallySelected(button, false);
+        }
+        /** Visually Update selected list */
+        for (const button of newSelectedButtons) {
+            setVisuallySelected(button, true);
+        }
+        /** Remove  unselected list */
+        this.buttonsInSelection = this.buttonsInSelection.filter((button) => {
+            return !unselectedButtons.includes(button);
+        });
+        /** Add new selected buttons */
+        this.buttonsInSelection = [
+            ...this.buttonsInSelection,
+            ...newSelectedButtons,
+        ];
+    }
+    /**
+     * Trigger when the user click to add the selected scans
+     */
+    onSelectionAdd() {
+        for (const button of this.buttonsInSelection) {
+            if (!this.chosenScansOnPlan.includes(button.id)) {
+                this.onButtonScanClicked(button);
+            }
+        }
+        this.onSelectionChanged({ top: 0, left: 0, width: 0, height: 0 });
+    }
+    /**
+     * Trigger when the user click to remove the selected scans
+     */
+    onSelectionRemove() {
+        for (const button of this.buttonsInSelection) {
+            if (this.chosenScansOnPlan.includes(button.id)) {
+                this.onButtonScanClicked(button);
+            }
+        }
+        this.onSelectionChanged({ top: 0, left: 0, width: 0, height: 0 });
+    }
+    /**
+     * Trigger when the user click to select all scans
+     */
+    onSelectAll() {
+        this.buttonsInSelection = [...this.buttonElements];
+        for (const button of this.buttonsInSelection) {
+            setVisuallySelected(button, true);
+        }
+    }
+    /**
+     * Trigger when the user change the size of the scan points
+     * @param event
+     */
+    onChangeScanSize(event) {
+        const factor = event.target.value;
+        for (const button of this.buttonElements) {
+            button.style.transform = `scale(${factor})`;
+        }
+    }
+    /**
+     * When a button representing a scan is clicked
+     * @param button
+     */
+    onButtonScanClicked(button) {
+        this.selectionChanged = true;
+        if (this.isSettingStartSweep) {
+            if (this.startSweepID === button.id) {
+                // we deselect the starting point
+                button.style.backgroundImage = `url("https://api.iconify.design/mdi:adjust.svg?color=green&height=17&width=17")`;
+                this.startSweepID = null;
+                return;
+            }
+            button.style.backgroundImage = `url('https://api.iconify.design/ic/baseline-flag-circle.svg?color=white&width=17&height=17')`;
+            if (!this.chosenScansOnPlan.includes(button.id)) {
+                this.chosenScansOnPlan.push(button.id);
+            }
+            if (this.startSweepID) {
+                // we are changing start sweep
+                const btnChanged = this.buttonElements.find((btn) => btn.id === this.startSweepID);
+                btnChanged.style.backgroundImage = `url("https://api.iconify.design/mdi:adjust.svg?color=green&height=17&width=17")`;
+            }
+            this.startSweepID = button.id;
+            return;
+        }
+        if (!this.chosenScansOnPlan.includes(button.id)) {
+            // add to selection
+            button.style.backgroundImage = `url("https://api.iconify.design/mdi:adjust.svg?color=green&height=17&width=17")`;
+            this.chosenScansOnPlan.push(button.id);
+        }
+        else {
+            // remove from selection
+            if (this.occupiedSweeps.includes(button.id) && !this.navIDsZoneEdit.includes(button.id)) {
+                // the sweep belongs to another zone => set orange
+                button.style.backgroundImage = `url("https://api.iconify.design/mdi:adjust.svg?color=orange&height=17&width=17")`;
+            }
+            else {
+                button.style.backgroundImage = `url("https://api.iconify.design/mdi:close-circle-outline.svg?color=red&height=17&width=17")`;
+            }
+            const index = this.chosenScansOnPlan.indexOf(button.id);
+            this.chosenScansOnPlan.splice(index, 1);
+        }
+    }
+    onSaveSelection() {
+        if (this.multipleFloors) {
+            // rassemble all sweeps per floors
+            let finalSweeps = [];
+            Array.from(this.inputSweepsPerFloor.keys()).forEach(floorID => {
+                if (this.chosenSweepsPerFloor.get(floorID)) {
+                    // the sweeps for this floor were modified, we take them
+                    finalSweeps = [...finalSweeps, ...this.chosenSweepsPerFloor.get(floorID)];
+                }
+                else {
+                    // was not modified, we take the previous values
+                    finalSweeps = [...finalSweeps, ...this.inputSweepsPerFloor.get(floorID)];
+                }
+            });
+            // console.log("final sweeps", finalSweeps);
+            this.sweepsSelected.emit({ "sweeps": finalSweeps, "startSweepID": this.startSweepID });
+        }
+        else {
+            this.sweepsSelected.emit({ "sweeps": this.chosenScansOnPlan, "startSweepID": this.startSweepID });
+        }
+    }
+    onCancel() {
+        if (this.selectionChanged) {
+            const message = this.translate.instant("confirm.cancelModifZoneSweeps");
+            if (window.confirm(message)) {
+                this.sweepsSelected.emit(null);
+            }
+        }
+        else {
+            this.sweepsSelected.emit(null);
+        }
+    }
+    /**
+     * Adds current selection of sweeps for current floor (plan) for multifloor zone.
+     * It has to be saved anyway with onSaveSelection!
+     */
+    onValidateForFloor() {
+        if (this.multipleFloors) {
+            this.chosenSweepsPerFloor.set(this.chosenPlan.zoneID, [...this.chosenScansOnPlan]);
+            this.selectionChanged = false;
+        }
+    }
+}
+SweepPlanSelectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SweepPlanSelectionComponent, deps: [{ token: i1.ZoneService }, { token: i1.NavigationService }, { token: i1.PlanService }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+SweepPlanSelectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: SweepPlanSelectionComponent, selector: "lib-sweep-plan-selection", inputs: { spaceID: "spaceID", chosenScansOnPlan: "chosenScansOnPlan", newZoneData: "newZoneData", occupiedSweeps: "occupiedSweeps", unavailableSweeps: "unavailableSweeps", editingAudioZone: "editingAudioZone", inputZone: "inputZone", multipleFloors: "multipleFloors" }, outputs: { sweepsSelected: "sweepsSelected" }, usesOnChanges: true, ngImport: i0, template: "<div ngbDropdown class=\"sp-row d-inline-block\">\n    <div class=\"col-sm-3\" *ngIf=\"plans\">\n            <button type=\"button\" class=\"btn btn-label-file rounded-pill\" id=\"dropdownBasic1\"\n                ngbDropdownToggle>{{chosenPlan ?\n                chosenPlan.name : ('Choose Plan' | translate) }}</button>\n            <div ngbDropdownMenu aria-labelledby=\"dropdownBasic1\">\n                <button type=\"button\" ngbDropdownItem *ngFor=\"let plan of plans\" (click)=\"onPlanClick(plan)\"\n                    [disabled]=\"!plan.calibration\">{{ plan.name }}\n                </button>\n            </div>\n    </div>\n</div>\n<div class=\"sp-row\">\n    <lib-selection class=\"col-md-8\" (onSelectionChanged)=\"onSelectionChanged($event)\">\n        <lib-plan-legend [isAudioZone]=\"editingAudioZone\" *ngIf=\"buttonElements.length > 0\"></lib-plan-legend>\n        <div class=\"selectZone\" oncontextmenu=\"return false;\">\n            <div class=\"sp-row\">\n                <div style=\"overflow: hidden;width:100%;\">\n                    <div style=\"height: 400px; width: 100%;\" id=\"planDiv\">\n                    </div>\n                </div>\n            </div>\n        </div>\n    </lib-selection>\n    \n    <div class=\"col-md-4 scanTool\" *ngIf=\"buttonElements.length > 0\">\n        <div class=\"sp-row d-inline-block\">\n            <h2>{{'selectTool.title' | translate}}</h2>\n            <div class=\"protip\">{{'selectTool.tip' | translate}}.</div>\n        </div>\n    \n        <div class=\"sp-row\">\n            <div class=\"col-3\" style=\"padding:0px\">\n                <label class=\"tool-label\" for=\"scanSize\">{{'selectTool.size' | translate}}</label>\n            </div>\n            <div class=\"col-9\">\n                <input type=\"range\" class=\"form-range\" min=\"0.001\" max=\"5\" step=\"0.01\" value=\"1\"\n                    id=\"scanSize\" (input)=\"onChangeScanSize($event)\">\n            </div>\n        </div>\n    \n        <div class=\"sp-row\">\n            <button class=\"btn btn-primary rounded-pill\" (click)=\"onSelectAll()\">{{'selectTool.selectAll' | translate}}</button>\n        </div>\n    \n        <div *ngIf=\"buttonsInSelection.length > 0\" class=\"edit-selected\">\n            <span class=\"tool-label\">{{'selectTool.edit' | translate}} : </span>\n            <div class=\"sp-row\">\n                <button class=\"btn rounded-pill btn-primary ms-3 me-2\" (click)=\"onSelectionAdd()\">{{'selectTool.add' | translate}}</button>\n                <button class=\"btn btn-primary rounded-pill\" (click)=\"onSelectionRemove()\">{{'selectTool.undo' | translate}}</button>\n            </div>\n        </div>\n\n        <div class=\"sp-row\">\n            <div *ngIf=\"multipleFloors\"> \n                {{ chosenSweepsPerFloor.get(chosenPlan.zoneID) ? chosenSweepsPerFloor.get(chosenPlan.zoneID).length : \"0\"}} {{'scan points selected on this floor' | translate}} \n                <button class=\"btn btn-primary rounded-pill\" (click)=\"onValidateForFloor()\" [disabled]=\"!selectionChanged\">{{'Update selection for this floor' | translate}}</button>\n            </div>\n            <div *ngIf=\"!multipleFloors\">\n                {{ chosenScansOnPlan.length }} {{'scan points chosen' | translate}}  \n            </div>\n        </div>\n        <div *ngIf=\"!editingAudioZone\" class=\"sp-row\">\n            <lib-radio-button  label=\"{{ 'selectTool.chooseStartPoint'  | translate }}\" (isCheckedEvent)=\"isSettingStartSweep=!isSettingStartSweep\"></lib-radio-button>\n        </div>\n        <div class=\"sp-row\">\n            <button class=\"btn btn-primary rounded-pill\" (click)=\"onSaveSelection()\">{{'selectTool.saveSelection' | translate}}</button>\n            <button class=\"btn btn-outline-primary rounded-pill\" (click)=\"onCancel()\">{{'selectTool.cancelSelection' | translate}}</button>\n        </div>\n    </div>\n\n</div>\n   \n", styles: [".sp-row{display:flex;margin-bottom:1rem}.selectZone{border-radius:6px;overflow:hidden;background-color:var(--smarterplan-secondary)}.scanTool{margin:0px 1rem}.protip{color:gray;padding:0}.tool-label{font-size:1rem}\n"], components: [{ type: i3.SelectionComponent, selector: "lib-selection", outputs: ["onSelectionChanged"] }, { type: i4.PlanLegendComponent, selector: "lib-plan-legend", inputs: ["isAudioZone"] }, { type: i5.RadioButtonComponent, selector: "lib-radio-button", inputs: ["label"], outputs: ["isCheckedEvent"] }], directives: [{ type: i6.NgbDropdown, selector: "[ngbDropdown]", inputs: ["autoClose", "dropdownClass", "open", "placement", "container", "display"], outputs: ["openChange"], exportAs: ["ngbDropdown"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.NgbDropdownToggle, selector: "[ngbDropdownToggle]" }, { type: i6.NgbDropdownMenu, selector: "[ngbDropdownMenu]" }, { type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i6.NgbDropdownItem, selector: "[ngbDropdownItem]", inputs: ["disabled"] }], pipes: { "translate": i2.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SweepPlanSelectionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-sweep-plan-selection', template: "<div ngbDropdown class=\"sp-row d-inline-block\">\n    <div class=\"col-sm-3\" *ngIf=\"plans\">\n            <button type=\"button\" class=\"btn btn-label-file rounded-pill\" id=\"dropdownBasic1\"\n                ngbDropdownToggle>{{chosenPlan ?\n                chosenPlan.name : ('Choose Plan' | translate) }}</button>\n            <div ngbDropdownMenu aria-labelledby=\"dropdownBasic1\">\n                <button type=\"button\" ngbDropdownItem *ngFor=\"let plan of plans\" (click)=\"onPlanClick(plan)\"\n                    [disabled]=\"!plan.calibration\">{{ plan.name }}\n                </button>\n            </div>\n    </div>\n</div>\n<div class=\"sp-row\">\n    <lib-selection class=\"col-md-8\" (onSelectionChanged)=\"onSelectionChanged($event)\">\n        <lib-plan-legend [isAudioZone]=\"editingAudioZone\" *ngIf=\"buttonElements.length > 0\"></lib-plan-legend>\n        <div class=\"selectZone\" oncontextmenu=\"return false;\">\n            <div class=\"sp-row\">\n                <div style=\"overflow: hidden;width:100%;\">\n                    <div style=\"height: 400px; width: 100%;\" id=\"planDiv\">\n                    </div>\n                </div>\n            </div>\n        </div>\n    </lib-selection>\n    \n    <div class=\"col-md-4 scanTool\" *ngIf=\"buttonElements.length > 0\">\n        <div class=\"sp-row d-inline-block\">\n            <h2>{{'selectTool.title' | translate}}</h2>\n            <div class=\"protip\">{{'selectTool.tip' | translate}}.</div>\n        </div>\n    \n        <div class=\"sp-row\">\n            <div class=\"col-3\" style=\"padding:0px\">\n                <label class=\"tool-label\" for=\"scanSize\">{{'selectTool.size' | translate}}</label>\n            </div>\n            <div class=\"col-9\">\n                <input type=\"range\" class=\"form-range\" min=\"0.001\" max=\"5\" step=\"0.01\" value=\"1\"\n                    id=\"scanSize\" (input)=\"onChangeScanSize($event)\">\n            </div>\n        </div>\n    \n        <div class=\"sp-row\">\n            <button class=\"btn btn-primary rounded-pill\" (click)=\"onSelectAll()\">{{'selectTool.selectAll' | translate}}</button>\n        </div>\n    \n        <div *ngIf=\"buttonsInSelection.length > 0\" class=\"edit-selected\">\n            <span class=\"tool-label\">{{'selectTool.edit' | translate}} : </span>\n            <div class=\"sp-row\">\n                <button class=\"btn rounded-pill btn-primary ms-3 me-2\" (click)=\"onSelectionAdd()\">{{'selectTool.add' | translate}}</button>\n                <button class=\"btn btn-primary rounded-pill\" (click)=\"onSelectionRemove()\">{{'selectTool.undo' | translate}}</button>\n            </div>\n        </div>\n\n        <div class=\"sp-row\">\n            <div *ngIf=\"multipleFloors\"> \n                {{ chosenSweepsPerFloor.get(chosenPlan.zoneID) ? chosenSweepsPerFloor.get(chosenPlan.zoneID).length : \"0\"}} {{'scan points selected on this floor' | translate}} \n                <button class=\"btn btn-primary rounded-pill\" (click)=\"onValidateForFloor()\" [disabled]=\"!selectionChanged\">{{'Update selection for this floor' | translate}}</button>\n            </div>\n            <div *ngIf=\"!multipleFloors\">\n                {{ chosenScansOnPlan.length }} {{'scan points chosen' | translate}}  \n            </div>\n        </div>\n        <div *ngIf=\"!editingAudioZone\" class=\"sp-row\">\n            <lib-radio-button  label=\"{{ 'selectTool.chooseStartPoint'  | translate }}\" (isCheckedEvent)=\"isSettingStartSweep=!isSettingStartSweep\"></lib-radio-button>\n        </div>\n        <div class=\"sp-row\">\n            <button class=\"btn btn-primary rounded-pill\" (click)=\"onSaveSelection()\">{{'selectTool.saveSelection' | translate}}</button>\n            <button class=\"btn btn-outline-primary rounded-pill\" (click)=\"onCancel()\">{{'selectTool.cancelSelection' | translate}}</button>\n        </div>\n    </div>\n\n</div>\n   \n", styles: [".sp-row{display:flex;margin-bottom:1rem}.selectZone{border-radius:6px;overflow:hidden;background-color:var(--smarterplan-secondary)}.scanTool{margin:0px 1rem}.protip{color:gray;padding:0}.tool-label{font-size:1rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ZoneService }, { type: i1.NavigationService }, { type: i1.PlanService }, { type: i2.TranslateService }]; }, propDecorators: { spaceID: [{
+                type: Input
+            }], chosenScansOnPlan: [{
+                type: Input
+            }], newZoneData: [{
+                type: Input
+            }], occupiedSweeps: [{
+                type: Input
+            }], unavailableSweeps: [{
+                type: Input
+            }], editingAudioZone: [{
+                type: Input
+            }], inputZone: [{
+                type: Input
+            }], multipleFloors: [{
+                type: Input
+            }], sweepsSelected: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sweep-plan-selection.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-smarterplan-locations/src/lib/components/zones/add-zone/sweep-plan-selection/sweep-plan-selection.component.ts","../../../../../../../../projects/ngx-smarterplan-locations/src/lib/components/zones/add-zone/sweep-plan-selection/sweep-plan-selection.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { getCoefficientsForImage, getMetaForImage, Navigation, NavigationService, Plan, Zone, showScanPointsOnPlanInDiv, ZoneService, PlanService } from '@smarterplan/ngx-smarterplan-core';\nimport panzoom, { PanZoom } from 'panzoom';\nimport { buttonIsInSelection, isInPolygon, Rectangle, rotate, setVisuallySelected, styleButton, SweepState } from '../../../../helper.service';\n\n@Component({\n    selector: 'lib-sweep-plan-selection',\n    templateUrl: './sweep-plan-selection.component.html',\n    styleUrls: ['./sweep-plan-selection.component.scss']\n})\nexport class SweepPlanSelectionComponent implements OnInit {\n\n    plans: Plan[];\n\n    @Input() spaceID: string;\n\n    @Input() chosenScansOnPlan: string[] = [];\n\n    /** if comming from Edit Plan SVG Zone creation */\n    @Input() newZoneData: any;\n\n    navIDsZoneEdit: string[] = [];\n\n    // sweeps belonging to any audio zone\n    @Input() occupiedSweeps: string[] = [];\n\n    // sweeps unavailable (cannot be chosen)\n    @Input() unavailableSweeps: string[] = [];\n\n    // if choosing sweeps for audio zone\n    @Input() editingAudioZone: boolean = false;\n\n    @Input() inputZone: Zone;\n\n    @Input() multipleFloors: boolean = false;\n\n    chosenPlan: Plan;\n\n    /** panZoom element for adding scans */\n    panZoom: PanZoom;\n\n    /** divPlan (use By panZoom) */\n    divPlan: HTMLElement;\n\n    /** all scan buttons Element */\n    buttonElements: HTMLButtonElement[] = [];\n\n    /** Scan buttons that are in the current selection */\n    buttonsInSelection: HTMLButtonElement[] = [];\n\n    @Output() sweepsSelected = new EventEmitter<{ sweeps: string[]; startSweepID: string; }>();\n\n    isSettingStartSweep = false;\n\n    startSweepID: string;\n\n    chosenSweepsPerFloor = new Map<string, string[]>(); // map matching floorID to sweeps selected\n\n    inputSweepsPerFloor = new Map<string, string[]>(); // map matching floorID to sweeps selected for zone in edition\n\n    selectionChanged = false;\n\n    constructor(\n        private zoneService: ZoneService,\n        private navigationService: NavigationService,\n        private planService: PlanService,\n        private translate: TranslateService,\n    ) { }\n\n    async ngOnInit() {\n        await this.getPlans();\n        this.setSweepsOfInputZone();\n    }\n\n    ngOnChanges() {\n        if (this.chosenPlan) {\n            this.setSweepsOfInputZone();\n            this.chosenScansOnPlan = [];\n            this.clearDivPlan();\n            this.addScanPoints();\n        }\n    }\n\n    setSweepsOfInputZone() {\n        this.navIDsZoneEdit = this.inputZone ? this.inputZone.sweepIDs : [];\n        if (this.multipleFloors) {\n            this.plans.forEach((plan) => {\n                if (!this.inputSweepsPerFloor.get(plan.zoneID)) {\n                    this.inputSweepsPerFloor.set(plan.zoneID,\n                        this.navIDsZoneEdit.filter((sweep) => plan.zone.sweepIDs.includes(sweep)));\n                }\n            });\n        } else {\n            if (this.inputZone) {\n                //filter plans only for the parent Zone\n                this.plans = this.plans.filter((p) => p.zoneID === this.inputZone.parentID);\n            }\n        }\n    }\n\n    async getPlans() {\n        this.plans = await this.planService.getSingedPlansForSpace(\n            this.spaceID,\n        );\n    }\n\n    async onPlanClick(plan: Plan) {\n        const switchPlan = () => {\n            this.selectionChanged = false;\n            this.chosenPlan = plan;\n            this.chosenScansOnPlan = [];\n            this.clearDivPlan();\n            this.addScanPoints();\n        };\n        if (this.selectionChanged) {\n            const message = this.translate.instant(\"confirm.cancelModifZoneSweeps\");\n            if (window.confirm(message)) {\n                switchPlan();\n            }\n        } else {\n            switchPlan();\n        }\n    }\n\n    async addScanPoints() {\n        let wasModified = false;\n        if (this.multipleFloors) {\n            // check if we have already validated buttons for this floor\n            if (this.chosenSweepsPerFloor.get(this.chosenPlan.zoneID)) {\n                this.chosenScansOnPlan = this.chosenSweepsPerFloor.get(this.chosenPlan.zoneID);\n                wasModified = true;\n            }\n        }\n        this.divPlan = document.querySelector(\"#planDiv\") as HTMLElement;\n        const zoneOfPlan = await this.zoneService.getZone(\n            this.chosenPlan.zoneID,\n        );\n        const navigations = await this.navigationService.getNavigationsForZone(\n            zoneOfPlan,\n        );\n        if (this.newZoneData) await this.setScanByDraw(navigations);\n        this.buttonElements = await showScanPointsOnPlanInDiv(\n            this.chosenPlan,\n            this.divPlan,\n            navigations,\n        );\n        for (const element of this.buttonElements) {\n            if (this.unavailableSweeps && this.unavailableSweeps.includes(element.id)) {\n                styleButton(element, SweepState.DISABLED);\n            } else {\n\n                if (wasModified) {\n                    if (this.chosenScansOnPlan.includes(element.id)) {\n                        styleButton(element, SweepState.ADDED);\n                    } else {\n                        styleButton(element, SweepState.REMOVED);\n                    }\n                } else {\n                    if (\n                        this.navIDsZoneEdit.length > 0 &&\n                        this.navIDsZoneEdit.includes(element.id)) {\n                        styleButton(element, SweepState.ADDED);\n                        if (!this.chosenScansOnPlan.includes(element.id)) {\n                            this.chosenScansOnPlan.push(element.id);\n                        }\n                    } else if (this.occupiedSweeps && this.occupiedSweeps.includes(element.id)) {\n                        styleButton(element, SweepState.OCCUPIED);\n                    } else {\n                        styleButton(element, SweepState.REMOVED);\n                    }\n                }\n\n                //start point should be last condition \n                if (this.inputZone && this.inputZone.startSweepID === element.id) {\n                    console.log(\"setting start point\");\n                    styleButton(element, SweepState.STARTPOINT);\n                }\n                element.addEventListener(\"click\", (event) =>\n                    this.onButtonScanClicked(event.target as HTMLElement),\n                );\n            }\n        }\n        this.panZoom = panzoom(this.divPlan, {\n            bounds: true,\n            boundsPadding: 0,\n            maxZoom: 3.5,\n            beforeMouseDown(e: MouseEvent) {\n                return (\n                    e.button === 2\n                ); /** Ignore event for right click (use for selecting) */\n            },\n        });\n        if (this.multipleFloors) {\n            this.chosenSweepsPerFloor.set(this.chosenPlan.zoneID, [...this.chosenScansOnPlan]);\n        }\n    }\n\n    /** Function if we are coming for svg editor workflow */\n    setScanByDraw(navigations: any[]): Promise<void> {\n        return new Promise(async (resolve) => {\n            const rect = {\n                width: this.newZoneData.width,\n                height: this.newZoneData.height,\n            };\n            const img = await getMetaForImage(this.chosenPlan.filepath);\n            const { coeffX, coeffY } = getCoefficientsForImage(img, rect);\n\n            const draw = this.newZoneData.elements;\n\n            draw.map(async (element: any) => {\n                switch (element.nodeName) {\n                    case \"rect\":\n                        await this.setScanInRect(\n                            img,\n                            coeffX,\n                            coeffY,\n                            element,\n                            navigations,\n                        );\n                        break;\n\n                    case \"ellipse\":\n                        await this.setScanInCircle(\n                            img,\n                            coeffX,\n                            coeffY,\n                            element,\n                            navigations,\n                        );\n                        break;\n\n                    case \"path\":\n                        await this.setScanInPolygon(\n                            img,\n                            coeffX,\n                            coeffY,\n                            element,\n                            navigations,\n                        );\n                        break;\n                    default:\n                        break;\n                }\n            });\n\n            resolve();\n        });\n    }\n\n    async setScanInRect(img: any, coeffX: number, coeffY: number,\n        element: { angle: any; cx: any; cy: any; x: number; width: any; y: number; height: any; }, navigations: any[]) {\n        const calibrage = JSON.parse(this.chosenPlan.calibration);\n        navigations.map((navigation) => {\n            const positionsOnPlan = navigation.positionOnPlan.map((entry) =>\n                JSON.parse(entry),\n            );\n            const positionOnPlan = positionsOnPlan.find(\n                (data) => data.planID === this.chosenPlan.id,\n            );\n            if (positionOnPlan) {\n                const realWidth = img.width / coeffX;\n                const realHeight = img.height / coeffY;\n                const navY = (positionOnPlan.y * realHeight) / calibrage.imgHeight;\n                const navX = (positionOnPlan.x * realWidth) / calibrage.imgWidth;\n                if (\n                    navX > element.x &&\n                    navX < element.x + element.width &&\n                    navY > element.y &&\n                    navY < element.y + element.height &&\n                    !this.navIDsZoneEdit.includes(navigation.id)\n                ) {\n                    this.navIDsZoneEdit.push(navigation.id);\n                }\n            }\n\n            // old calibration:\n            // const position = JSON.parse(navigation.position);\n            // let navX = (calibrage.offsetX + position.x * calibrage.x) / coeffX;\n            // let navY = (calibrage.offsetY + position.z * calibrage.y) / coeffY;\n            // if (element.angle) {\n            //     const rotatePos = rotate(\n            //         { x: navX, y: navY },\n            //         { x: element.cx, y: element.cy },\n            //         element.angle,\n            //     );\n            //     navX = rotatePos.x;\n            //     navY = rotatePos.y;\n            // }\n            /**\n             * TODO calculer la rotation du rectangle\n             */\n            // if (\n            //     navX > element.x &&\n            //     navX < element.x + element.width &&\n            //     navY > element.y &&\n            //     navY < element.y + element.height &&\n            //     !this.navIDsZoneEdit.includes(navigation.id)\n            // ) {\n            //     this.navIDsZoneEdit.push(navigation.id);\n            // }\n        });\n    } // EO\n\n    async setScanInCircle(img: any, coeffX: number, coeffY: number,\n        element: { angle: any; cx: number; cy: number; rx: number; ry: number; }, navigations: Navigation[]) {\n        const calibrage = JSON.parse(this.chosenPlan.calibration);\n        navigations.map(navigation => {\n            const positionsOnPlan = navigation.positionOnPlan.map((entry) =>\n                JSON.parse(entry),\n            );\n            const positionOnPlan = positionsOnPlan.find(\n                (data) => data.planID === this.chosenPlan.id,\n            );\n            if (positionOnPlan) {\n                const realWidth = img.width / coeffX;\n                const realHeight = img.height / coeffY;\n                let navY = (positionOnPlan.y * realHeight) / calibrage.imgHeight;\n                let navX = (positionOnPlan.x * realWidth) / calibrage.imgWidth;\n                if (element.angle) {\n                    const rotatePos = rotate(\n                        { x: navX, y: navY },\n                        { x: element.cx, y: element.cy },\n                        element.angle,\n                    );\n                    navX = rotatePos.x;\n                    navY = rotatePos.y;\n                }\n\n                const valueX =\n                    Math.pow(navX - element.cx, 2) / Math.pow(element.rx, 2);\n                const valueY =\n                    Math.pow(navY - element.cy, 2) / Math.pow(element.ry, 2);\n                const result = valueX + valueY;\n                if (result <= 1 && !this.navIDsZoneEdit.includes(navigation.id)) {\n                    this.navIDsZoneEdit.push(navigation.id);\n                }\n            }\n\n            // old calibration\n            // const position = JSON.parse(navigation.position);\n            // let navX = (calibrage.offsetX + position.x * calibrage.x) / coeffX;\n            // let navY = (calibrage.offsetY + position.z * calibrage.y) / coeffY;\n            // if (element.angle) {\n            //     const rotatePos = rotate(\n            //         { x: navX, y: navY },\n            //         { x: element.cx, y: element.cy },\n            //         element.angle,\n            //     );\n            //     navX = rotatePos.x;\n            //     navY = rotatePos.y;\n            // }\n\n            // const valueX =\n            //     Math.pow(navX - element.cx, 2) / Math.pow(element.rx, 2);\n            // const valueY =\n            //     Math.pow(navY - element.cy, 2) / Math.pow(element.ry, 2);\n            // const result = valueX + valueY;\n            // if (result <= 1 && !this.navIDsZoneEdit.includes(navigation.id)) {\n            //     this.navIDsZoneEdit.push(navigation.id);\n            // }\n        });\n    } // EO\n\n    async setScanInPolygon(img: any, coeffX: number, coeffY: number, element: { segList: any; }, navigations: any[]) {\n        const calibrage = JSON.parse(this.chosenPlan.calibration);\n        navigations.map(async (navigation) => {\n\n            const positionsOnPlan = navigation.positionOnPlan.map((entry) =>\n                JSON.parse(entry),\n            );\n            const positionOnPlan = positionsOnPlan.find(\n                (data) => data.planID === this.chosenPlan.id,\n            );\n            if (positionOnPlan) {\n                const realWidth = img.width / coeffX;\n                const realHeight = img.height / coeffY;\n                let navY = (positionOnPlan.y * realHeight) / calibrage.imgHeight;\n                let navX = (positionOnPlan.x * realWidth) / calibrage.imgWidth;\n\n                const p = {\n                    x: navX,\n                    y: navY,\n                };\n                if (\n                    isInPolygon(p, element.segList) &&\n                    !this.navIDsZoneEdit.includes(navigation.id)\n                ) {\n                    this.navIDsZoneEdit.push(navigation.id);\n                }\n            }\n\n            // old calibration\n            // const position = JSON.parse(navigation.position);\n            // const p = {\n            //     x: (calibrage.offsetX + position.x * calibrage.x) / coeffX,\n            //     y: (calibrage.offsetY + position.z * calibrage.y) / coeffY,\n            // };\n            // if (element.angle) {\n            //     p = this.rotate(\n            //         p,\n            //         { x: element.cx, y: element.cy },\n            //         element.angle,\n            //     );\n            // }\n            // if (\n            //     isInPolygon(p, element.segList) &&\n            //     !this.navIDsZoneEdit.includes(navigation.id)\n            // ) {\n            //     this.navIDsZoneEdit.push(navigation.id);\n            // }\n        });\n    }\n\n    clearDivPlan() {\n        if (this.divPlan) this.divPlan.innerHTML = \"\";\n    }\n\n\n    /**\n     * Trigger each by the selectionComponent when selection change\n     * Update the current selected scan buttons\n     * @param selection new selection\n     */\n    onSelectionChanged(selection: Rectangle) {\n        const unselectedButtons: HTMLButtonElement[] = [];\n        const newSelectedButtons = [];\n\n        /** For each button, decide whether will be add to selected list or unselected list */\n        for (const button of this.buttonElements) {\n            const isSelected = buttonIsInSelection(button, selection);\n            if (this.buttonsInSelection.includes(button)) {\n                /** If the button is already in the selected list, we check if it should be unselect */\n                if (!isSelected) {\n                    unselectedButtons.push(button);\n                }\n            } else if (isSelected) {\n                newSelectedButtons.push(button);\n            }\n        }\n\n        /** Visually Update unselected list */\n        for (const button of unselectedButtons) {\n            setVisuallySelected(button, false);\n        }\n\n        /** Visually Update selected list */\n        for (const button of newSelectedButtons) {\n            setVisuallySelected(button, true);\n        }\n\n        /** Remove  unselected list */\n        this.buttonsInSelection = this.buttonsInSelection.filter((button) => {\n            return !unselectedButtons.includes(button);\n        });\n        /** Add new selected buttons */\n        this.buttonsInSelection = [\n            ...this.buttonsInSelection,\n            ...newSelectedButtons,\n        ];\n    }\n\n\n\n    /**\n     * Trigger when the user click to add the selected scans\n     */\n    onSelectionAdd() {\n        for (const button of this.buttonsInSelection) {\n            if (!this.chosenScansOnPlan.includes(button.id)) {\n                this.onButtonScanClicked(button);\n            }\n        }\n\n        this.onSelectionChanged({ top: 0, left: 0, width: 0, height: 0 });\n    }\n\n    /**\n     * Trigger when the user click to remove the selected scans\n     */\n    onSelectionRemove() {\n        for (const button of this.buttonsInSelection) {\n            if (this.chosenScansOnPlan.includes(button.id)) {\n                this.onButtonScanClicked(button);\n            }\n        }\n        this.onSelectionChanged({ top: 0, left: 0, width: 0, height: 0 });\n    }\n\n    /**\n     * Trigger when the user click to select all scans\n     */\n    onSelectAll() {\n        this.buttonsInSelection = [...this.buttonElements];\n        for (const button of this.buttonsInSelection) {\n            setVisuallySelected(button, true);\n        }\n    }\n\n    /**\n     * Trigger when the user change the size of the scan points\n     * @param event\n     */\n    onChangeScanSize(event: any) {\n        const factor = event.target.value;\n\n        for (const button of this.buttonElements) {\n            button.style.transform = `scale(${factor})`;\n        }\n    }\n\n    /**\n     * When a button representing a scan is clicked\n     * @param button\n     */\n    onButtonScanClicked(button: HTMLElement) {\n        this.selectionChanged = true;\n        if (this.isSettingStartSweep) {\n            if (this.startSweepID === button.id) {\n                // we deselect the starting point\n                button.style.backgroundImage = `url(\"https://api.iconify.design/mdi:adjust.svg?color=green&height=17&width=17\")`;\n                this.startSweepID = null;\n                return;\n            }\n            button.style.backgroundImage = `url('https://api.iconify.design/ic/baseline-flag-circle.svg?color=white&width=17&height=17')`;\n            if (!this.chosenScansOnPlan.includes(button.id)) {\n                this.chosenScansOnPlan.push(button.id);\n            }\n            if (this.startSweepID) {\n                // we are changing start sweep\n                const btnChanged = this.buttonElements.find((btn) => btn.id === this.startSweepID);\n                btnChanged.style.backgroundImage = `url(\"https://api.iconify.design/mdi:adjust.svg?color=green&height=17&width=17\")`;\n            }\n            this.startSweepID = button.id;\n            return;\n        }\n        if (!this.chosenScansOnPlan.includes(button.id)) {\n            // add to selection\n            button.style.backgroundImage = `url(\"https://api.iconify.design/mdi:adjust.svg?color=green&height=17&width=17\")`;\n            this.chosenScansOnPlan.push(button.id);\n        } else {\n            // remove from selection\n            if (this.occupiedSweeps.includes(button.id) && !this.navIDsZoneEdit.includes(button.id)) {\n                // the sweep belongs to another zone => set orange\n                button.style.backgroundImage = `url(\"https://api.iconify.design/mdi:adjust.svg?color=orange&height=17&width=17\")`;\n            } else {\n                button.style.backgroundImage = `url(\"https://api.iconify.design/mdi:close-circle-outline.svg?color=red&height=17&width=17\")`;\n            }\n            const index = this.chosenScansOnPlan.indexOf(button.id);\n            this.chosenScansOnPlan.splice(index, 1);\n        }\n    }\n\n    onSaveSelection() {\n        if (this.multipleFloors) {\n            // rassemble all sweeps per floors\n            let finalSweeps = [];\n            Array.from(this.inputSweepsPerFloor.keys()).forEach(floorID => {\n                if (this.chosenSweepsPerFloor.get(floorID)) {\n                    // the sweeps for this floor were modified, we take them\n                    finalSweeps = [...finalSweeps, ...this.chosenSweepsPerFloor.get(floorID)];\n                } else {\n                    // was not modified, we take the previous values\n                    finalSweeps = [...finalSweeps, ...this.inputSweepsPerFloor.get(floorID)];\n                }\n            });\n            // console.log(\"final sweeps\", finalSweeps);\n            this.sweepsSelected.emit({ \"sweeps\": finalSweeps, \"startSweepID\": this.startSweepID });\n        } else {\n            this.sweepsSelected.emit({ \"sweeps\": this.chosenScansOnPlan, \"startSweepID\": this.startSweepID });\n        }\n    }\n\n    onCancel() {\n        if (this.selectionChanged) {\n            const message = this.translate.instant(\"confirm.cancelModifZoneSweeps\");\n            if (window.confirm(message)) {\n                this.sweepsSelected.emit(null);\n            }\n        } else {\n            this.sweepsSelected.emit(null);\n        }\n    }\n\n    /**\n     * Adds current selection of sweeps for current floor (plan) for multifloor zone.\n     * It has to be saved anyway with onSaveSelection!\n     */\n    onValidateForFloor() {\n        if (this.multipleFloors) {\n            this.chosenSweepsPerFloor.set(this.chosenPlan.zoneID, [...this.chosenScansOnPlan]);\n            this.selectionChanged = false;\n        }\n    }\n}\n","<div ngbDropdown class=\"sp-row d-inline-block\">\n    <div class=\"col-sm-3\" *ngIf=\"plans\">\n            <button type=\"button\" class=\"btn btn-label-file rounded-pill\" id=\"dropdownBasic1\"\n                ngbDropdownToggle>{{chosenPlan ?\n                chosenPlan.name : ('Choose Plan' | translate) }}</button>\n            <div ngbDropdownMenu aria-labelledby=\"dropdownBasic1\">\n                <button type=\"button\" ngbDropdownItem *ngFor=\"let plan of plans\" (click)=\"onPlanClick(plan)\"\n                    [disabled]=\"!plan.calibration\">{{ plan.name }}\n                </button>\n            </div>\n    </div>\n</div>\n<div class=\"sp-row\">\n    <lib-selection class=\"col-md-8\" (onSelectionChanged)=\"onSelectionChanged($event)\">\n        <lib-plan-legend [isAudioZone]=\"editingAudioZone\" *ngIf=\"buttonElements.length > 0\"></lib-plan-legend>\n        <div class=\"selectZone\" oncontextmenu=\"return false;\">\n            <div class=\"sp-row\">\n                <div style=\"overflow: hidden;width:100%;\">\n                    <div style=\"height: 400px; width: 100%;\" id=\"planDiv\">\n                    </div>\n                </div>\n            </div>\n        </div>\n    </lib-selection>\n    \n    <div class=\"col-md-4 scanTool\" *ngIf=\"buttonElements.length > 0\">\n        <div class=\"sp-row d-inline-block\">\n            <h2>{{'selectTool.title' | translate}}</h2>\n            <div class=\"protip\">{{'selectTool.tip' | translate}}.</div>\n        </div>\n    \n        <div class=\"sp-row\">\n            <div class=\"col-3\" style=\"padding:0px\">\n                <label class=\"tool-label\" for=\"scanSize\">{{'selectTool.size' | translate}}</label>\n            </div>\n            <div class=\"col-9\">\n                <input type=\"range\" class=\"form-range\" min=\"0.001\" max=\"5\" step=\"0.01\" value=\"1\"\n                    id=\"scanSize\" (input)=\"onChangeScanSize($event)\">\n            </div>\n        </div>\n    \n        <div class=\"sp-row\">\n            <button class=\"btn btn-primary rounded-pill\" (click)=\"onSelectAll()\">{{'selectTool.selectAll' | translate}}</button>\n        </div>\n    \n        <div *ngIf=\"buttonsInSelection.length > 0\" class=\"edit-selected\">\n            <span class=\"tool-label\">{{'selectTool.edit' | translate}} : </span>\n            <div class=\"sp-row\">\n                <button class=\"btn rounded-pill btn-primary ms-3 me-2\" (click)=\"onSelectionAdd()\">{{'selectTool.add' | translate}}</button>\n                <button class=\"btn btn-primary rounded-pill\" (click)=\"onSelectionRemove()\">{{'selectTool.undo' | translate}}</button>\n            </div>\n        </div>\n\n        <div class=\"sp-row\">\n            <div *ngIf=\"multipleFloors\"> \n                {{ chosenSweepsPerFloor.get(chosenPlan.zoneID) ? chosenSweepsPerFloor.get(chosenPlan.zoneID).length : \"0\"}} {{'scan points selected on this floor' | translate}} \n                <button class=\"btn btn-primary rounded-pill\" (click)=\"onValidateForFloor()\" [disabled]=\"!selectionChanged\">{{'Update selection for this floor' | translate}}</button>\n            </div>\n            <div *ngIf=\"!multipleFloors\">\n                {{ chosenScansOnPlan.length }} {{'scan points chosen' | translate}}  \n            </div>\n        </div>\n        <div *ngIf=\"!editingAudioZone\" class=\"sp-row\">\n            <lib-radio-button  label=\"{{ 'selectTool.chooseStartPoint'  | translate }}\" (isCheckedEvent)=\"isSettingStartSweep=!isSettingStartSweep\"></lib-radio-button>\n        </div>\n        <div class=\"sp-row\">\n            <button class=\"btn btn-primary rounded-pill\" (click)=\"onSaveSelection()\">{{'selectTool.saveSelection' | translate}}</button>\n            <button class=\"btn btn-outline-primary rounded-pill\" (click)=\"onCancel()\">{{'selectTool.cancelSelection' | translate}}</button>\n        </div>\n    </div>\n\n</div>\n   \n"]}