@eturnity/eturnity_3d 8.16.1 → 8.16.2-EPDM-14200.0

package/package.json

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

package/src/components/ThreeCanvasViewer.vue

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

package/src/config.js

@@ -282,3 +282,14 @@ 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,7 +3,11 @@ 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(
@@ -78,3 +82,168 @@ export function removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state) {
   ]
   return state
 }
+
+export function updateModuleFieldFittingPanels({
+  moduleField,
+  state,
+  preComputed = false,
+  outline = [],
+  holes = [],
+}) {
+  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 computedOutline = preComputed
+    ? outline
+    : getModuleFieldRoofIntersection(
+        moduleField,
+        getRoofInnerMarginOutline(moduleField.roof, moduleField, state).outline
+      )
+
+  const computedHoles = preComputed
+    ? holes
+    : getModuleFieldHoleOutlines(moduleField)
+
+  // Clean up holes outside of the outline
+  const holesClean = computedHoles
+    .map((hole) => intersectOutlines(hole, computedOutline)[0])
+    .filter(Boolean)
+
+  // map backsheet color to hex color
+  const backSheetColor = moduleField.pvData?.backsheet_color || 'default'
+  const mappedColor = fittingPanelsColorMap[backSheetColor]
+
+  moduleField.fittingPanels = {
+    outline: computedOutline,
+    holes: holesClean,
+    visible: true,
+    color: mappedColor,
+  }
+}
+
+export function getRoofInnerMarginOutline(roof, moduleField, state) {
+  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 (state.pointer && state.pointer.reality_x && state.pointer.reality_y) {
+        let P = {
+          x: state.pointer.reality_x,
+          y: state.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 getModuleFieldRoofIntersection(
+  moduleField,
+  roofInnerMarginOutline
+) {
+  const roof = moduleField.roof
+  let intersection = intersectOutlines(
+    roofInnerMarginOutline,
+    moduleField.outline
+  )[0]
+
+  intersection = intersection?.map((v) => {
+    return {
+      ...v,
+      z: verticalProjectionOnPlane(v, roof.normalVector, roof.flatOutline[0]).z,
+    }
+  })
+  return intersection
+}
+
+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,3 +1,5 @@
+import * as THREE from 'three'
+
 export default {
   methods: {
     clearThreeObjects(obj) {
@@ -31,18 +33,7 @@ export default {
         return
       }
       scene.remove(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
-      }
+      this.disposeMesh(mesh)
       if (
         mesh.userData.meshId &&
         this.meshes[mesh.userData.type][mesh.userData.meshId]
@@ -68,19 +59,24 @@ export default {
       })
     },
     clearByType(type) {
-      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)
+      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)
       })
       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,10 +88,9 @@ export default {
           cylinder.userData.type = 'edgeMeshes'
           cylinder.userData.layer = edge.layer
           cylinder.frustumCulled = false
-          cylinder.renderOrder = 10
 
           cylinder.frustumCulled = false
-          cylinder.renderOrder = 10
+          cylinder.renderOrder = 15
           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 = 10
+  const moduleHeight = 20
   //get lowest verticalProjection
   const normalVector = roofPolygon.normalVector
 
@@ -747,3 +747,55 @@ 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 vertexList = [outline, ...croppedHolesOutline].flat()
+  vertexList.forEach((point) => {
+    const offset = addVector(point, vectorOffset)
+    Object.assign(point, offset)
+  })
+
+  const geometry = new THREE.BufferGeometry()
+  const triangleVertices = getTriangleVerticesFromOutline(
+    outline,
+    croppedHolesOutline
+  )
+  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,5 +1,9 @@
 import * as THREE from 'three'
-import { getBufferModuleFieldGeometry } from './geometryHandler'
+import {
+  getBufferModuleFieldGeometry,
+  getFittingPanelsBufferGeometry,
+} from './geometryHandler'
+
 export default {
   methods: {
     data() {
@@ -13,27 +17,78 @@ export default {
         ['moduleField', 'tmpModuleField'].includes(p.layer)
       )
       moduleFieldPolygons.forEach((moduleFieldPolygon) => {
-        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 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.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?.outline) return
+      const { outline, holes, visible, color } =
+        moduleFieldPolygon.fittingPanels
+
+      const geometry = getFittingPanelsBufferGeometry(
+        outline,
+        holes,
+        moduleFieldPolygon
+      )
+
+      const isTransparent = color === 'transparent'
+      const material = new THREE.MeshBasicMaterial({
+        color: isTransparent ? '#ffffff' : color,
+        side: THREE.DoubleSide,
+        transparent: true,
+        opacity: isTransparent ? 0.2 : 0.8,
+      })
+
+      if (geometry) {
+        const mesh = new THREE.Mesh(geometry, 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
+      }
+    },
     setModuleFieldsVisibility(isVisible) {
       this.areModuleFieldsVisible = isVisible
       Object.values(this.meshes['moduleFieldsMeshes']).forEach(

package/src/helper/render/overlay.js

@@ -36,6 +36,7 @@ export default {
               const texturedRoof = mesh.getObjectByName('textured_roof')
               if (texturedRoof) {
                 if (
+                  yearlySunShadingOverlay &&
                   yearlySunShadingOverlay.isActive &&
                   yearlySunShadingMaterial
                 ) {

package/src/store/hydrateData.js

@@ -2,13 +2,15 @@
 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 (
@@ -138,7 +140,8 @@ 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 =
@@ -295,4 +298,13 @@ 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,
+        state,
+      })
+    })
 }