@eturnity/eturnity_3d 7.8.0 → 7.10.0-EPDM-10188.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "7.8.0",
+  "version": "7.10.0-EPDM-10188.1",
   "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/geometryHandler.js

@@ -80,7 +80,6 @@ export function updateBufferRoofGeometry(
     return null
   }
   const vertices = new Float32Array(triangleVertices)
-  // itemSize = 3 because there are 3 values (components) per vertex
   if (
     geometry.attributes.position &&
     geometry.attributes.position.array.length >= vertices.length
@@ -98,6 +97,7 @@ export function updateBufferRoofGeometry(
   geometry.setDrawRange(0, vertices.length / 3)
   geometry.attributes.position.needsUpdate = true
   geometry.computeVertexNormals()
+  geometry.needsUpdate = true
   return geometry
 }
 
@@ -458,7 +458,7 @@ export function getBufferImageOverlayGeometry(corners) {
   geometry.computeVertexNormals()
   return geometry
 }
-export function getBufferPanelGeometry(panelPolygon) {
+export function getPanelOutlineWithHeightOffset(panelPolygon) {
   let panelNormalVector = getNormalVectorFrom3Points(
     panelPolygon.outline[0],
     panelPolygon.outline[1],
@@ -471,15 +471,19 @@ export function getBufferPanelGeometry(panelPolygon) {
   //get lowest verticalProjection
 
   const panelOutlineTop = []
-  const geometry = new THREE.BufferGeometry()
-  //Calcul of triangles using cutear algo
-  const trianglesVertices = []
   panelPolygon.outline.forEach((p) => {
     const vectorFromBottomToTop = multiplyVector(panelHeight, panelNormalVector)
     let p_up_0 = addVector(p, vectorFromBottomToTop)
 
     panelOutlineTop.push(p_up_0)
   })
+  return panelOutlineTop
+}
+export function getBufferPanelGeometry(panelPolygon) {
+  const geometry = new THREE.BufferGeometry()
+  //Calcul of triangles using cutear algo
+  const trianglesVertices = []
+  const panelOutlineTop = getPanelOutlineWithHeightOffset(panelPolygon)
   trianglesVertices.push(...getTriangleVerticesFromOutline(panelOutlineTop))
 
   if (hasNaN(trianglesVertices)) {
@@ -514,41 +518,22 @@ export function getBufferPanelGeometry(panelPolygon) {
   return geometry
 }
 export function updateBufferPanelGeometry(panelPolygon, geometry) {
-  geometry = updateBufferRoofGeometry(panelPolygon.outline, [], geometry)
+  const panelOutlineTop = getPanelOutlineWithHeightOffset(panelPolygon)
+  geometry = updateBufferRoofGeometry(panelOutlineTop, [], geometry)
   return geometry
 }
 
-export function updateBufferPanelSideGeometry(panelPolygon, geometry) {
-  geometry = updateBufferRoofGeometry(panelPolygon.outline, [], geometry)
-  return geometry
-}
-export function getBufferPanelSideGeometry(panelPolygon) {
-  let panelNormalVector = getNormalVectorFrom3Points(
-    panelPolygon.outline[0],
-    panelPolygon.outline[1],
-    panelPolygon.outline[2]
-  )
-  if (panelNormalVector.z < 0) {
-    panelNormalVector = multiplyVector(-1, panelNormalVector)
-  }
-  const roofPolygon = panelPolygon.roof
-  const panelHeight = parseInt(panelPolygon.height || 50)
-  // const normalVector = roofPolygon.normalVector
-  // const passByPoint = roofPolygon.flatOutline[0]
-
-  const geometry = new THREE.BufferGeometry()
-  //Calcul of triangles using cutear algo
-  const panelLength = panelPolygon.outline.length
-  const trianglesVertices = []
-  const panelOutlineTop = []
-  panelPolygon.outline.forEach((p, index) => {
+export function getTriangleVerticesForSidePanels(outlineBottom, outlineUp) {
+  const triangleVertices = []
+  const length = outlineBottom.length
+  for (let index = 0; index < length; index++) {
     //const vectorFromBottomToTop=multiplyVector(obstacleHeight,{normalVector})
-    const p_bottom_0 = p
-    const p_bottom_1 = panelPolygon.outline[(index + 1) % panelLength]
-    const vectorFromBottomToTop = multiplyVector(panelHeight, panelNormalVector)
-    let p_up_0 = addVector(p_bottom_0, vectorFromBottomToTop)
-    let p_up_1 = addVector(p_bottom_1, vectorFromBottomToTop)
-    trianglesVertices.push(
+    const nextIndex = (index + 1) % length
+    const p_bottom_0 = outlineBottom[index]
+    const p_bottom_1 = outlineBottom[nextIndex]
+    let p_up_0 = outlineUp[index]
+    let p_up_1 = outlineUp[nextIndex]
+    triangleVertices.push(
       ...[
         p_up_0.x / 1000,
         p_up_0.y / 1000,
@@ -570,7 +555,49 @@ export function getBufferPanelSideGeometry(panelPolygon) {
         p_bottom_1.z / 1000
       ]
     )
-  })
+  }
+  return triangleVertices
+}
+export function updateBufferPanelSideGeometry(panelPolygon, geometry) {
+  const panelOutlineTop = getPanelOutlineWithHeightOffset(panelPolygon)
+  const triangleVertices = getTriangleVerticesForSidePanels(
+    panelPolygon.outline,
+    panelOutlineTop
+  )
+  
+  if (hasNaN(triangleVertices)) {
+    return null
+  }
+  const vertices = new Float32Array(triangleVertices)
+  if (
+    geometry.attributes.position &&
+    geometry.attributes.position.array.length >= vertices.length
+  ) {
+    let positions = geometry.attributes.position.array
+    for (let k in vertices) {
+      positions[k] = vertices[k]
+    }
+  } else {
+    geometry.dispose()
+    geometry = null
+    geometry = new THREE.BufferGeometry()
+    geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
+  }
+  geometry.setDrawRange(0, vertices.length / 3)
+  geometry.attributes.position.needsUpdate = true
+  geometry.computeVertexNormals()
+  geometry.needsUpdate = true
+ 
+  return geometry
+}
+export function getBufferPanelSideGeometry(panelPolygon) {
+  const panelOutlineTop = getPanelOutlineWithHeightOffset(panelPolygon)
+  const geometry = new THREE.BufferGeometry()
+  //Calcul of triangles using cutear algo
+  const trianglesVertices = getTriangleVerticesForSidePanels(
+    panelPolygon.outline,
+    panelOutlineTop
+  )
   if (hasNaN(trianglesVertices)) {
     return null
   }

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/mergedGeometry.js

@@ -15,10 +15,10 @@ export default {
 
         if (geometry.attributes.uv) {
           const uvs = geometry.attributes.uv.array
-          mergedUvs.push(...uvs)
+          mergedUvs.push(...uvs.slice(0, 3 * geometry.drawRange.count))
         }
       })
-
+      console.log('mergedVertices', mergedVertices[0],geometries)
       //position
       if (
         mergedGeometry.attributes.position &&

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)
         }
       })
 
@@ -67,11 +67,16 @@ export default {
           return ['panel', 'user_deactivated_panel'].includes(polygon.layer)
         })
       }
+      if (panels.length > 0) {
+        console.log('z', panels[0].outline[0].z)
+      }
+
       panels.forEach((panelPolygon) => {
         //for each visible panels
         //1. define materialId and material
         //2. create or update individual meshes
         //  2a. Fill in panelTopGeometries & panelSideGeometries
+
         if (!panelPolygon.visible) {
           return
         }
@@ -95,7 +100,7 @@ export default {
 
           materialId = 'default_' + moduleTextureId
           material = this.material.panel[materialId]
-          
+
           if (panelPolygon.moduleField.data) {
             if (
               this.material.panel[
@@ -115,67 +120,74 @@ export default {
           material.opacity = this.panelOpacity
         }
         //2. create or update individual meshes
-        if (
-          !this.meshes.panelsMeshes[panelPolygon.id + '_top'] ||
-          !this.meshes.panelsMeshes[panelPolygon.id + '_side']
-        ) {
-          //mesh creation
-          const geometry = getBufferPanelGeometry(panelPolygon)
-          const geometrySide = getBufferPanelSideGeometry(panelPolygon)
-          //2a.Fill in panelTopGeometries & panelSideGeometries
+        //update existing geometry
+        if (this.meshes.panelsMeshes[panelPolygon.id + '_top']) {
+          const topMesh = this.meshes.panelsMeshes[panelPolygon.id + '_top']
+          if (panelPolygon.version > topMesh.userData.version) {
+            let topGeometry = updateBufferPanelGeometry(
+              panelPolygon,
+              topMesh.geometry
+            )
+            topMesh.geometry = topGeometry
+          }
+
+          if (!panelTopGeometries[materialId]) {
+            panelTopGeometries[materialId] = []
+          }
+          panelTopGeometries[materialId].push(topMesh.geometry)
+          topMesh.material = material
+        }
+        if (this.meshes.panelsMeshes[panelPolygon.id + '_side']) {
+          const sideMesh = this.meshes.panelsMeshes[panelPolygon.id + '_side']
+          if (panelPolygon.version > sideMesh.userData.version) {
+            let sideGeometry = updateBufferPanelSideGeometry(
+              panelPolygon,
+              sideMesh.geometry
+            )
+            sideMesh.geometry = sideGeometry
+          }
+          if (panelPolygon.layer != 'user_deactivated_panel') {
+            panelSideGeometries.push(sideMesh.geometry)
+          }
+        }
+        //2a.Fill in panelTopGeometries & panelSideGeometries
+        //mesh creation
+        if (!this.meshes.panelsMeshes[panelPolygon.id + '_top']) {
           //gather all geometry with similar material together to merge them for faster rendering
+          const geometry = getBufferPanelGeometry(panelPolygon)
           if (!panelTopGeometries[materialId]) {
             panelTopGeometries[materialId] = []
           }
           panelTopGeometries[materialId].push(geometry)
+          if (geometry) {
+            const mesh = new THREE.Mesh(geometry, this.material.hidden)
+            mesh.userData.version = panelPolygon.version
+            mesh.userData.type = 'panelsMeshes'
+            mesh.userData.meshId = panelPolygon.id + '_top'
+            mesh.userData.polygonId = panelPolygon.id
+            //this.scene.add(mesh)
+            mesh.matrixAutoUpdate = false
+            this.meshes.panelsMeshes[panelPolygon.id + '_top'] = mesh
+          }
+        }
+        if (!this.meshes.panelsMeshes[panelPolygon.id + '_side']) {
+          //sidemesh creation
+          const geometrySide = getBufferPanelSideGeometry(panelPolygon)
           if (panelPolygon.layer != 'user_deactivated_panel') {
             panelSideGeometries.push(geometrySide)
           }
-          if (geometry && geometrySide) {
-            const mesh = new THREE.Mesh(geometry, this.material.hidden)
+          if (geometrySide) {
             const meshSide = new THREE.Mesh(
               geometrySide,
               this.material.panelSide
             )
-            mesh.userData.version = panelPolygon.version
-            mesh.userData.type = 'panelsMeshes'
-            mesh.userData.meshId = panelPolygon.id + '_top'
-            mesh.userData.polygonId = panelPolygon.id
-            this.scene.add(mesh)
             meshSide.userData.version = panelPolygon.version
             meshSide.userData.type = 'panelsMeshes'
             meshSide.userData.meshId = panelPolygon.id + '_side'
             meshSide.userData.polygonId = panelPolygon.id
-            mesh.matrixAutoUpdate = false
             meshSide.matrixAutoUpdate = false
-            this.meshes.panelsMeshes[panelPolygon.id + '_top'] = mesh
             this.meshes.panelsMeshes[panelPolygon.id + '_side'] = meshSide
           }
-        } else {
-          //update existing geometry
-          const topMesh = this.meshes.panelsMeshes[panelPolygon.id + '_top']
-          const sideMesh = this.meshes.panelsMeshes[panelPolygon.id + '_side']
-          if (panelPolygon.version > topMesh.userData.version) {
-            let topGeometry = updateBufferPanelGeometry(
-              panelPolygon,
-              topMesh.geometry
-            )
-            let sideGeometry = updateBufferPanelSideGeometry(
-              panelPolygon,
-              sideMesh.geometry
-            )
-
-            topMesh.geometry = topGeometry
-            sideMesh.geometry = sideGeometry
-          }
-          if (panelPolygon.layer != 'user_deactivated_panel') {
-            panelSideGeometries.push(sideMesh.geometry)
-          }
-          if (!panelTopGeometries[materialId]) {
-            panelTopGeometries[materialId] = []
-          }
-          panelTopGeometries[materialId].push(topMesh.geometry)
-          topMesh.material = material
         }
       })
 
@@ -186,7 +198,10 @@ 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(
@@ -202,6 +217,7 @@ export default {
           this.material.panel[key],
           'panelTop_' + key
         )
+        this.mergedPanelTopMeshes[key].renderOrder = 10
       }
       if (this.arePanelVisible) {
         this.showPanels()

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) => {