@eturnity/eturnity_3d 7.8.0 → 7.10.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "7.8.0",
+  "version": "7.10.0",
   "main": "dist/main.js",
   "scripts": {
     "dev": "vue-cli-service serve --skip-plugins @vue/cli-plugin-eslint",
@@ -10,7 +10,7 @@
     "prettier": "prettier --write \"**/*.{js,vue}\""
   },
   "dependencies": {
-    "@eturnity/eturnity_maths": "7.4.0",
+    "@eturnity/eturnity_maths": "7.10.0",
     "core-js": "^2.6.12",
     "cors": "^2.8.5",
     "earcut": "^2.2.4",

package/src/config.js

@@ -4,7 +4,8 @@ export const snapToPointTolerance = 15
 export const snapToIntersectionPointTolerance = 15
 export const snapToLineTolerance = 10
 export const distanceToCloseNode = 70
-export const mmTolerance = 1
+export const mmTolerance = 5
+export const mmTolerance3dNode = 50
 export const earthRadius = 6371008
 export const marginAroundBuildingForCameraViewInMeter = 5
 export const layerColors = {

package/src/helper/UpdateRoofModuleFieldRelations.js

@@ -35,7 +35,7 @@ export function UpdateRoofModuleFieldRelations(state) {
       const intersection = intersectOutlines(moduleField.outline, roof.outline)
       if (intersection.length == 0) return false
       const intersectionArea = calculateArea(intersection[0])
-      return intersectionArea > 100 && moduleField.area <= roof.area
+      return intersectionArea > 100 && moduleField.area <= roof.area + 0.1
     })
     //roofs on roof can lead to multiple roof under a point. moduleField is on the smallest
     let smallestRoof = null

package/src/helper/cameraMixin.js

@@ -315,6 +315,38 @@ export default {
         y
       })
     },
+    setCameraInitialPosition() {
+      if (this.roofs.length == 0) return
+      let newFov = 50
+      let bounds = this.roofsBounds
+      let targetVector = {
+        x: (bounds.xMax + bounds.xMin) / 2000,
+        y: (bounds.yMax + bounds.yMin) / 2000,
+        z: 0
+      }
+      let objectRadius_m = Math.max(
+        (bounds.xMax - bounds.xMin) / 2000,
+        (bounds.yMax - bounds.yMin) / 2000
+      )
+      let distance =
+        5 + objectRadius_m / Math.sin(((newFov / 2) * Math.PI) / 180)
+      let cameraMoveVector = { x: 0, y: 0, z: distance }
+      const positionVector = addVector(targetVector, cameraMoveVector)
+      const position = [
+        positionVector.x,
+        positionVector.y - distance,
+        positionVector.z
+      ]
+      let target = [targetVector.x, targetVector.y, targetVector.z]
+
+      this.camera.position.set(position[0], position[1], position[2])
+      this.camera.updateProjectionMatrix()
+
+      this.orbitControl.target.set(target[0], target[1], target[2])
+      if (this.orbitControl && this.orbitControl.update) {
+        this.orbitControl.update()
+      }
+    },
     setCameraGlobalPosition() {
       if (this.roofs.length == 0) return
       if (this.camera.isOrthographicCamera) {

package/src/helper/render/clear.js

@@ -35,18 +35,18 @@ export default {
             let meshTop = this.meshes.panelsMeshes[panel.id + '_top']
             let meshSide = this.meshes.panelsMeshes[panel.id + '_side']
             if (meshTop || meshSide) {
-              this.clearMesh(meshTop)
-              this.clearMesh(meshSide)
+              this.clearMeshFromScene(meshTop, this.scene)
+              this.clearMeshFromScene(meshSide, this.scene)
             }
           })
         )
       )
     },
