@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/vr.service.js

@@ -0,0 +1,198 @@
+import { Injectable } from '@angular/core';
+import { BufferGeometry, Group, Line, Matrix4, PerspectiveCamera, Raycaster, Vector3 } from 'three';
+import { XRControllerModelFactory } from 'three/examples/jsm/webxr/XRControllerModelFactory';
+import * as THREE from 'three';
+import { Reticle } from '../../../core/model/xr-reticle';
+import { isNill } from '../../../core/utils/function/is-nill.function';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { ItemGroup } from '../items/item-group';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/view-mode.service";
+export class VrService {
+    constructor(_viewModeService) {
+        this._viewModeService = _viewModeService;
+    }
+    init(scene, renderer) {
+        if (isNill(this._scene)) {
+            this._scene = scene;
+            this._renderer = renderer;
+            this._camera = new PerspectiveCamera(50, window.innerWidth / window.innerHeight, 0.1, 10);
+            this._raycaster = new Raycaster();
+            this._reticle = new Reticle();
+            this._tempMatrix = new Matrix4();
+            this._meshes = [];
+            this._user = new Group();
+            this._user.name = 'user-group';
+            this._user.add(this._camera);
+            this._scene.add(this._user, this._reticle);
+            this._createControllers();
+        }
+        this._initSession();
+    }
+    render() {
+        this._handleIntersections();
+        this._renderer.render(this._scene, this._camera);
+    }
+    endSession() {
+        if (this._session) {
+            this._session.end();
+        }
+    }
+    _initSession() {
+        if (!this._session) {
+            const sessionInit = { optionalFeatures: ['local-floor', 'bounded-floor'] };
+            navigator.xr.requestSession('immersive-vr', sessionInit).then((session) => {
+                this._onSessionStarted(session);
+                this.startVRSession();
+            });
+        }
+    }
+    _onSessionStarted(session) {
+        session.addEventListener('end', this._onSessionEnded.bind(this));
+        this._renderer.xr.setSession(session);
+        this._renderer.xr.enabled = true;
+        this._session = session;
+    }
+    _onSessionEnded() {
+        this._session = null;
+        this._viewModeService.viewMode = ViewMode.RoomPlan3D;
+        this._renderer.xr.enabled = false;
+    }
+    startVRSession() {
+        this._registerMeshes();
+    }
+    _createControllers() {
+        this._controller0 = this._renderer.xr.getController(0);
+        this._controller0.addEventListener('selectstart', (event) => this._onSelectStart(event));
+        this._controller0.addEventListener('selectend', (event) => this._onSelectEnd(event));
+        this._user.add(this._controller0);
+        this._controller1 = this._renderer.xr.getController(1);
+        this._controller1.addEventListener('selectstart', (event) => this._onSelectStart(event));
+        this._controller1.addEventListener('selectend', (event) => this._onSelectEnd(event));
+        this._user.add(this._controller1);
+        const controllerModelFactory = new XRControllerModelFactory();
+        const controllerGrip1 = this._renderer.xr.getControllerGrip(0);
+        controllerGrip1.add(controllerModelFactory.createControllerModel(controllerGrip1));
+        this._user.add(controllerGrip1);
+        const controllerGrip2 = this._renderer.xr.getControllerGrip(1);
+        controllerGrip2.add(controllerModelFactory.createControllerModel(controllerGrip2));
+        this._user.add(controllerGrip2);
+        const geometry = new BufferGeometry().setFromPoints([new Vector3(0, 0, 0), new Vector3(0, 0, -1)]);
+        const line = new Line(geometry);
+        line.name = 'line';
+        line.scale.z = 10;
+        // Only add line to controller0 when debugging with WebXR chrome extension
+        // this._controller0.add( line.clone() );
+        this._controller1.add(line.clone());
+    }
+    _onSelectStart(event) {
+        if (this._isObjectFloor(this._currentClosestIntersection.object)) {
+            this._user.position.set(this._currentClosestIntersection.point.x, 0, this._currentClosestIntersection.point.z);
+            this._controller0.updateMatrix();
+        }
+    }
+    _onSelectEnd(event) {
+        // Function can be used to clean up after _onSelectStart
+    }
+    _getIntersections(controller, group) {
+        this._tempMatrix.identity().extractRotation(controller.matrixWorld);
+        this._raycaster.ray.origin.setFromMatrixPosition(controller.matrixWorld);
+        this._raycaster.ray.direction.set(0, 0, -1).applyMatrix4(this._tempMatrix);
+        return this._raycaster.intersectObjects(group);
+    }
+    _registerMeshes() {
+        this._scene.traverse((mesh) => {
+            this._meshes.push(mesh);
+        });
+    }
+    _handleIntersections() {
+        if (this._renderer.xr.getController(1).visible) {
+            this._handleControllerIntersections(this._controller1);
+        }
+        else {
+            this._handleControllerIntersections(this._controller0);
+        }
+    }
+    _handleControllerIntersections(controller) {
+        const objectIntersections = this._getIntersections(controller, this._meshes);
+        if (objectIntersections.length > 0) {
+            const nearestIntersection = this._getNearestIntersection(objectIntersections);
+            if (nearestIntersection !== null) {
+                this._currentClosestIntersection = nearestIntersection;
+                const nearestObjectParent = this._getParentOfChild(nearestIntersection.object);
+                if (this._isObjectFloor(nearestIntersection.object)) {
+                    this._handleFloorIntersection(controller, nearestIntersection);
+                }
+                else if (nearestObjectParent) {
+                    this._updateObjectSelection(nearestObjectParent);
+                    this._handleObjectIntersection(controller, nearestIntersection);
+                }
+                else {
+                    this._handleNoIntersections(controller);
+                }
+            }
+        }
+    }
+    _getNearestIntersection(intersections) {
+        let nearest = null;
+        for (const intersection of intersections) {
+            // TODO: need a better solution for first if-statement
+            if (intersection.object.name && (intersection.object.name === 'home' || intersection.object.name === 'line')
+                || (intersection.object.parent && intersection.object.parent instanceof Reticle)) {
+                // DO NOTHING
+            }
+            else if (nearest === null || intersection.distance < nearest.distance) {
+                nearest = intersection;
+            }
+        }
+        return nearest;
+    }
+    _handleFloorIntersection(controller, intersection) {
+        this._updateControllerRay(controller, intersection.distance);
+        this._reticle.visible = true;
+        this._reticle.position.copy(intersection.point);
+    }
+    _handleObjectIntersection(controller, intersection) {
+        this._updateControllerRay(controller, intersection.distance);
+        this._reticle.visible = false;
+    }
+    _handleNoIntersections(controller) {
+        this._reticle.visible = false;
+        this._updateControllerRay(controller, 0);
+    }
+    _updateControllerRay(controller, rayLenght) {
+        const line = controller.getObjectByName('line');
+        if (line) {
+            line.scale.z = rayLenght;
+        }
+    }
+    _isObjectFloor(object) {
+        return object.name && object.name === 'floor-plane';
+    }
+    _getParentOfChild(object) {
+        // TODO: return null if object is not selectable
+        if (!object.parent || (object.parent instanceof THREE.Scene) || (object.parent instanceof ItemGroup)
+            || (object.parent instanceof Reticle)) {
+            return object;
+        }
+        else {
+            return this._getParentOfChild(object.parent);
+        }
+    }
+    _updateObjectSelection(object) {
+        if (!this._selectedObject) {
+            this._selectedObject = object;
+        }
+        // Do something with newly selected item
+        // ...
+    }
+}
+VrService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VrService, deps: [{ token: i1.ViewModeService }], target: i0.ɵɵFactoryTarget.Injectable });
+VrService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VrService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VrService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ViewModeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vr.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/vr.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n  BufferGeometry,\r\n  Group, Intersection,\r\n  Line,\r\n  Matrix4,\r\n  Mesh,\r\n  Object3D,\r\n  PerspectiveCamera,\r\n  Raycaster,\r\n  Scene,\r\n  Vector3,\r\n  WebGLRenderer\r\n} from 'three';\r\nimport {XRControllerModelFactory} from 'three/examples/jsm/webxr/XRControllerModelFactory';\r\nimport * as THREE from 'three';\r\nimport {Reticle} from '../../../core/model/xr-reticle';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {isNill} from '../../../core/utils/function/is-nill.function';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\nimport {ItemGroup} from '../items/item-group';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class VrService {\r\n\r\n  private _scene: Scene;\r\n  private _renderer: WebGLRenderer;\r\n  private _camera: PerspectiveCamera;\r\n\r\n  private _tempMatrix: Matrix4;\r\n  private _currentClosestIntersection: Intersection;\r\n  private _meshes: Mesh[];\r\n  private _raycaster: Raycaster;\r\n  private _reticle: Reticle;\r\n\r\n  private _controller0;\r\n  private _controller1;\r\n\r\n  private _session: any;\r\n  private _user: Group;\r\n\r\n  private _selectedObject: any;\r\n\r\n  constructor(private _viewModeService: ViewModeService) {}\r\n\r\n  public init(scene: Scene, renderer: WebGLRenderer) {\r\n    if (isNill(this._scene)) {\r\n      this._scene = scene;\r\n      this._renderer = renderer;\r\n      this._camera = new PerspectiveCamera(50, window.innerWidth / window.innerHeight, 0.1, 10);\r\n      this._raycaster = new Raycaster();\r\n      this._reticle = new Reticle();\r\n      this._tempMatrix = new Matrix4();\r\n      this._meshes = [];\r\n\r\n      this._user = new Group();\r\n      this._user.name = 'user-group';\r\n      this._user.add(this._camera);\r\n      this._scene.add(this._user, this._reticle);\r\n\r\n      this._createControllers();\r\n    }\r\n\r\n    this._initSession();\r\n  }\r\n\r\n  public render() {\r\n    this._handleIntersections();\r\n    this._renderer.render(this._scene, this._camera);\r\n  }\r\n\r\n  public endSession() {\r\n    if (this._session) {\r\n      this._session.end();\r\n    }\r\n  }\r\n\r\n  private _initSession() {\r\n    if (!this._session) {\r\n      const sessionInit = { optionalFeatures: [ 'local-floor', 'bounded-floor' ] };\r\n      (navigator as any).xr.requestSession('immersive-vr', sessionInit).then((session) => {\r\n        this._onSessionStarted(session);\r\n        this.startVRSession();\r\n      });\r\n    }\r\n  }\r\n\r\n  private _onSessionStarted(session: any) {\r\n    session.addEventListener('end', this._onSessionEnded.bind(this));\r\n    this._renderer.xr.setSession( session );\r\n    this._renderer.xr.enabled = true;\r\n    this._session = session;\r\n  }\r\n\r\n  private _onSessionEnded() {\r\n    this._session = null;\r\n    this._viewModeService.viewMode = ViewMode.RoomPlan3D;\r\n    this._renderer.xr.enabled = false;\r\n  }\r\n\r\n  public startVRSession() {\r\n    this._registerMeshes();\r\n  }\r\n\r\n  private _createControllers() {\r\n    this._controller0 = this._renderer.xr.getController( 0 );\r\n    this._controller0.addEventListener( 'selectstart', (event) => this._onSelectStart(event) );\r\n    this._controller0.addEventListener( 'selectend', (event) => this._onSelectEnd(event) );\r\n    this._user.add( this._controller0 );\r\n\r\n    this._controller1 = this._renderer.xr.getController( 1 );\r\n    this._controller1.addEventListener( 'selectstart', (event) => this._onSelectStart(event) );\r\n    this._controller1.addEventListener( 'selectend', (event) => this._onSelectEnd(event) );\r\n    this._user.add( this._controller1 );\r\n\r\n    const controllerModelFactory = new XRControllerModelFactory();\r\n\r\n    const controllerGrip1 = this._renderer.xr.getControllerGrip( 0 );\r\n    controllerGrip1.add( controllerModelFactory.createControllerModel( controllerGrip1 ) );\r\n    this._user.add( controllerGrip1 );\r\n\r\n    const controllerGrip2 = this._renderer.xr.getControllerGrip( 1 );\r\n    controllerGrip2.add( controllerModelFactory.createControllerModel( controllerGrip2 ) );\r\n    this._user.add( controllerGrip2 );\r\n\r\n    const geometry = new BufferGeometry().setFromPoints( [ new Vector3( 0, 0, 0 ), new Vector3( 0, 0, - 1 ) ] );\r\n\r\n    const line = new Line( geometry );\r\n    line.name = 'line';\r\n    line.scale.z = 10;\r\n\r\n    // Only add line to controller0 when debugging with WebXR chrome extension\r\n    // this._controller0.add( line.clone() );\r\n    this._controller1.add( line.clone() );\r\n  }\r\n\r\n  private _onSelectStart( event ) {\r\n    if (this._isObjectFloor(this._currentClosestIntersection.object)) {\r\n      this._user.position.set(this._currentClosestIntersection.point.x, 0, this._currentClosestIntersection.point.z);\r\n      this._controller0.updateMatrix();\r\n    }\r\n  }\r\n\r\n  private _onSelectEnd( event ) {\r\n    // Function can be used to clean up after _onSelectStart\r\n\r\n  }\r\n\r\n  private _getIntersections( controller: any, group: Object3D[] | Mesh[] ) {\r\n    this._tempMatrix.identity().extractRotation( controller.matrixWorld );\r\n    this._raycaster.ray.origin.setFromMatrixPosition( controller.matrixWorld );\r\n    this._raycaster.ray.direction.set( 0, 0, - 1 ).applyMatrix4( this._tempMatrix );\r\n\r\n    return this._raycaster.intersectObjects( group );\r\n  }\r\n\r\n  private _registerMeshes() {\r\n    this._scene.traverse((mesh: Mesh) => {\r\n      this._meshes.push(mesh);\r\n    });\r\n  }\r\n\r\n  private _handleIntersections() {\r\n    if (this._renderer.xr.getController(1).visible) {\r\n      this._handleControllerIntersections( this._controller1 );\r\n    } else {\r\n      this._handleControllerIntersections(this._controller0);\r\n    }\r\n  }\r\n\r\n  private _handleControllerIntersections(controller: any) {\r\n    const objectIntersections = this._getIntersections(controller, this._meshes);\r\n\r\n    if (objectIntersections.length > 0) {\r\n      const nearestIntersection = this._getNearestIntersection(objectIntersections);\r\n      if (nearestIntersection !== null) {\r\n        this._currentClosestIntersection = nearestIntersection;\r\n        const nearestObjectParent = this._getParentOfChild(nearestIntersection.object);\r\n        if (this._isObjectFloor(nearestIntersection.object)) {\r\n          this._handleFloorIntersection(controller, nearestIntersection);\r\n        } else if (nearestObjectParent) {\r\n          this._updateObjectSelection(nearestObjectParent);\r\n          this._handleObjectIntersection(controller, nearestIntersection);\r\n        } else {\r\n          this._handleNoIntersections(controller);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _getNearestIntersection(intersections: Intersection[]): Intersection {\r\n    let nearest = null;\r\n    for (const intersection of intersections) {\r\n      // TODO: need a better solution for first if-statement\r\n      if (intersection.object.name && (intersection.object.name === 'home' || intersection.object.name === 'line')\r\n      || (intersection.object.parent && intersection.object.parent instanceof Reticle)) {\r\n        // DO NOTHING\r\n      } else if (nearest === null || intersection.distance < nearest.distance) {\r\n        nearest = intersection;\r\n      }\r\n    }\r\n\r\n    return nearest;\r\n  }\r\n\r\n  private _handleFloorIntersection(controller: any, intersection: Intersection) {\r\n    this._updateControllerRay(controller, intersection.distance);\r\n    this._reticle.visible = true;\r\n    this._reticle.position.copy(intersection.point);\r\n  }\r\n\r\n  private _handleObjectIntersection(controller: any, intersection: Intersection) {\r\n    this._updateControllerRay(controller, intersection.distance);\r\n    this._reticle.visible = false;\r\n  }\r\n\r\n  private _handleNoIntersections(controller: any) {\r\n    this._reticle.visible = false;\r\n    this._updateControllerRay(controller, 0);\r\n  }\r\n\r\n  private _updateControllerRay(controller: any, rayLenght: number) {\r\n    const line = controller.getObjectByName( 'line' );\r\n    if (line) {\r\n      line.scale.z = rayLenght;\r\n    }\r\n  }\r\n\r\n  private _isObjectFloor(object: Object3D) {\r\n    return object.name && object.name === 'floor-plane';\r\n  }\r\n\r\n  private _getParentOfChild(object: any): any {\r\n    // TODO: return null if object is not selectable\r\n    if (!object.parent || (object.parent instanceof THREE.Scene) || (object.parent instanceof ItemGroup)\r\n      || (object.parent instanceof Reticle)) {\r\n      return object;\r\n    } else {\r\n      return this._getParentOfChild(object.parent);\r\n    }\r\n  }\r\n\r\n  private _updateObjectSelection(object: Object3D) {\r\n    if (!this._selectedObject) {\r\n      this._selectedObject = object;\r\n    }\r\n\r\n    // Do something with newly selected item\r\n    // ...\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/service/wall-measurements.service.js

@@ -0,0 +1,79 @@
+import * as THREE from 'three';
+import { Injectable } from '@angular/core';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { ConfigurationKey } from '../../../core/enum/configuration-key.enum';
+import { Dimensioning } from '../core/dimensioning';
+import { makeTextMesh } from '../hud/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../room-planner/components/floorplanner/service/floorplan.service";
+import * as i2 from "../../../core/service/view-mode.service";
+import * as i3 from "./scene.service";
+import * as i4 from "../../../core/service/configuration.service";
+import * as i5 from "./font.service";
+export class WallMeasurementsService {
+    constructor(_floorplanService, _viewModeService, _sceneService, _configurationService, _fontService) {
+        this._floorplanService = _floorplanService;
+        this._viewModeService = _viewModeService;
+        this._sceneService = _sceneService;
+        this._configurationService = _configurationService;
+        this._fontService = _fontService;
+        this._subs = [];
+        this._subs.push(this._viewModeService.viewModeChanged.subscribe(mode => {
+            if (mode === ViewMode.TopView) {
+                this._showMeasurements();
+            }
+            else {
+                this._removeMeasurements();
+            }
+        }), this._configurationService.onChange.subscribe((changed) => {
+            if (ConfigurationKey.ShowDetailedWallMeasurements in changed) {
+                this._removeMeasurements();
+                if (this._viewModeService.viewMode === ViewMode.TopView) {
+                    this._showMeasurements();
+                }
+            }
+        }));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    _showMeasurements() {
+        if (this._measurements) {
+            this._removeMeasurements();
+        }
+        this._measurements = [];
+        this._floorplanService.getWalls().forEach((w) => {
+            this._measurements.push(this._makeMeasurements(w));
+        });
+        this._measurements.forEach(m => this._sceneService.addObject(m));
+    }
+    _removeMeasurements() {
+        if (this._measurements) {
+            this._measurements.forEach(m => this._sceneService.removeObject(m));
+            this._measurements = undefined;
+        }
+    }
+    _makeMeasurements(wall) {
+        const position = new THREE.Vector3((wall.getStartX() + wall.getEndX()) / 2, wall.height, (wall.getStartY() + wall.getEndY()) / 2);
+        const lengths = this._configurationService.getValue(ConfigurationKey.ShowDetailedWallMeasurements) ? wall.edgesLengths : [wall.length];
+        const dimUnit = this._configurationService.getValue(ConfigurationKey.DimensioningUnit);
+        const distanceStep = this._configurationService.getDistanceStep();
+        const text = lengths.map(l => Dimensioning.mToMeasure(l, dimUnit, distanceStep)).join('/');
+        const mesh = makeTextMesh(text, this._fontService.monospaceFont, 0x000000, 0.16, true);
+        const halfX = (mesh.geometry.boundingBox.max.x - mesh.geometry.boundingBox.min.x) / 2;
+        const halfZ = (mesh.geometry.boundingBox.max.z - mesh.geometry.boundingBox.min.z) / 2;
+        mesh.geometry.translate(-halfX, 0, halfZ);
+        mesh.position.copy(position);
+        mesh.rotation.x = -90 * (Math.PI / 180);
+        return mesh;
+    }
+}
+WallMeasurementsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WallMeasurementsService, deps: [{ token: i1.FloorplanService }, { token: i2.ViewModeService }, { token: i3.SceneService }, { token: i4.ConfigurationService }, { token: i5.FontService }], target: i0.ɵɵFactoryTarget.Injectable });
+WallMeasurementsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WallMeasurementsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WallMeasurementsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FloorplanService }, { type: i2.ViewModeService }, { type: i3.SceneService }, { type: i4.ConfigurationService }, { type: i5.FontService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wall-measurements.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/wall-measurements.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\r\nimport {Mesh, Object3D} from 'three';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {Subscription} from 'rxjs';\r\nimport {FloorplanService} from '../../room-planner/components/floorplanner/service/floorplan.service';\r\nimport {ViewModeService} from '../../../core/service/view-mode.service';\r\nimport {SceneService} from './scene.service';\r\nimport {ConfigurationService} from '../../../core/service/configuration.service';\r\nimport {FontService} from './font.service';\r\nimport {ViewMode} from '../../../core/enum/view-mode.enum';\r\nimport {ConfigurationData} from '../../../core/interface/configuration-data.interface';\r\nimport {ConfigurationKey} from '../../../core/enum/configuration-key.enum';\r\nimport {Wall} from '../items/wall-objects';\r\nimport {Dimensioning} from '../core/dimensioning';\r\nimport {makeTextMesh} from '../hud/utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WallMeasurementsService implements OnDestroy {\r\n\r\n  private _measurements: Object3D[];\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n    private _floorplanService: FloorplanService,\r\n    private _viewModeService: ViewModeService,\r\n    private _sceneService: SceneService,\r\n    private _configurationService: ConfigurationService,\r\n    private _fontService: FontService\r\n  ) {\r\n    this._subs.push(\r\n      this._viewModeService.viewModeChanged.subscribe(mode => {\r\n        if (mode === ViewMode.TopView) {\r\n          this._showMeasurements();\r\n        } else {\r\n          this._removeMeasurements();\r\n        }\r\n      }),\r\n      this._configurationService.onChange.subscribe((changed: ConfigurationData) => {\r\n        if (ConfigurationKey.ShowDetailedWallMeasurements in changed) {\r\n          this._removeMeasurements();\r\n          if (this._viewModeService.viewMode === ViewMode.TopView) {\r\n            this._showMeasurements();\r\n          }\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  private _showMeasurements(): void {\r\n    if (this._measurements) {\r\n      this._removeMeasurements();\r\n    }\r\n    this._measurements = [];\r\n    this._floorplanService.getWalls().forEach((w: Wall) => {\r\n      this._measurements.push(this._makeMeasurements(w));\r\n    });\r\n    this._measurements.forEach(m => this._sceneService.addObject(m));\r\n  }\r\n\r\n  private _removeMeasurements(): void {\r\n    if (this._measurements) {\r\n      this._measurements.forEach(m => this._sceneService.removeObject(m));\r\n      this._measurements = undefined;\r\n    }\r\n  }\r\n\r\n  private _makeMeasurements(wall: Wall): Object3D {\r\n      const position = new THREE.Vector3(\r\n        (wall.getStartX() + wall.getEndX()) / 2,\r\n        wall.height,\r\n        (wall.getStartY() + wall.getEndY()) / 2\r\n      );\r\n      const lengths =\r\n        this._configurationService.getValue(ConfigurationKey.ShowDetailedWallMeasurements) ? wall.edgesLengths : [wall.length];\r\n      const dimUnit = this._configurationService.getValue(ConfigurationKey.DimensioningUnit);\r\n      const distanceStep = this._configurationService.getDistanceStep();\r\n      const text: string = lengths.map(l => Dimensioning.mToMeasure(l, dimUnit, distanceStep)).join('/');\r\n      const mesh: Mesh = makeTextMesh(text, this._fontService.monospaceFont, 0x000000, 0.16, true);\r\n\r\n      const halfX: number = (mesh.geometry.boundingBox.max.x - mesh.geometry.boundingBox.min.x) / 2;\r\n      const halfZ: number = (mesh.geometry.boundingBox.max.z - mesh.geometry.boundingBox.min.z) / 2;\r\n      mesh.geometry.translate(-halfX, 0, halfZ);\r\n\r\n      mesh.position.copy(position);\r\n      mesh.rotation.x = -90 * (Math.PI / 180);\r\n      return mesh;\r\n  }\r\n}\r\n"]}