@eturnity/eturnity_3d 8.16.2-EPDM-14200.4 → 8.19.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "8.16.2-EPDM-14200.4",
+  "version": "8.19.0",
   "files": [
     "dist",
     "src"

package/src/components/ThreeCanvasViewer.vue

@@ -26,6 +26,7 @@
         layers: null,
         provider: null,
         pointer: { x: 0, y: 0 },
+        areModuleFieldsVisible: false,
         areUserDeactivatedPanelsVisible: false,
         animationFrameId: null,
         intervalId: null,

package/src/config.js

@@ -282,14 +282,3 @@ export const hitOptionStroke = {
 
 export const dragHeightSensitivity = 20
 export const snapLimit = 100
-
-export const fittingPanelsColorMap = {
-  black: '#000000',
-  blue: '#0068DE',
-  brown: '#5C4033',
-  'rustic red': '#8B0000',
-  terracotta: '#E35336',
-  transparent: 'transparent',
-  white: '#ffffff',
-  default: '#0068DE',
-}

package/src/helper/UpdateRoofModuleFieldRelations.js

@@ -3,11 +3,7 @@ import {
   verticalProjectionOnPlane,
   intersectOutlines,
   calculateArea,
-  isSelfIntersecting,
-  isPolygonInsidePolygon,
-  getConcaveOutlines,
 } from '@eturnity/eturnity_maths'
-import { fittingPanelsColorMap } from '../config'
 //this function just update the "roof" and "moduleField(s)" properties of panels,moduleFields and roofs
 export function UpdateRoofModuleFieldRelations(state) {
   let moduleFields = state.polygons.filter(
@@ -82,170 +78,3 @@ export function removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state) {
   ]
   return state
 }
-
-export function updateModuleFieldFittingPanels(moduleField) {
-  delete moduleField.fittingPanels
-  const { has_fitting_panels, fitting_panel_area_m2 } = moduleField.data
-  const hasFittingPanels = has_fitting_panels && fitting_panel_area_m2 > 0
-  if (!hasFittingPanels) return
-  const polygons = []
-
-  const outlines = getModuleFieldRoofIntersections(
-    moduleField,
-    moduleField.roof.margins.innerOutline
-  )
-  const holes = getModuleFieldHoleOutlines(moduleField)
-
-  outlines.forEach((outline) => {
-    polygons.push({
-      outline,
-      // Clean up holes outside of the outline
-      holes: holes
-        .flatMap((hole) => intersectOutlines(hole, outline))
-        .filter(Boolean),
-    })
-  })
-
-  // map backsheet color to hex color
-  const backSheetColor = moduleField.pvData?.backsheet_color || 'default'
-  const mappedColor = fittingPanelsColorMap[backSheetColor]
-
-  moduleField.fittingPanels = {
-    polygons,
-    visible: true,
-    color: mappedColor,
-  }
-}
-
-export function getRoofInnerMarginOutline({
-  roof,
-  moduleField,
-  pointer = null,
-} = {}) {
-  let roofInnerMarginOutline = roof.margins.innerOutline
-  let isOutlineSelfIntersecting = false
-  let sumAllArea = 0
-  if (isSelfIntersecting(roofInnerMarginOutline)) {
-    let selfIntersections = intersectOutlines(
-      roof.margins.innerOutline,
-      roof.margins.innerOutline
-    )
-    let sumAllArea = selfIntersections.reduce((acc, cur) => {
-      acc += calculateArea(cur)
-      return acc
-    }, 0)
-    if (moduleField) {
-      selfIntersections = selfIntersections.filter((i) => {
-        if (calculateArea(i) < 0.05 * sumAllArea) {
-          return false
-        }
-        let MFintersections = intersectOutlines(moduleField.outline, i)
-        if (MFintersections.length > 0) {
-          return true
-        }
-      })
-    } else {
-      if (pointer && pointer.reality_x && pointer.reality_y) {
-        let P = {
-          x: pointer.reality_x,
-          y: pointer.reality_y,
-          z: 0,
-        }
-        let pointerIntersections = selfIntersections.filter((outline) =>
-          isInsidePolygon(P, outline)
-        )
-        if (pointerIntersections.length) {
-          selfIntersections = pointerIntersections
-        }
-      }
-    }
-    let sortedSelfIntersections = selfIntersections.sort(
-      (a, b) => calculateArea(b) - calculateArea(a)
-    )
-    if (sortedSelfIntersections.length) {
-      roofInnerMarginOutline = sortedSelfIntersections[0]
-      isOutlineSelfIntersecting = true
-    }
-  }
-  return {
-    isSelfIntersecting: isOutlineSelfIntersecting,
-    outline: roofInnerMarginOutline,
-    totalArea: sumAllArea,
-  }
-}
-
-export function getModuleFieldRoofIntersections(
-  moduleField,
-  roofInnerMarginOutline
-) {
-  const roof = moduleField.roof
-  let intersections = intersectOutlines(
-    roofInnerMarginOutline,
-    moduleField.outline
-  )
-
-  intersections = intersections.map((i) =>
-    i.map((v) => {
-      return {
-        ...v,
-        z: verticalProjectionOnPlane(v, roof.normalVector, roof.flatOutline[0])
-          .z,
-      }
-    })
-  )
-
-  return intersections
-}
-
-export function getModuleFieldHoleOutlines(moduleField) {
-  const obstacles = []
-  const roof = moduleField.roof
-  if (roof.moduleFields && roof.moduleFields.length > 0) {
-    obstacles.push(
-      ...roof.moduleFields.filter((obstacle) => {
-        return (
-          obstacle.id != moduleField.id && //obstacle cannot be MF itself
-          obstacle.panels &&
-          obstacle.panels.length > 0 && //obstacle cannot be a moduleField without panels on
-          !isPolygonInsidePolygon(moduleField.outline, obstacle.outline) && //obstacle cannot be a container of the polygon we try to compute
-          (obstacle.priority >= moduleField.priority ||
-            isPolygonInsidePolygon(obstacle.outline, moduleField.outline)) //obstacle cannot be a MF with lower prio level (except if fully inside)
-        )
-      })
-    )
-  }
-
-  let groupedConcavePanelOutlines = []
-  obstacles.forEach((moduleField) => {
-    if (moduleField.panels.length) {
-      let groupedConcavePanelData = getConcaveOutlines(
-        moduleField.panels,
-        moduleField.panels[0].outline
-      )
-      groupedConcavePanelOutlines.push(...groupedConcavePanelData.outlines)
-    }
-  })
-
-  function verticalProjectionOnRoofFlatFace(v) {
-    const projectedZ = verticalProjectionOnPlane(
-      v,
-      roof.normalVector,
-      roof.flatOutline[0]
-    ).z
-    return { ...v, z: projectedZ }
-  }
-
-  groupedConcavePanelOutlines = groupedConcavePanelOutlines.map((outline) =>
-    outline.map((v) => verticalProjectionOnRoofFlatFace(v)).reverse()
-  )
-
-  const roofObstacleOutlines = roof.holes.map((hole) =>
-    hole.margins.outterOutline.map((v) => verticalProjectionOnRoofFlatFace(v))
-  )
-  const obstacleOutLine = [
-    ...roofObstacleOutlines,
-    ...groupedConcavePanelOutlines,
-  ]
-
-  return obstacleOutLine
-}

package/src/helper/render/clear.js

@@ -1,5 +1,3 @@
-import * as THREE from 'three'
-
 export default {
   methods: {
     clearThreeObjects(obj) {
@@ -33,7 +31,18 @@ export default {
         return
       }
       scene.remove(mesh)
-      this.disposeMesh(mesh)
+      if (mesh.geometry && mesh.geometry.dispose) {
+        mesh.geometry.dispose()
+        mesh.geometry = null
+      }
+      if (mesh.texture && mesh.texture.dispose) {
+        mesh.texture.dispose()
+        mesh.texture = null
+      }
+      if (mesh.material && mesh.material.dispose) {
+        mesh.material.dispose()
+        mesh.material = null
+      }
       if (
         mesh.userData.meshId &&
         this.meshes[mesh.userData.type][mesh.userData.meshId]
@@ -59,24 +68,19 @@ export default {
       })
     },
     clearByType(type) {
-      Object.values(this.meshes[type]).forEach((object) => {
-        object instanceof THREE.Group
-          ? object.children.forEach((c) => this.disposeMesh(c))
-          : this.disposeMesh(object)
-        this.scene.remove(object)
+      Object.values(this.meshes[type]).forEach((mesh) => {
+        mesh.geometry.dispose()
+        mesh.geometry = null
+        if (mesh.material && mesh.material.dispose) {
+          mesh.material.dispose()
+        }
+        mesh.material = null
+        this.scene.remove(mesh)
       })
       this.meshes[type] = {}
       if (this.renderer) {
         this.renderer.renderLists.dispose()
       }
     },
-    disposeMesh(mesh) {
-      if (mesh.geometry && mesh.geometry.dispose) mesh.geometry.dispose()
-      if (mesh.material && mesh.material.dispose) mesh.material.dispose()
-      if (mesh.texture && mesh.texture.dispose) mesh.texture.dispose()
-      mesh.geometry = null
-      mesh.material = null
-      mesh.texture = null
-    },
   },
 }

package/src/helper/render/edge.js

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

package/src/helper/render/geometryHandler.js

@@ -410,7 +410,7 @@ export function getBufferObstacleSideGeometry(obstaclePolygon, roofPolygon) {
 
 export function getBufferModuleFieldGeometry(moduleFieldPolygon) {
   const roofPolygon = moduleFieldPolygon.roof
-  const moduleHeight = 20
+  const moduleHeight = 10
   //get lowest verticalProjection
   const normalVector = roofPolygon.normalVector
 
@@ -747,55 +747,3 @@ export function getExtrusionGeometry(
   const geometry = new THREE.ExtrudeGeometry(shapes, settings)
   return geometry
 }
-
-export function getFittingPanelsBufferGeometry(
-  outline,
-  holes = [],
-  moduleFieldPolygon
-) {
-  const croppedHolesOutline = holes
-    .map((hole) => {
-      const cropedHoleOutline = intersectOutlines(hole, outline)[0] || []
-      return cropedHoleOutline.map((p) => {
-        return {
-          x: p.x,
-          y: p.y,
-          z: verticalProjectionOnPlane(
-            p,
-            moduleFieldPolygon.normalVector,
-            moduleFieldPolygon.flatOutline[0]
-          ).z,
-        }
-      })
-    })
-    .filter((outline) => !!outline)
-
-  // add offset to vertices for rendering
-  const FITTING_PANELS_OFFSET = 2
-  const vectorOffset = multiplyVector(
-    FITTING_PANELS_OFFSET,
-    moduleFieldPolygon.normalVector
-  )
-
-  const offsetOutline = outline.map((point) => addVector(point, vectorOffset))
-  const offsetHolesOutline = croppedHolesOutline.map((outline) =>
-    outline.map((point) => addVector(point, vectorOffset))
-  )
-
-  const geometry = new THREE.BufferGeometry()
-  const triangleVertices = getTriangleVerticesFromOutline(
-    offsetOutline,
-    offsetHolesOutline
-  )
-  if (hasNaN(triangleVertices)) {
-    return null
-  }
-  const vertices = new Float32Array(triangleVertices)
-
-  const uvs = new Float32Array([1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0])
-  geometry.setAttribute('position', new THREE.BufferAttribute(vertices, 3))
-  geometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2))
-  geometry.computeVertexNormals()
-  geometry.userData.version = 0
-  return geometry
-}

package/src/helper/render/moduleField.js

@@ -1,105 +1,43 @@
 import * as THREE from 'three'
-import {
-  getBufferModuleFieldGeometry,
-  getFittingPanelsBufferGeometry,
-} from './geometryHandler'
-
+import { getBufferModuleFieldGeometry } from './geometryHandler'
 export default {
-  data() {
-    return {
-      areModuleFieldsVisible: true,
-    }
-  },
   methods: {
+    data() {
+      return {
+        areModuleFieldsVisible: true,
+      }
+    },
     renderModuleFields() {
       this.clearByType('moduleFieldsMeshes')
       const moduleFieldPolygons = this.polygons.filter((p) =>
         ['moduleField', 'tmpModuleField'].includes(p.layer)
       )
       moduleFieldPolygons.forEach((moduleFieldPolygon) => {
-        const panelOverrideMesh =
-          this.renderModuleFieldPanelOverride(moduleFieldPolygon)
-        const fittingPanelsMesh =
-          this.renderModuleFieldFittingPanels(moduleFieldPolygon)
-
-        if (!panelOverrideMesh && !fittingPanelsMesh) return
-
-        const meshList = [panelOverrideMesh, fittingPanelsMesh]
-        const group = new THREE.Group()
-        meshList.forEach((mesh) => {
-          if (mesh) group.add(mesh)
-        })
-        group.matrixAutoUpdate = false
-        group.userData.version = moduleFieldPolygon.version
-        group.userData.type = 'moduleFieldsMeshes'
-        group.userData.layer = moduleFieldPolygon.layer
-        group.userData.meshId = moduleFieldPolygon.id
-        group.userData.polygonId = moduleFieldPolygon.id
-        group.visible = this.areModuleFieldsVisible && this.panelOpacity === 1
-        this.scene.add(group)
-        this.meshes.moduleFieldsMeshes[moduleFieldPolygon.id] = group
-        return
-      })
-    },
-    renderModuleFieldPanelOverride(moduleFieldPolygon) {
-      if (!moduleFieldPolygon?.data?.number_of_panels_override) return
-      const geometry = getBufferModuleFieldGeometry(moduleFieldPolygon)
-      const material = this.material.moduleFieldWithPanelOveride
-      if (geometry) {
-        const mesh = new THREE.Mesh(geometry, material)
-        mesh.matrixAutoUpdate = false
-        mesh.userData.version = moduleFieldPolygon.version
-        mesh.userData.type = 'moduleFieldsMeshes_panelOverride'
-        mesh.userData.layer = moduleFieldPolygon.layer
-        mesh.userData.meshId = moduleFieldPolygon.id
-        mesh.userData.polygonId = moduleFieldPolygon.id
-        mesh.renderOrder = 5
-        return mesh
-      }
-    },
-    renderModuleFieldFittingPanels(moduleFieldPolygon) {
-      if (!moduleFieldPolygon?.fittingPanels?.polygons?.length) return
-      const { polygons, visible, color } = moduleFieldPolygon.fittingPanels
-
-      const geometries = []
-      polygons.forEach((polygon) => {
-        const { outline, holes } = polygon
-        const geometry = getFittingPanelsBufferGeometry(
-          outline,
-          holes,
-          moduleFieldPolygon
-        )
-        geometries.push(geometry)
-      })
-
-      if (!geometries.length) return
-
-      const mergedGeometry = this.createMergedGeometry(geometries)
-      const isTransparent = color === 'transparent'
-      const material = new THREE.MeshBasicMaterial({
-        color: isTransparent ? '#ffffff' : color,
-        side: THREE.DoubleSide,
-        transparent: true,
-        opacity: isTransparent ? 0.2 : 0.8,
+        let material
+        if (moduleFieldPolygon.data.number_of_panels_override) {
+          material = this.material.moduleFieldWithPanelOveride
+        } else {
+          return
+        }
+        const geometry = getBufferModuleFieldGeometry(moduleFieldPolygon)
+        if (geometry) {
+          const mesh = new THREE.Mesh(geometry, material)
+          mesh.matrixAutoUpdate = false
+          mesh.userData.version = moduleFieldPolygon.version
+          mesh.userData.type = 'moduleFieldsMeshes'
+          mesh.userData.layer = moduleFieldPolygon.layer
+          mesh.userData.meshId = moduleFieldPolygon.id
+          mesh.userData.polygonId = moduleFieldPolygon.id
+          mesh.visible = this.areModuleFieldsVisible
+          this.scene.add(mesh)
+          this.meshes.moduleFieldsMeshes[moduleFieldPolygon.id] = mesh
+        }
       })
-
-      const mesh = new THREE.Mesh(mergedGeometry, material)
-      mesh.visible = visible
-      mesh.matrixAutoUpdate = false
-      mesh.userData.version = moduleFieldPolygon.version
-      mesh.userData.type = 'moduleFieldsMeshes_fittingPanels'
-      mesh.userData.layer = moduleFieldPolygon.layer
-      mesh.userData.meshId = moduleFieldPolygon.id
-      mesh.userData.polygonId = moduleFieldPolygon.id
-      mesh.renderOrder = 5
-      return mesh
     },
-    updateModuleFieldsVisibility(isVisible) {
+    setModuleFieldsVisibility(isVisible) {
       this.areModuleFieldsVisible = isVisible
       Object.values(this.meshes['moduleFieldsMeshes']).forEach(
-        (mesh) =>
-          (mesh.visible =
-            this.areModuleFieldsVisible && this.panelOpacity === 1)
+        (mesh) => (mesh.visible = isVisible)
       )
     },
   },

package/src/helper/render/tile.js

@@ -295,7 +295,7 @@ export default {
               mesh.castShadow = false
               mesh.updateMatrix()
             } else {
-              material = new THREE.MeshPhongMaterial({
+              material = new THREE.MeshPhysicalMaterial({
                 map: texture,
                 color: 0xffffff,
                 side: THREE.FrontSide,
@@ -448,7 +448,7 @@ export default {
               googleMapType
             )
           }
-          planeMaterial[indexGoogleBackground] = new THREE.MeshPhongMaterial({
+          planeMaterial[indexGoogleBackground] = new THREE.MeshPhysicalMaterial({
             map: planeTexture[indexGoogleBackground],
             side: THREE.DoubleSide,
             shininess: 0,

package/src/helper/renderMixin.js

@@ -302,11 +302,6 @@ export default {
             method: this.renderPanels,
             arg: [],
           })
-          methodList.push({
-            name: 'updateModuleFieldsVisibility',
-            method: this.updateModuleFieldsVisibility,
-            arg: [this.areModuleFieldsVisible],
-          })
           break
         case 'addPointToPolygon': //params.polygon,index
         case 'removeObstacle': //params:obstacle
@@ -427,18 +422,11 @@ export default {
           break
         case 'updateIsYearlyShadingHeatmapActive':
           methodList.push({
-            name: 'updateModuleFieldsVisibility',
-            method: this.updateModuleFieldsVisibility,
+            name: 'setModuleFieldsVisibility',
+            method: this.setModuleFieldsVisibility,
             arg: [!params.value],
           })
           break
-        case 'updateModuleFieldsVisibility':
-          methodList.push({
-            name: 'updateModuleFieldsVisibility',
-            method: this.updateModuleFieldsVisibility,
-            arg: [params.value],
-          })
-          break
         case 'selectedPanelChange':
           methodList.push({
             name: 'renderModuleFields',

package/src/store/hydrateData.js

@@ -2,15 +2,13 @@
 import {
   Polygon,
   updateComputedGeometryPolygon,
+  getRoofMarginOutline,
   getObstacleMarginOutline,
+  midPoint,
 } from '@eturnity/eturnity_maths'
 import OverlayLayer from '../Overlay/OverlayLayer'
 import getLayers from '../utils/layers'
 import { UpdateRoofObstacleRelations } from '../helper/UpdateRoofObstacleRelations'
-import {
-  updateModuleFieldFittingPanels,
-  UpdateRoofModuleFieldRelations,
-} from '../helper/UpdateRoofModuleFieldRelations'
 function sanitizedOutline(outline) {
   return outline.reduce((accumulator, currentValue) => {
     if (
@@ -130,7 +128,6 @@ export async function hydratePolygons({
     moduleField.mountingData = {}
     moduleField.pvData.module_texture_version_id =
       moduleFieldResp.module_texture_version_id
-    moduleField.pvData.backsheet_color = moduleFieldResp.backsheet_color
     moduleField.data = {}
     moduleField.data.texture_img_url = moduleFieldResp.texture_img_url
     moduleField.data.col_spacing_mm = moduleFieldResp.col_spacing_mm
@@ -141,8 +138,7 @@ export async function hydratePolygons({
     moduleField.data.row_spacing_valley_mm =
       moduleFieldResp.row_spacing_valley_mm
     moduleField.data.offset_percent = moduleFieldResp.offset_percent
-    moduleField.data.fitting_panel_area_m2 =
-      moduleFieldResp.fitting_panel_area_m2
+    moduleField.data.fitting_panel_area_m2 = moduleFieldResp.fitting_panel_area_m2
     moduleField.data.has_fitting_panels = moduleFieldResp.has_fitting_panels
     moduleField.data.panel_orientation = moduleFieldResp.panel_orientation
     moduleField.data.panel_direction_degrees =
@@ -299,10 +295,4 @@ export async function hydrateData({ state, commit }, data) {
   state.polygons = hydratationResult.polygons
 
   state = UpdateRoofObstacleRelations(state)
-  state = UpdateRoofModuleFieldRelations(state)
-  state.polygons
-    .filter((poly) => poly.layer == 'moduleField')
-    .forEach((moduleField) => {
-      updateModuleFieldFittingPanels(moduleField)
-    })
 }