@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/room-planner/room-planner.module.js

@@ -0,0 +1,233 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatCardModule } from '@angular/material/card';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatGridListModule } from '@angular/material/grid-list';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import { ColorChromeModule } from 'ngx-color/chrome';
+import { ColorPickerComponent } from './components/color-picker/color-picker.component';
+import { EditApplyComponent } from './components/edit-apply/edit-apply.component';
+import { ObjectLibraryComponent } from './components/object-library/object-library.component';
+import { RoomPlannerComponent } from './room-planner/room-planner.component';
+import { SelectedFloorComponent } from './components/selected-floor/selected-floor.component';
+import { SelectedObjectComponent } from './components/selected-object/selected-object.component';
+import { SelectedWallComponent } from './components/selected-wall/selected-wall.component';
+import { SettingsComponent } from './components/settings/settings.component';
+import { TexturePickerComponent } from './components/texture-picker/texture-picker.component';
+import { TextureEditorComponent } from './components/texture-editor/texture-editor.component';
+import { EditParameterComponent } from './components/edit-parameter/edit-parameter.component';
+import { RalColorPickerComponent } from './components/ral-color-picker/ral-color-picker.component';
+import { RgbColorPickerComponent } from './components/rgb-color-picker/rgb-color-picker.component';
+import { ToolbarIconModule } from '../../shared/toolbar-icon/toolbar-icon.module';
+import { DimensionInputComponent } from './components/dimension-input/dimension-input.component';
+import { FileDropComponent } from './components/file-drop/file-drop.component';
+import { AppearanceSectionComponent } from './components/appearance-section/appearance-section.component';
+import { CustomShapeCreatorComponent } from './components/custome-shape-creator/custom-shape-creator.component';
+import { ButtonModule, IconModule } from '@colijnit/corecomponents';
+import { FloorplannerComponent } from './components/floorplanner/floorplanner.component';
+import { WallLengthInputComponent } from './components/wall-length-input/wall-length-input.component';
+import { CustomCylinderCreatorComponent } from './components/custom-cylinder-creator/custom-cylinder-creator.component';
+import { CoreModule } from '../../core/core.module';
+import { CategoryLibraryModule } from '../../shared/category-library/category-library.module';
+import { ContextMenuModule } from '../../shared/context-menu/context-menu.module';
+import { InfoDialogModule } from '../../shared/info-dialog/info-dialog.module';
+import { Core3dModule } from '../core3d/core3d.module';
+import { ZoomControlsModule } from '../../shared/zoom-controls/zoom-controls.module';
+import { RenderModule } from '../render/render.module';
+import { SliderInputModule } from '../../shared/slider-input/slider-input.module';
+import { ButtonElevationModule } from '../../shared/button-elevation/button-elevation.module';
+import { SelectedThreedObjectComponent } from './components/selected-threed-object/selected-threed-object.component';
+import { SettingsOptionsComponent } from './components/settings/settings-options.component';
+import { CollisionManagerService } from '../core3d/collision-manager/collision-manager.service';
+import { UtilsService } from '../../core/service/utils.service';
+import { RalService } from '../../core/service/ral.service';
+import { AppStateService } from '../../core/service/app-state.service';
+import { HomedecoratorIconCacheService } from '../../core/service/homedecorator-icon-cache.service';
+import * as i0 from "@angular/core";
+export class RoomPlannerModule {
+}
+RoomPlannerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RoomPlannerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RoomPlannerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RoomPlannerModule, declarations: [ColorPickerComponent,
+        EditApplyComponent,
+        ObjectLibraryComponent,
+        RoomPlannerComponent,
+        FloorplannerComponent,
+        SelectedFloorComponent,
+        SelectedObjectComponent,
+        SelectedThreedObjectComponent,
+        SelectedWallComponent,
+        SettingsComponent,
+        SettingsOptionsComponent,
+        TexturePickerComponent,
+        TextureEditorComponent,
+        EditParameterComponent,
+        RalColorPickerComponent,
+        RgbColorPickerComponent,
+        DimensionInputComponent,
+        FileDropComponent,
+        AppearanceSectionComponent,
+        CustomShapeCreatorComponent,
+        WallLengthInputComponent,
+        CustomCylinderCreatorComponent], imports: [CoreModule,
+        CategoryLibraryModule,
+        ColorChromeModule,
+        CommonModule,
+        ContextMenuModule,
+        MatButtonModule,
+        MatButtonToggleModule,
+        MatCardModule,
+        MatCheckboxModule,
+        MatFormFieldModule,
+        MatInputModule,
+        MatSidenavModule,
+        MatSliderModule,
+        MatSlideToggleModule,
+        MatGridListModule,
+        MatIconModule,
+        MatTabsModule,
+        MatSelectModule,
+        MatDividerModule,
+        MatTooltipModule,
+        MatSnackBarModule,
+        FormsModule,
+        InfoDialogModule,
+        Core3dModule,
+        ToolbarIconModule,
+        ZoomControlsModule,
+        RenderModule,
+        SliderInputModule,
+        FlexLayoutModule,
+        IconModule,
+        ButtonModule,
+        ButtonElevationModule], exports: [RoomPlannerComponent] });
+RoomPlannerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RoomPlannerModule, providers: [
+        CollisionManagerService,
+        UtilsService,
+        RalService,
+        AppStateService,
+        HomedecoratorIconCacheService
+    ], imports: [[
+            CoreModule,
+            CategoryLibraryModule,
+            ColorChromeModule,
+            CommonModule,
+            ContextMenuModule,
+            MatButtonModule,
+            MatButtonToggleModule,
+            MatCardModule,
+            MatCheckboxModule,
+            MatFormFieldModule,
+            MatInputModule,
+            MatSidenavModule,
+            MatSliderModule,
+            MatSlideToggleModule,
+            MatGridListModule,
+            MatIconModule,
+            MatTabsModule,
+            MatSelectModule,
+            MatDividerModule,
+            MatTooltipModule,
+            MatSnackBarModule,
+            FormsModule,
+            InfoDialogModule,
+            Core3dModule,
+            ToolbarIconModule,
+            ZoomControlsModule,
+            RenderModule,
+            SliderInputModule,
+            FlexLayoutModule,
+            IconModule,
+            ButtonModule,
+            ButtonElevationModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RoomPlannerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CoreModule,
+                        CategoryLibraryModule,
+                        ColorChromeModule,
+                        CommonModule,
+                        ContextMenuModule,
+                        MatButtonModule,
+                        MatButtonToggleModule,
+                        MatCardModule,
+                        MatCheckboxModule,
+                        MatFormFieldModule,
+                        MatInputModule,
+                        MatSidenavModule,
+                        MatSliderModule,
+                        MatSlideToggleModule,
+                        MatGridListModule,
+                        MatIconModule,
+                        MatTabsModule,
+                        MatSelectModule,
+                        MatDividerModule,
+                        MatTooltipModule,
+                        MatSnackBarModule,
+                        FormsModule,
+                        InfoDialogModule,
+                        Core3dModule,
+                        ToolbarIconModule,
+                        ZoomControlsModule,
+                        RenderModule,
+                        SliderInputModule,
+                        FlexLayoutModule,
+                        IconModule,
+                        ButtonModule,
+                        ButtonElevationModule,
+                    ],
+                    declarations: [
+                        ColorPickerComponent,
+                        EditApplyComponent,
+                        ObjectLibraryComponent,
+                        RoomPlannerComponent,
+                        FloorplannerComponent,
+                        SelectedFloorComponent,
+                        SelectedObjectComponent,
+                        SelectedThreedObjectComponent,
+                        SelectedWallComponent,
+                        SettingsComponent,
+                        SettingsOptionsComponent,
+                        TexturePickerComponent,
+                        TextureEditorComponent,
+                        EditParameterComponent,
+                        RalColorPickerComponent,
+                        RgbColorPickerComponent,
+                        DimensionInputComponent,
+                        FileDropComponent,
+                        AppearanceSectionComponent,
+                        CustomShapeCreatorComponent,
+                        WallLengthInputComponent,
+                        CustomCylinderCreatorComponent
+                    ],
+                    providers: [
+                        CollisionManagerService,
+                        UtilsService,
+                        RalService,
+                        AppStateService,
+                        HomedecoratorIconCacheService
+                    ],
+                    exports: [
+                        RoomPlannerComponent
+                    ],
+                    entryComponents: [
+                        RoomPlannerComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"room-planner.module.js","sourceRoot":"","sources":["../../../../../../src/client/app/plugins/room-planner/room-planner.module.ts"],"names":[],"mappings":"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","sourcesContent":["import {NgModule} from '@angular/core';\r\nimport {CommonModule} from '@angular/common';\r\nimport {FormsModule} from '@angular/forms';\r\nimport {MatButtonModule} from '@angular/material/button';\r\nimport {MatButtonToggleModule} from '@angular/material/button-toggle';\r\nimport {MatCardModule} from '@angular/material/card';\r\nimport {MatCheckboxModule} from '@angular/material/checkbox';\r\nimport {MatDividerModule} from '@angular/material/divider';\r\nimport {MatFormFieldModule} from '@angular/material/form-field';\r\nimport {MatGridListModule} from '@angular/material/grid-list';\r\nimport {MatIconModule} from '@angular/material/icon';\r\nimport {MatInputModule} from '@angular/material/input';\r\nimport {MatSelectModule} from '@angular/material/select';\r\nimport {MatSidenavModule} from '@angular/material/sidenav';\r\nimport {MatSlideToggleModule} from '@angular/material/slide-toggle';\r\nimport {MatSliderModule} from '@angular/material/slider';\r\nimport {MatSnackBarModule} from '@angular/material/snack-bar';\r\nimport {MatTabsModule} from '@angular/material/tabs';\r\nimport {MatTooltipModule} from '@angular/material/tooltip';\r\n\r\nimport {FlexLayoutModule} from '@angular/flex-layout';\r\nimport {ColorChromeModule} from 'ngx-color/chrome';\r\n\r\nimport {ColorPickerComponent} from './components/color-picker/color-picker.component';\r\nimport {EditApplyComponent} from './components/edit-apply/edit-apply.component';\r\nimport {ObjectLibraryComponent} from './components/object-library/object-library.component';\r\nimport {RoomPlannerComponent} from './room-planner/room-planner.component';\r\nimport {SelectedFloorComponent} from './components/selected-floor/selected-floor.component';\r\nimport {SelectedObjectComponent} from './components/selected-object/selected-object.component';\r\nimport {SelectedWallComponent} from './components/selected-wall/selected-wall.component';\r\nimport {SettingsComponent} from './components/settings/settings.component';\r\nimport {TexturePickerComponent} from './components/texture-picker/texture-picker.component';\r\nimport {TextureEditorComponent} from './components/texture-editor/texture-editor.component';\r\nimport {EditParameterComponent} from './components/edit-parameter/edit-parameter.component';\r\nimport {RalColorPickerComponent} from './components/ral-color-picker/ral-color-picker.component';\r\nimport {RgbColorPickerComponent} from './components/rgb-color-picker/rgb-color-picker.component';\r\nimport {ToolbarIconModule} from '../../shared/toolbar-icon/toolbar-icon.module';\r\nimport {DimensionInputComponent} from './components/dimension-input/dimension-input.component';\r\nimport {FileDropComponent} from './components/file-drop/file-drop.component';\r\nimport {AppearanceSectionComponent} from './components/appearance-section/appearance-section.component';\r\nimport {CustomShapeCreatorComponent} from './components/custome-shape-creator/custom-shape-creator.component';\r\nimport {ButtonModule, IconModule} from '@colijnit/corecomponents';\r\nimport {FloorplannerComponent} from './components/floorplanner/floorplanner.component';\r\nimport {WallLengthInputComponent} from './components/wall-length-input/wall-length-input.component';\r\nimport {CustomCylinderCreatorComponent} from './components/custom-cylinder-creator/custom-cylinder-creator.component';\r\nimport {CoreModule} from '../../core/core.module';\r\nimport {CategoryLibraryModule} from '../../shared/category-library/category-library.module';\r\nimport {ContextMenuModule} from '../../shared/context-menu/context-menu.module';\r\nimport {InfoDialogModule} from '../../shared/info-dialog/info-dialog.module';\r\nimport {Core3dModule} from '../core3d/core3d.module';\r\nimport {ZoomControlsModule} from '../../shared/zoom-controls/zoom-controls.module';\r\nimport {RenderModule} from '../render/render.module';\r\nimport {SliderInputModule} from '../../shared/slider-input/slider-input.module';\r\nimport {ButtonElevationModule} from '../../shared/button-elevation/button-elevation.module';\r\nimport {SelectedThreedObjectComponent} from './components/selected-threed-object/selected-threed-object.component';\r\nimport {SettingsOptionsComponent} from './components/settings/settings-options.component';\r\nimport {FloorplanService} from './components/floorplanner/service/floorplan.service';\r\nimport {CollisionManagerService} from '../core3d/collision-manager/collision-manager.service';\r\nimport {UtilsService} from '../../core/service/utils.service';\r\nimport {RalService} from '../../core/service/ral.service';\r\nimport {AppStateService} from '../../core/service/app-state.service';\r\nimport {HomedecoratorIconCacheService} from '../../core/service/homedecorator-icon-cache.service';\r\n\r\n@NgModule({\r\n  imports: [\r\n    CoreModule,\r\n    CategoryLibraryModule,\r\n    ColorChromeModule,\r\n    CommonModule,\r\n    ContextMenuModule,\r\n    MatButtonModule,\r\n    MatButtonToggleModule,\r\n    MatCardModule,\r\n    MatCheckboxModule,\r\n    MatFormFieldModule,\r\n    MatInputModule,\r\n    MatSidenavModule,\r\n    MatSliderModule,\r\n    MatSlideToggleModule,\r\n    MatGridListModule,\r\n    MatIconModule,\r\n    MatTabsModule,\r\n    MatSelectModule,\r\n    MatDividerModule,\r\n    MatTooltipModule,\r\n    MatSnackBarModule,\r\n    FormsModule,\r\n    InfoDialogModule,\r\n    Core3dModule,\r\n    ToolbarIconModule,\r\n    ZoomControlsModule,\r\n    RenderModule,\r\n    SliderInputModule,\r\n    FlexLayoutModule,\r\n    IconModule,\r\n    ButtonModule,\r\n    ButtonElevationModule,\r\n  ],\r\n  declarations: [\r\n    ColorPickerComponent,\r\n    EditApplyComponent,\r\n    ObjectLibraryComponent,\r\n    RoomPlannerComponent,\r\n    FloorplannerComponent,\r\n    SelectedFloorComponent,\r\n    SelectedObjectComponent,\r\n    SelectedThreedObjectComponent,\r\n    SelectedWallComponent,\r\n    SettingsComponent,\r\n    SettingsOptionsComponent,\r\n    TexturePickerComponent,\r\n    TextureEditorComponent,\r\n    EditParameterComponent,\r\n    RalColorPickerComponent,\r\n    RgbColorPickerComponent,\r\n    DimensionInputComponent,\r\n    FileDropComponent,\r\n    AppearanceSectionComponent,\r\n    CustomShapeCreatorComponent,\r\n    WallLengthInputComponent,\r\n    CustomCylinderCreatorComponent\r\n  ],\r\n  providers: [\r\n    CollisionManagerService,\r\n    UtilsService,\r\n    RalService,\r\n    AppStateService,\r\n    HomedecoratorIconCacheService\r\n  ],\r\n  exports: [\r\n    RoomPlannerComponent\r\n  ],\r\n  entryComponents: [\r\n    RoomPlannerComponent\r\n  ]\r\n})\r\nexport class RoomPlannerModule { }\r\n"]}

package/esm2015/app/plugins/threed-in-photo/components/threed-in-photo-scene/threed-in-photo-scene.component.js

@@ -0,0 +1,43 @@
+import { Component } from '@angular/core';
+import { UploadImageComponent } from '../upload-image/upload-image.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/threed-in-photo-scene.service";
+import * as i2 from "../../services/threed-in-photo-initializer.service";
+import * as i3 from "../../services/threed-in-photo-render.service";
+import * as i4 from "@angular/material/dialog";
+export class ThreedInPhotoSceneComponent {
+    constructor(sceneService, _initializerService, _renderService, _dialog) {
+        this.sceneService = sceneService;
+        this._initializerService = _initializerService;
+        this._renderService = _renderService;
+        this._dialog = _dialog;
+    }
+    ngAfterViewInit() {
+        this._setSceneElementReference();
+        this._renderService.init();
+        this._openUploadDialog();
+    }
+    _setSceneElementReference() {
+        this._renderService.sceneContainer = document.getElementById('sceneContainer');
+    }
+    _openUploadDialog() {
+        this._dialog.open(UploadImageComponent, {
+            width: '400px'
+        });
+    }
+}
+ThreedInPhotoSceneComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ThreedInPhotoSceneComponent, deps: [{ token: i1.ThreedInPhotoSceneService }, { token: i2.ThreedInPhotoInitializerService }, { token: i3.ThreedInPhotoRenderService }, { token: i4.MatDialog }], target: i0.ɵɵFactoryTarget.Component });
+ThreedInPhotoSceneComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ThreedInPhotoSceneComponent, selector: "threed-in-photo-scene", ngImport: i0, template: `
+    <div [style.width.px]="sceneService.sceneWidth" [style.height.px]="sceneService.sceneHeight" id="sceneContainer"></div>
+  `, isInline: true, styles: [":host{display:flex;align-items:center;justify-content:center;width:inherit;height:inherit}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ThreedInPhotoSceneComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'threed-in-photo-scene',
+                    template: `
+    <div [style.width.px]="sceneService.sceneWidth" [style.height.px]="sceneService.sceneHeight" id="sceneContainer"></div>
+  `,
+                    styleUrls: ['./threed-in-photo-scene.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ThreedInPhotoSceneService }, { type: i2.ThreedInPhotoInitializerService }, { type: i3.ThreedInPhotoRenderService }, { type: i4.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/threed-in-photo/components/upload-image/upload-image.component.js

@@ -0,0 +1,61 @@
+import { Component, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../../services/threed-in-photo-build.service";
+import * as i3 from "../../services/threed-in-photo-event.service";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+export class UploadImageComponent {
+    constructor(_dialog, _dialogRef, _buildService, _eventService) {
+        this._dialog = _dialog;
+        this._dialogRef = _dialogRef;
+        this._buildService = _buildService;
+        this._eventService = _eventService;
+        this.file = null;
+    }
+    onClickFileInputButton() {
+        this.fileInput.nativeElement.click();
+    }
+    onChangeFileInput() {
+        const files = this.fileInput.nativeElement.files;
+        this.file = files[0];
+        this.startSceneBuilding(this.file);
+    }
+    startSceneBuilding(event) {
+        this._dialogRef.close();
+        this._buildService.generateScene(event);
+        if (!this._buildService.floorMesh) {
+            this._eventService.showViewControlDialog.next();
+        }
+    }
+}
+UploadImageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UploadImageComponent, deps: [{ token: i1.MatDialog }, { token: i1.MatDialogRef }, { token: i2.ThreedInPhotoBuildService }, { token: i3.ThreedInPhotoEventService }], target: i0.ɵɵFactoryTarget.Component });
+UploadImageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: UploadImageComponent, selector: "upload-image", viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true }], ngImport: i0, template: `
+    <div class="container">
+      <input type="file" style="display: none" #fileInput accept="image/*" (change)="onChangeFileInput()" />
+      <button mat-raised-button color="primary" class="file-select-button" (click)="onClickFileInputButton()">
+        <mat-icon class="homedecorator-material-icons">attach_file</mat-icon>
+        Upload Image
+      </button>
+    </div>
+  `, isInline: true, styles: [":host .file-select-button{display:inline-block;margin:8px;width:335px}\n"], components: [{ type: i4.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UploadImageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'upload-image',
+                    template: `
+    <div class="container">
+      <input type="file" style="display: none" #fileInput accept="image/*" (change)="onChangeFileInput()" />
+      <button mat-raised-button color="primary" class="file-select-button" (click)="onClickFileInputButton()">
+        <mat-icon class="homedecorator-material-icons">attach_file</mat-icon>
+        Upload Image
+      </button>
+    </div>
+  `,
+                    styleUrls: ['./upload-image.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i1.MatDialogRef }, { type: i2.ThreedInPhotoBuildService }, { type: i3.ThreedInPhotoEventService }]; }, propDecorators: { fileInput: [{
+                type: ViewChild,
+                args: ['fileInput']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/threed-in-photo/components/view-control/view-control.component.js

@@ -0,0 +1,164 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/threed-in-photo-view.service";
+import * as i2 from "../../services/threed-in-photo-build.service";
+import * as i3 from "../../services/threed-in-photo-event.service";
+import * as i4 from "../../services/threed-in-photo-render.service";
+import * as i5 from "../../../core3d/service/scene.service";
+import * as i6 from "@angular/material/dialog";
+import * as i7 from "@angular/material/form-field";
+import * as i8 from "@angular/material/slide-toggle";
+import * as i9 from "@angular/material/button";
+import * as i10 from "@angular/cdk/drag-drop";
+import * as i11 from "@angular/forms";
+import * as i12 from "@angular/material/input";
+export class ViewControlComponent {
+    constructor(_viewService, _buildService, _eventService, _renderService, _sceneService, _dialog) {
+        this._viewService = _viewService;
+        this._buildService = _buildService;
+        this._eventService = _eventService;
+        this._renderService = _renderService;
+        this._sceneService = _sceneService;
+        this._dialog = _dialog;
+        this.showFloorValue = true;
+        this.originalFloorValue = true;
+    }
+    ngOnInit() {
+        this.camera = this._viewService.camera;
+        this.floorPlane = this._buildService.floorMesh;
+    }
+    handleCameraChange() {
+        this.camera.updateProjectionMatrix();
+        this._sceneService.needsRender = true;
+    }
+    handleToggleChange() {
+        this.showFloorValue = !this.showFloorValue;
+        if (this._buildService.floorMesh) {
+            this._buildService.floorMesh.material = !this.showFloorValue ? this._buildService.shadowMaterial : this._buildService.visibilityMaterial;
+            this._buildService.floorMesh.material.needsUpdate = true;
+            this.handleCameraChange();
+        }
+    }
+    handleFloorSizeChange() {
+        this.originalFloorValue = !this.originalFloorValue;
+        if (this._buildService.floorMesh) {
+            if (!this.originalFloorValue) {
+                this._buildService.floorMesh.scale.set(1000, 1, 1000);
+            }
+            else {
+                this._buildService.floorMesh.scale.set(1, 1, 1);
+            }
+            this.handleCameraChange();
+        }
+    }
+    resetCamera() {
+        this.camera.position.set(0, 0, 4);
+        this.camera.rotation.set(0, 0, 0);
+        this.camera.fov = 45;
+        this.handleCameraChange();
+    }
+    changeImage() {
+        this._eventService.showUploadImageDialog.next();
+    }
+}
+ViewControlComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewControlComponent, deps: [{ token: i1.ThreedInPhotoViewService }, { token: i2.ThreedInPhotoBuildService }, { token: i3.ThreedInPhotoEventService }, { token: i4.ThreedInPhotoRenderService }, { token: i5.SceneService }, { token: i6.MatDialog }], target: i0.ɵɵFactoryTarget.Component });
+ViewControlComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ViewControlComponent, selector: "view-control", ngImport: i0, template: `
+    <h1 mat-dialog-title cdkDrag
+        cdkDragRootElement=".cdk-overlay-pane"
+        cdkDragHandle>{{'VIEW_SETTINGS'}}</h1>
+    <div mat-dialog-content class="dialog-wrapper">
+      <form class="dialog-form-wrapper">
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'X_POSITION'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.position.x" (ngModelChange)="handleCameraChange()" step="0.1" name="maxHorizontalOrbit">
+        </mat-form-field>
+
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'Y_POSITION'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.position.y" (ngModelChange)="handleCameraChange()" step="0.1" name="minHorizontalOrbit">
+        </mat-form-field>
+
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'Z_POSITION'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.position.z" (ngModelChange)="handleCameraChange()" step="0.1" name="maxVerticalOrbit">
+        </mat-form-field>
+
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'FOV_VALUE'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.fov" (ngModelChange)="handleCameraChange()" step="1" name="minVerticalOrbit">
+        </mat-form-field>
+
+        <mat-slide-toggle (toggleChange)="handleToggleChange()" [checked]="showFloorValue"
+        ><mat-label>{{'SHOW_FLOOR'}}</mat-label>
+        </mat-slide-toggle>
+
+        <mat-slide-toggle (toggleChange)="handleFloorSizeChange()" [checked]="originalFloorValue"
+        ><mat-label>{{'ORIGINAL_SIZE'}}</mat-label>
+        </mat-slide-toggle>
+      </form>
+    </div>
+
+    <div mat-dialog-actions class="buttons-wrapper">
+      <div class="action-buttons">
+        <button mat-raised-button color="primary" (click)="resetCamera()">{{'RESET_CAMERA'}}</button>
+      </div>
+
+      <div class="action-buttons">
+        <button mat-raised-button color="primary" (click)="changeImage()">{{'CHANGE_IMAGE'}}</button>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host .dialog-form-wrapper{display:grid;grid-template-columns:1fr 1fr;grid-template-rows:1fr 1fr 1fr;grid-gap:0 15px;gap:0 15px;grid-template-areas:\". .\" \". .\" \". .\"}:host .dialog-form-wrapper mat-form-field{width:168px}:host .input-button-wrapper{display:flex;align-items:center;justify-content:space-between}:host .input-button-wrapper button{margin-bottom:21.5px;margin-right:10px}:host .input-button-wrapper mat-form-field{width:100px}:host .buttons-wrapper{justify-content:space-between}:host h1{cursor:move}\n"], components: [{ type: i7.MatFormField, selector: "mat-form-field", inputs: ["color", "floatLabel", "appearance", "hideRequiredMarker", "hintLabel"], exportAs: ["matFormField"] }, { type: i8.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["disabled", "disableRipple", "color", "tabIndex", "name", "id", "labelPosition", "aria-label", "aria-labelledby", "required", "checked", "aria-describedby"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { type: i9.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i6.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { type: i10.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragDisabled", "cdkDragStartDelay", "cdkDragLockAxis", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragBoundary", "cdkDragRootElement", "cdkDragPreviewContainer", "cdkDragData", "cdkDragFreeDragPosition"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { type: i10.CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }, { type: i6.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { type: i11.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i11.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i11.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i7.MatLabel, selector: "mat-label" }, { type: i12.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["id", "disabled", "required", "type", "value", "readonly", "placeholder", "errorStateMatcher", "aria-describedby"], exportAs: ["matInput"] }, { type: i11.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { type: i11.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i11.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i11.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i6.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewControlComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'view-control',
+                    template: `
+    <h1 mat-dialog-title cdkDrag
+        cdkDragRootElement=".cdk-overlay-pane"
+        cdkDragHandle>{{'VIEW_SETTINGS'}}</h1>
+    <div mat-dialog-content class="dialog-wrapper">
+      <form class="dialog-form-wrapper">
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'X_POSITION'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.position.x" (ngModelChange)="handleCameraChange()" step="0.1" name="maxHorizontalOrbit">
+        </mat-form-field>
+
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'Y_POSITION'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.position.y" (ngModelChange)="handleCameraChange()" step="0.1" name="minHorizontalOrbit">
+        </mat-form-field>
+
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'Z_POSITION'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.position.z" (ngModelChange)="handleCameraChange()" step="0.1" name="maxVerticalOrbit">
+        </mat-form-field>
+
+        <mat-form-field class="example-full-width" appearance="fill">
+          <mat-label>{{'FOV_VALUE'}}</mat-label>
+          <input matInput type="number" [(ngModel)]="camera.fov" (ngModelChange)="handleCameraChange()" step="1" name="minVerticalOrbit">
+        </mat-form-field>
+
+        <mat-slide-toggle (toggleChange)="handleToggleChange()" [checked]="showFloorValue"
+        ><mat-label>{{'SHOW_FLOOR'}}</mat-label>
+        </mat-slide-toggle>
+
+        <mat-slide-toggle (toggleChange)="handleFloorSizeChange()" [checked]="originalFloorValue"
+        ><mat-label>{{'ORIGINAL_SIZE'}}</mat-label>
+        </mat-slide-toggle>
+      </form>
+    </div>
+
+    <div mat-dialog-actions class="buttons-wrapper">
+      <div class="action-buttons">
+        <button mat-raised-button color="primary" (click)="resetCamera()">{{'RESET_CAMERA'}}</button>
+      </div>
+
+      <div class="action-buttons">
+        <button mat-raised-button color="primary" (click)="changeImage()">{{'CHANGE_IMAGE'}}</button>
+      </div>
+    </div>
+  `,
+                    styleUrls: ['./view-control.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ThreedInPhotoViewService }, { type: i2.ThreedInPhotoBuildService }, { type: i3.ThreedInPhotoEventService }, { type: i4.ThreedInPhotoRenderService }, { type: i5.SceneService }, { type: i6.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view-control.component.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/threed-in-photo/components/view-control/view-control.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAS,MAAM,eAAe,CAAC;;;;;;;;;;;;;;AA2DhD,MAAM,OAAO,oBAAoB;IAO/B,YACU,YAAsC,EACtC,aAAwC,EACxC,aAAwC,EACxC,cAA0C,EAC1C,aAA2B,EAC3B,OAAkB;QALlB,iBAAY,GAAZ,YAAY,CAA0B;QACtC,kBAAa,GAAb,aAAa,CAA2B;QACxC,kBAAa,GAAb,aAAa,CAA2B;QACxC,mBAAc,GAAd,cAAc,CAA4B;QAC1C,kBAAa,GAAb,aAAa,CAAc;QAC3B,YAAO,GAAP,OAAO,CAAW;QATrB,mBAAc,GAAY,IAAI,CAAC;QAC/B,uBAAkB,GAAY,IAAI,CAAC;IAStC,CAAC;IAEE,QAAQ;QACb,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;QACvC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;IACjD,CAAC;IAEM,kBAAkB;QACvB,IAAI,CAAC,MAAM,CAAC,sBAAsB,EAAE,CAAC;QACrC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;IACxC,CAAC;IAEM,kBAAkB;QACvB,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC;QAC3C,IAAI,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE;YAChC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC;YACzI,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC;YACzD,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;IACH,CAAC;IAEM,qBAAqB;QAC1B,IAAI,CAAC,kBAAkB,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC;QACnD,IAAI,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE;YAChC,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;gBAC5B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;aACvD;iBAAM;gBACL,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;aACjD;YACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;IACH,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,IAAI,EAAE,CAAC;IAClD,CAAC;;kHAxDU,oBAAoB;sGAApB,oBAAoB,oDAhDrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CT;4FAGU,oBAAoB;kBAlDhC,SAAS;mBAAC;oBACT,QAAQ,EAAE,cAAc;oBACxB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CT;oBACD,SAAS,EAAE,CAAC,+BAA+B,CAAC;iBAC7C","sourcesContent":["import {Component, OnInit} from '@angular/core';\r\nimport {Mesh, PerspectiveCamera} from 'three';\r\nimport {MatDialog} from '@angular/material/dialog';\r\nimport {ThreedInPhotoViewService} from '../../services/threed-in-photo-view.service';\r\nimport {ThreedInPhotoBuildService} from '../../services/threed-in-photo-build.service';\r\nimport {ThreedInPhotoEventService} from '../../services/threed-in-photo-event.service';\r\nimport {ThreedInPhotoRenderService} from '../../services/threed-in-photo-render.service';\r\nimport {SceneService} from '../../../core3d/service/scene.service';\r\n\r\n@Component({\r\n  selector: 'view-control',\r\n  template: `\r\n    <h1 mat-dialog-title cdkDrag\r\n        cdkDragRootElement=\".cdk-overlay-pane\"\r\n        cdkDragHandle>{{'VIEW_SETTINGS'}}</h1>\r\n    <div mat-dialog-content class=\"dialog-wrapper\">\r\n      <form class=\"dialog-form-wrapper\">\r\n        <mat-form-field class=\"example-full-width\" appearance=\"fill\">\r\n          <mat-label>{{'X_POSITION'}}</mat-label>\r\n          <input matInput type=\"number\" [(ngModel)]=\"camera.position.x\" (ngModelChange)=\"handleCameraChange()\" step=\"0.1\" name=\"maxHorizontalOrbit\">\r\n        </mat-form-field>\r\n\r\n        <mat-form-field class=\"example-full-width\" appearance=\"fill\">\r\n          <mat-label>{{'Y_POSITION'}}</mat-label>\r\n          <input matInput type=\"number\" [(ngModel)]=\"camera.position.y\" (ngModelChange)=\"handleCameraChange()\" step=\"0.1\" name=\"minHorizontalOrbit\">\r\n        </mat-form-field>\r\n\r\n        <mat-form-field class=\"example-full-width\" appearance=\"fill\">\r\n          <mat-label>{{'Z_POSITION'}}</mat-label>\r\n          <input matInput type=\"number\" [(ngModel)]=\"camera.position.z\" (ngModelChange)=\"handleCameraChange()\" step=\"0.1\" name=\"maxVerticalOrbit\">\r\n        </mat-form-field>\r\n\r\n        <mat-form-field class=\"example-full-width\" appearance=\"fill\">\r\n          <mat-label>{{'FOV_VALUE'}}</mat-label>\r\n          <input matInput type=\"number\" [(ngModel)]=\"camera.fov\" (ngModelChange)=\"handleCameraChange()\" step=\"1\" name=\"minVerticalOrbit\">\r\n        </mat-form-field>\r\n\r\n        <mat-slide-toggle (toggleChange)=\"handleToggleChange()\" [checked]=\"showFloorValue\"\r\n        ><mat-label>{{'SHOW_FLOOR'}}</mat-label>\r\n        </mat-slide-toggle>\r\n\r\n        <mat-slide-toggle (toggleChange)=\"handleFloorSizeChange()\" [checked]=\"originalFloorValue\"\r\n        ><mat-label>{{'ORIGINAL_SIZE'}}</mat-label>\r\n        </mat-slide-toggle>\r\n      </form>\r\n    </div>\r\n\r\n    <div mat-dialog-actions class=\"buttons-wrapper\">\r\n      <div class=\"action-buttons\">\r\n        <button mat-raised-button color=\"primary\" (click)=\"resetCamera()\">{{'RESET_CAMERA'}}</button>\r\n      </div>\r\n\r\n      <div class=\"action-buttons\">\r\n        <button mat-raised-button color=\"primary\" (click)=\"changeImage()\">{{'CHANGE_IMAGE'}}</button>\r\n      </div>\r\n    </div>\r\n  `,\r\n  styleUrls: ['./view-control.component.scss']\r\n})\r\nexport class ViewControlComponent implements OnInit {\r\n\r\n  public camera: PerspectiveCamera;\r\n  public floorPlane: Mesh;\r\n  public showFloorValue: boolean = true;\r\n  public originalFloorValue: boolean = true;\r\n\r\n  constructor(\r\n    private _viewService: ThreedInPhotoViewService,\r\n    private _buildService: ThreedInPhotoBuildService,\r\n    private _eventService: ThreedInPhotoEventService,\r\n    private _renderService: ThreedInPhotoRenderService,\r\n    private _sceneService: SceneService,\r\n    private _dialog: MatDialog,\r\n  ) { }\r\n\r\n  public ngOnInit(): void {\r\n    this.camera = this._viewService.camera;\r\n    this.floorPlane = this._buildService.floorMesh;\r\n  }\r\n\r\n  public handleCameraChange(): void {\r\n    this.camera.updateProjectionMatrix();\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  public handleToggleChange(): void {\r\n    this.showFloorValue = !this.showFloorValue;\r\n    if (this._buildService.floorMesh) {\r\n      this._buildService.floorMesh.material = !this.showFloorValue ? this._buildService.shadowMaterial : this._buildService.visibilityMaterial;\r\n      this._buildService.floorMesh.material.needsUpdate = true;\r\n      this.handleCameraChange();\r\n    }\r\n  }\r\n\r\n  public handleFloorSizeChange(): void {\r\n    this.originalFloorValue = !this.originalFloorValue;\r\n    if (this._buildService.floorMesh) {\r\n      if (!this.originalFloorValue) {\r\n        this._buildService.floorMesh.scale.set(1000, 1, 1000);\r\n      } else {\r\n        this._buildService.floorMesh.scale.set(1, 1, 1);\r\n      }\r\n      this.handleCameraChange();\r\n    }\r\n  }\r\n\r\n  public resetCamera(): void {\r\n    this.camera.position.set(0, 0, 4);\r\n    this.camera.rotation.set(0, 0, 0);\r\n    this.camera.fov = 45;\r\n    this.handleCameraChange();\r\n  }\r\n\r\n  public changeImage(): void {\r\n    this._eventService.showUploadImageDialog.next();\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/threed-in-photo/models/model-output.js

@@ -0,0 +1,18 @@
+import { Vector2, Vector3 } from 'three';
+export class ModelOutput {
+    constructor() {
+        this.polygons2D = { ceiling: [], floor: [], walls: [] };
+        this.polygons3D = { ceiling: [], floor: [], walls: [] };
+    }
+    static ObjectToModelOutput(object) {
+        const output = new ModelOutput();
+        output.polygons2D.ceiling = object.layout_2d.ceiling.map((point) => new Vector2(point[0], point[1]));
+        output.polygons2D.floor = object.layout_2d.floor.map((point) => new Vector2(point[0], point[1]));
+        output.polygons2D.walls = object.layout_2d.walls.map((polygon) => polygon.map((point) => new Vector2(point[0], point[1])));
+        output.polygons3D.ceiling = object.layout_3d.ceiling.map((point) => new Vector3(point[0], point[1], point[2]));
+        output.polygons3D.floor = object.layout_3d.floor.map((point) => new Vector3(point[0], point[1], point[2]));
+        output.polygons3D.walls = object.layout_3d.walls.map((polygon) => polygon.map((point) => new Vector3(point[0], point[1], point[2])));
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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