@eturnity/eturnity_3d 7.10.2-EPDM-10285.0 → 7.10.2-qa-dev03-7.12.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "7.10.2-EPDM-10285.0",
+  "version": "7.10.2-qa-dev03-7.12.0",
   "main": "dist/main.js",
   "scripts": {
     "dev": "vue-cli-service serve --skip-plugins @vue/cli-plugin-eslint",

package/src/helper/render/geometryHandler.js

@@ -8,8 +8,7 @@ import {
   getNormalVectorFrom3Points,
   hasNaN,
   getDistanceBetweenPoints,
-  intersectOutlines,
-  isSameSegment2D
+  intersectOutlines
 } from '@eturnity/eturnity_maths'
 
 export function getTriangleVerticesFromOutline(
@@ -153,7 +152,7 @@ export function getWallVertices(polygon) {
     )
   })
 
-  polygon.holes.forEach((hole, holeIndex) => {
+  polygon.holes.forEach((hole) => {
     let obstacleWallOutline =
       intersectOutlines(hole.outline, polygon.outline)[0] || []
     obstacleWallOutline = obstacleWallOutline.map((p) => {
@@ -166,47 +165,34 @@ export function getWallVertices(polygon) {
         ).z
       }
     })
-
     const lengthHole = obstacleWallOutline.length
     obstacleWallOutline.forEach((p_up_0, index) => {
       const p_up_1 = obstacleWallOutline[(index + 1) % lengthHole]
       const p_bottom_0 = { ...p_up_0, z: 0 }
       const p_bottom_1 = { ...p_up_1, z: 0 }
 
-      const isEdgeConnectedToRoof = !polygon.holes.some((hole, i) => {
-        return (
-          holeIndex != i &&
-          hole.outline.some((p, p_index, outline) => {
-            let p_next_index = (p_index + 1) % outline.length
-            return isSameSegment2D([p_up_0, p_up_1], [p, outline[p_next_index]])
-          })
-        )
-      })
-
-      if (isEdgeConnectedToRoof) {
-        trianglesVertices.push(
-          ...[
-            p_up_0.x / 1000,
-            p_up_0.y / 1000,
-            p_up_0.z / 1000,
-            p_up_1.x / 1000,
-            p_up_1.y / 1000,
-            p_up_1.z / 1000,
-            p_bottom_0.x / 1000,
-            p_bottom_0.y / 1000,
-            p_bottom_0.z / 1000,
-            p_up_1.x / 1000,
-            p_up_1.y / 1000,
-            p_up_1.z / 1000,
-            p_bottom_0.x / 1000,
-            p_bottom_0.y / 1000,
-            p_bottom_0.z / 1000,
-            p_bottom_1.x / 1000,
-            p_bottom_1.y / 1000,
-            p_bottom_1.z / 1000
-          ]
-        )
-      }
+      trianglesVertices.push(
+        ...[
+          p_up_0.x / 1000,
+          p_up_0.y / 1000,
+          p_up_0.z / 1000,
+          p_up_1.x / 1000,
+          p_up_1.y / 1000,
+          p_up_1.z / 1000,
+          p_bottom_0.x / 1000,
+          p_bottom_0.y / 1000,
+          p_bottom_0.z / 1000,
+          p_up_1.x / 1000,
+          p_up_1.y / 1000,
+          p_up_1.z / 1000,
+          p_bottom_0.x / 1000,
+          p_bottom_0.y / 1000,
+          p_bottom_0.z / 1000,
+          p_bottom_1.x / 1000,
+          p_bottom_1.y / 1000,
+          p_bottom_1.z / 1000
+        ]
+      )
     })
   })
   if (hasNaN(trianglesVertices)) {
@@ -578,7 +564,7 @@ export function updateBufferPanelSideGeometry(panelPolygon, geometry) {
     panelPolygon.outline,
     panelOutlineTop
   )
-
+  
   if (hasNaN(triangleVertices)) {
     return null
   }
@@ -601,7 +587,7 @@ export function updateBufferPanelSideGeometry(panelPolygon, geometry) {
   geometry.attributes.position.needsUpdate = true
   geometry.computeVertexNormals()
   geometry.needsUpdate = true
-
+ 
   return geometry
 }
 export function getBufferPanelSideGeometry(panelPolygon) {

package/src/helper/render/roof.js

@@ -18,23 +18,25 @@ export default {
   methods: {
     updateRoofGeometry(geometry, roofPolygon) {
       const roofOutline = roofPolygon.outline
-      let cropedHolesOutline = roofPolygon.holes.map((h) => {
-        //let's crop obstacle with roof outline
-        const cropedHoleOutline =
-          intersectOutlines(h.outline, roofPolygon.outline)[0] || []
-        const outline = cropedHoleOutline.map((p) => {
-          return {
-            x: p.x,
-            y: p.y,
-            z: verticalProjectionOnPlane(
-              p,
-              roofPolygon.normalVector,
-              roofPolygon.flatOutline[0]
-            ).z
-          }
+      let cropedHolesOutline = roofPolygon.holes
+        .filter((h) => h.layer == 'obstacle')
+        .map((h) => {
+          //let's crop obstacle with roof outline
+          const cropedHoleOutline =
+            intersectOutlines(h.outline, roofPolygon.outline)[0] || []
+          const outline = cropedHoleOutline.map((p) => {
+            return {
+              x: p.x,
+              y: p.y,
+              z: verticalProjectionOnPlane(
+                p,
+                roofPolygon.normalVector,
+                roofPolygon.flatOutline[0]
+              ).z
+            }
+          })
+          return outline
         })
-        return outline
-      })
 
       cropedHolesOutline = cropedHolesOutline.filter((outline) => !!outline)
       geometry = updateBufferRoofGeometry(
@@ -47,23 +49,25 @@ export default {
     },
     createRoofGeometry(roofPolygon) {
       const roofOutline = roofPolygon.outline
-      let cropedHolesOutline = roofPolygon.holes.map((h) => {
-        //let's crop obstacle with roof outline
-        const cropedHoleOutline =
-          intersectOutlines(h.outline, roofPolygon.outline)[0] || []
-        const outline = cropedHoleOutline.map((p) => {
-          return {
-            x: p.x,
-            y: p.y,
-            z: verticalProjectionOnPlane(
-              p,
-              roofPolygon.normalVector,
-              roofPolygon.flatOutline[0]
-            ).z
-          }
+      let cropedHolesOutline = roofPolygon.holes
+        .filter((h) => h.layer == 'obstacle')
+        .map((h) => {
+          //let's crop obstacle with roof outline
+          const cropedHoleOutline =
+            intersectOutlines(h.outline, roofPolygon.outline)[0] || []
+          const outline = cropedHoleOutline.map((p) => {
+            return {
+              x: p.x,
+              y: p.y,
+              z: verticalProjectionOnPlane(
+                p,
+                roofPolygon.normalVector,
+                roofPolygon.flatOutline[0]
+              ).z
+            }
+          })
+          return outline
         })
-        return outline
-      })
 
       cropedHolesOutline = cropedHolesOutline.filter((outline) => !!outline)
       let geometry = getBufferRoofGeometry(roofOutline, cropedHolesOutline)

package/src/store/nodesEdgesCreation.js

@@ -4,8 +4,7 @@ import {
   isAlmostSamePoint3D,
   isAlmostSameSegment2D,
   isAlmostSameSegment3D,
-  isAlmostSamePoint2D,
-  verticalProjectionOnPlane
+  isAlmostSamePoint2D
 } from '@eturnity/eturnity_maths'
 
 export function generateNodes2D(polygons) {
@@ -57,15 +56,14 @@ export function generateNodes2D(polygons) {
     if (node2D.masterHandle) {
       node2D.masterHandle.open = node2D.belongsTo.some(
         (item) =>
-          item.index == null ||
           item.polygon.outline[item.index].open ||
           item.polygon.outline[item.index].hasWarning
       )
       node2D.masterHandle.hasWarning = node2D.belongsTo.some(
-        (item) => item.index == null || item.polygon.outline[item.index].hasWarning
+        (item) => item.polygon.outline[item.index].hasWarning
       )
       node2D.masterHandle.selected = node2D.belongsTo.every(
-        (item) => item.index == null || item.polygon.outline[item.index].selected
+        (item) => item.polygon.outline[item.index].selected
       )
     }
   })
@@ -161,62 +159,20 @@ export function generateEdges2D(polygons, splitEdgesIds = []) {
           index: i,
           polygon
         })
-        if (polygon.roofs && polygon.roofs.length > 0) {
-          polygon.roofs.forEach((supportRoof) => {
-            edge2D.belongsTo.push({
-              polygonId: supportRoof.id,
-              index: null,
-              polygon: supportRoof
-            })
-          })
-        }
         edge2D.id += '_' + polygon.id + '_' + i
       })
     })
   edges2D.forEach((edge2D) => {
     edge2D.isSplit = splitEdgesIds.includes(edge2D.id)
-    if (edge2D.belongsTo.length > 2) {
-      edge2D.belongsTo = edge2D.belongsTo.filter((i) => i.index !== null)
-    }
   })
   edges2D.forEach((edge2D) => {
     const isNotSplit = edge2D.belongsTo.every((item, index, array) => {
-      if (index == 0) {
-        return true
-      }
       const outline0 = array[0].polygon.outline
       const outline1 = item.polygon.outline
-      let point0, point1, nextPoint0, nextPoint1
-      if (array[0].index !== null) {
-        point0 = outline0[array[0].index]
-        nextPoint0 = outline0[(array[0].index + 1) % outline0.length]
-      } else {
-        point0 = verticalProjectionOnPlane(
-          outline1[item.index],
-          array[0].polygon.normalVector,
-          array[0].polygon.flatOutline[0]
-        )
-        nextPoint0 = verticalProjectionOnPlane(
-          outline1[(item.index + 1) % outline1.length],
-          array[0].polygon.normalVector,
-          array[0].polygon.flatOutline[0]
-        )
-      }
-      if (item.index !== null) {
-        point1 = outline1[item.index]
-        nextPoint1 = outline1[(item.index + 1) % outline1.length]
-      } else {
-        point1 = verticalProjectionOnPlane(
-          outline0[array[0].index],
-          item.polygon.normalVector,
-          item.polygon.flatOutline[0]
-        )
-        nextPoint1 = verticalProjectionOnPlane(
-          outline0[(array[0].index + 1) % outline0.length],
-          item.polygon.normalVector,
-          item.polygon.flatOutline[0]
-        )
-      }
+      const point0 = outline0[array[0].index]
+      const nextPoint0 = outline0[(array[0].index + 1) % outline0.length]
+      const point1 = outline1[item.index]
+      const nextPoint1 = outline1[(item.index + 1) % outline1.length]
       return isAlmostSameSegment3D(
         [point0, nextPoint0],
         [point1, nextPoint1],

package/src/utils/layers.js

@@ -3,24 +3,38 @@ import 'leaflet.gridlayer.googlemutant'
 import { leafletMapLayersConfig } from './leaflet-config.service'
 
 function getLayers() {
-  const googleLayer = L.gridLayer.googleMutant({
-    type: 'hybrid',
-    layerTypeAPI: 'googleLayer',
-    maxNativeZoom: 25,
-    maxZoom: 25
-  })
-  const googleLayerRoadmap = L.gridLayer.googleMutant({
-    type: 'roadmap',
-    layerTypeAPI: 'googleLayerRoadmap',
-    maxNativeZoom: 25,
-    maxZoom: 25
-  })
-  const googleLayerTerrain = L.gridLayer.googleMutant({
-    type: 'terrain',
-    layerTypeAPI: 'googleLayerTerrain',
-    maxNativeZoom: 25,
-    maxZoom: 25
-  })
+  const googleLayer = L.tileLayer(
+    'http://{s}.google.com/vt/lyrs=s,h&x={x}&y={y}&z={z}',
+    {
+      subdomains: ['mt0', 'mt1', 'mt2', 'mt3'],
+      type: 'hybrid',
+      layerTypeAPI: 'googleLayer',
+      maxNativeZoom: 21,
+      maxZoom: 25
+    }
+  )
+
+  const googleLayerRoadmap = L.tileLayer(
+    'http://{s}.google.com/vt/lyrs=m&x={x}&y={y}&z={z}',
+    {
+      subdomains: ['mt0', 'mt1', 'mt2', 'mt3'],
+      type: 'roadmap',
+      layerTypeAPI: 'googleLayerRoadmap',
+      maxNativeZoom: 21,
+      maxZoom: 25
+    }
+  )
+
+  const googleLayerTerrain = L.tileLayer(
+    'http://{s}.google.com/vt/lyrs=p&x={x}&y={y}&z={z}',
+    {
+      subdomains: ['mt0', 'mt1', 'mt2', 'mt3'],
+      type: 'terrain',
+      layerTypeAPI: 'googleLayerTerrain',
+      maxNativeZoom: 21,
+      maxZoom: 25
+    }
+  )
   // TODO activate for different users
   const baseMapLayer = L.tileLayer(
     'http://{s}.wien.gv.at/basemap/geolandbasemap/normal/google3857/{z}/{y}/{x}.png',