-    clearMesh(mesh) {
-      if (!mesh || !this.scene) {
+    clearMeshFromScene(mesh, scene) {
+      if (!mesh || !scene) {
         return
       }
-      this.scene.remove(mesh)
+      scene.remove(mesh)
       if (mesh.geometry && mesh.geometry.dispose) {
         mesh.geometry.dispose()
         mesh.geometry = null
@@ -72,14 +72,14 @@ export default {
     clearEdgesRemovedOnes() {
       Object.values(this.meshes['edgeMeshes']).forEach((mesh) => {
         if (!this.edgeIds.includes(mesh.userData.edgeId)) {
-          this.clearMesh(mesh)
+          this.clearMeshFromScene(mesh, this.scene)
         }
       })
     },
     clearRemovedOnes(type) {
       Object.values(this.meshes[type]).forEach((mesh) => {
         if (!this.polygonIds.includes(mesh.userData.polygonId)) {
-          this.clearMesh(mesh)
+          this.clearMeshFromScene(mesh, this.scene)
         }
       })
     },

package/src/helper/render/edge.js

@@ -88,6 +88,8 @@ export default {
           cylinder.userData.type = 'edgeMeshes'
           cylinder.userData.layer = edge.layer
 
+          cylinder.frustumCulled = false
+          cylinder.renderOrder = 10
           this.meshes.edgeMeshes[edge.id] = cylinder
           this.scene.add(cylinder)
         }

package/src/helper/render/imageOverlay.js

@@ -34,7 +34,7 @@ export default {
   methods: {
     renderImageOverlayOnBackground() {
       if (!this.imageOverlay || !this.imageOverlayMaterial) {
-        this.clearMesh(this.meshes.backgroundMesh)
+        this.clearMeshFromScene(this.meshes.backgroundMesh, this.scene)
         this.meshes.backgroundMesh = null
         return
       }

package/src/helper/render/panel.js

@@ -48,14 +48,14 @@ export default {
               poly.layer == 'user_deactivated_panel'
           )
         ) {
-          this.clearMesh(mesh)
+          this.clearMeshFromScene(mesh, this.scene)
         }
         //clear panel on moduleField with overriden number of panel
         let panel = this.polygons.find(
           (poly) => mesh.userData.polygonId == poly.id
         )
         if (!panel || panel.moduleField.data.number_of_panels_override) {
-          this.clearMesh(mesh)
+          this.clearMeshFromScene(mesh, this.scene)
         }
       })
 
@@ -186,7 +186,7 @@ export default {
       )
       //if no panels, no materialIds,
       for (let materialId of materialIdsToRemove) {
-        this.clearMesh(this.mergedPanelTopMeshes[materialId])
+        this.clearMeshFromScene(this.mergedPanelTopMeshes[materialId], this.scene)
         delete this.mergedPanelTopMeshes[materialId]
       }
       this.mergedPanelSideMesh = this.updateOrCreateMergedMesh(

package/src/helper/render/tile.js

@@ -56,7 +56,7 @@ export default {
         return !tileToRenderIds.includes(id)
       })
       for (let id of idsToRemove) {
-        this.clearMesh(this.meshes.tileMeshes[id])
+        this.clearMeshFromScene(this.meshes.tileMeshes[id], this.scene)
       }
     },
     async renderProviderTiles() {

package/src/helper/renderMixin.js

@@ -65,6 +65,13 @@ export default {
           e.name == 'setCameraGlobalPosition'
       )
     },
+    setInitialPositionRenderNeeded() {
+      return !!this.geometryEvents.find(
+        (e) =>
+          e.id > this.lastGeometryEventIdDone &&
+          e.name == 'setInitialPositionRenderNeeded'
+      )
+    },
     fullRenderNeeded() {
       return !!this.geometryEvents.find(
         (e) => e.id > this.lastGeometryEventIdDone && e.name == 'full'
@@ -74,6 +81,9 @@ export default {
       return this.geometryEvents.filter(
         (e) => e.id > this.lastGeometryEventIdDone
       )
+    },
+    geometryEventsToDoWithoutFull() {
+      return this.geometryEventsToDo.filter((e) => e.name != 'full')
     }
   },
   methods: {
@@ -81,22 +91,17 @@ export default {
       let methodList = []
       if (this.fullRenderNeeded) {
         methodList = this.renderingMethodsByEvent({ name: 'full' })
-        if (this.setGlobalPositionRenderNeeded) {
-          methodList.push(
-            ...this.renderingMethodsByEvent({ name: 'setCameraGlobalPosition' })
-          )
-        }
-      } else {
-        for (let geometryEvent of this.geometryEventsToDo) {
-          for (let renderingMethod of this.renderingMethodsByEvent(
-            geometryEvent
-          )) {
-            if (!methodList.map((m) => m.name).includes(renderingMethod.name)) {
-              methodList.push(renderingMethod)
-            }
+      }
+      for (let geometryEvent of this.geometryEventsToDoWithoutFull) {
+        for (let renderingMethod of this.renderingMethodsByEvent(
+          geometryEvent
+        )) {
+          if (!methodList.map((m) => m.name).includes(renderingMethod.name)) {
+            methodList.push(renderingMethod)
           }
         }
       }
+
       if (methodList.length) {
         this.renderMethods(methodList)
         this.render()
@@ -131,6 +136,13 @@ export default {
             arg: []
           })
           break
+        case 'setCameraInitialPosition':
+          methodList.push({
+            name: 'setCameraInitialPosition',
+            method: this.setCameraInitialPosition,
+            arg: []
+          })
+          break
         case 'toolChange': //params.toolName
           methodList.push({
             name: 'renderEdges',
@@ -213,6 +225,11 @@ export default {
               method: this.renderObstacles,
               arg: []
             })
+            methodList.push({
+              name: 'renderNodes',
+              method: this.renderNodes,
+              arg: []
+            })
           } else if (params.layer == 'obstacle') {
             methodList.push({
               name: 'renderBase',
@@ -257,6 +274,11 @@ export default {
         case 'newRoofs':
         case 'moveNodesZ': //params.nodes
         case 'solveFlatness': //params.roof
+          methodList.push({
+            name: 'renderEdges',
+            method: this.renderEdges,
+            arg: []
+          })
           methodList.push({
             name: 'renderBuilding',
             method: this.renderBuilding,

package/src/helper/threeMixin.js

@@ -66,12 +66,14 @@ export default {
     },
     initialiseRenderer() {
       this.resizeRenderer(this.DOMElement)
-      this.renderer.setPixelRatio(window.devicePixelRatio)
-      this.renderer.toneMappingExposure = 0.01
-      this.DOMElement.appendChild(this.renderer.domElement)
+      if (this.renderer) {
+        this.renderer.setPixelRatio(window.devicePixelRatio)
+        this.renderer.toneMappingExposure = 0.01
+        this.DOMElement.appendChild(this.renderer.domElement)
+      }
     },
     resizeRenderer() {
-      if(this.DOMElement){
+      if (this.DOMElement) {
         const width = this.DOMElement.clientWidth
         const height = this.DOMElement.clientHeight
         this.renderer.domElement.style.width = width + 'px'

package/src/store/nodesEdgesCreation.js

@@ -1,5 +1,5 @@
 import { Point, Line } from '@eturnity/eturnity_maths'
-import { mmTolerance } from '../config'
+import { mmTolerance, mmTolerance3dNode } from '../config'
 import {
   isAlmostSamePoint3D,
   isAlmostSameSegment2D,
@@ -54,20 +54,17 @@ export function generateNodes2D(polygons) {
   //all nodes has been created. now lets update open/selected field
   nodes2D.forEach((node2D) => {
     if (node2D.masterHandle) {
-      node2D.masterHandle.open =
-        node2D.belongsTo.filter(
-          (item) =>
-            item.polygon.outline[item.index].open ||
-            item.polygon.outline[item.index].hasWarning
-        ).length > 0
-      node2D.masterHandle.hasWarning =
-        node2D.belongsTo.filter(
-          (item) => item.polygon.outline[item.index].hasWarning
-        ).length > 0
-      node2D.masterHandle.selected =
-        node2D.belongsTo.filter(
-          (item) => item.polygon.outline[item.index].selected
-        ).length == node2D.belongsTo.length
+      node2D.masterHandle.open = node2D.belongsTo.some(
+        (item) =>
+          item.polygon.outline[item.index].open ||
+          item.polygon.outline[item.index].hasWarning
+      )
+      node2D.masterHandle.hasWarning = node2D.belongsTo.some(
+        (item) => item.polygon.outline[item.index].hasWarning
+      )
+      node2D.masterHandle.selected = node2D.belongsTo.every(
+        (item) => item.polygon.outline[item.index].selected
+      )
     }
   })
   return nodes2D
@@ -84,7 +81,7 @@ export function generateNodes3D(polygons) {
       outline.forEach((point, i) => {
         //check if nodes2D already exist
         let node3D = nodes3D.find((node) =>
-          isAlmostSamePoint3D(node, point, mmTolerance)
+          isAlmostSamePoint3D(node, point, mmTolerance3dNode)
         )
         if (!node3D) {
           node3D = new Point(point.x, point.y, point.z, polygon.layer)
@@ -111,9 +108,9 @@ export function generateNodes3D(polygons) {
   //all nodes has been created. now lets update open/selected field
   nodes3D.forEach((node3D) => {
     if (node3D.masterHandle) {
-      node3D.masterHandle.open =
-        node3D.belongsTo.filter((item) => item.polygon.outline[item.index].open)
-          .length > 0
+      node3D.masterHandle.open = node3D.belongsTo.some(
+        (item) => item.polygon.outline[item.index].open
+      )
       node3D.masterHandle.selected = node3D.belongsTo.every(
         (item) => item.polygon.outline[item.index].selected
       )
@@ -131,7 +128,8 @@ export function generateEdges2D(polygons) {
     .forEach((polygon) => {
       const outline = polygon.outline
       outline.forEach((point, i) => {
-        if (!polygon.isClosed && i == outline.length - 1) {
+        const isLastPointOfPolygon = i == outline.length - 1
+        if (!polygon.isClosed && isLastPointOfPolygon) {
           return
         }
         //check if edge2D already exist
@@ -176,6 +174,10 @@ export function generateEdges3D(polygons) {
     .forEach((polygon) => {
       const outline = polygon.outline
       outline.forEach((point, i) => {
+        const isLastPointOfPolygon = i == outline.length - 1
+        if (!polygon.isClosed && isLastPointOfPolygon) {
+          return
+        }
         //check if edge2D already exist
         const nextPoint = outline[(i + 1) % outline.length]
         let edge3D = edges3D.find((edge) => {