@eturnity/eturnity_3d 8.19.3 → 8.22.0-EPDM-13091.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "8.19.3",
+  "version": "8.22.0-EPDM-13091.0",
   "files": [
     "dist",
     "src"
@@ -16,7 +16,7 @@
     "merge-remote-master": "node scripts/merge-remote-master.js"
   },
   "dependencies": {
-    "@eturnity/eturnity_maths": "8.19.0",
+    "@eturnity/eturnity_maths": "8.19.0-EPDM-13091.1",
     "@originjs/vite-plugin-commonjs": "1.0.3",
     "core-js": "3.30.2",
     "cors": "2.8.5",

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: '#2B3A67',
+  brown: '#623A36',
+  'rustic red': '#713229',
+  terracotta: '#A76448',
+  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,170 @@ 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,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 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,5 +1,9 @@
 import * as THREE from 'three'
-import { getBufferModuleFieldGeometry } from './geometryHandler'
+import {
+  getBufferModuleFieldGeometry,
+  getFittingPanelsBufferGeometry,
+} from './geometryHandler'
+
 export default {
   data() {
     return {
@@ -13,31 +17,89 @@ 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.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,
+      })
+
+      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) {
       this.areModuleFieldsVisible = isVisible
       Object.values(this.meshes['moduleFieldsMeshes']).forEach(
-        (mesh) => (mesh.visible = isVisible)
+        (mesh) =>
+          (mesh.visible =
+            this.areModuleFieldsVisible && this.panelOpacity === 1)
       )
     },
   },

package/src/helper/renderMixin.js

@@ -302,6 +302,11 @@ 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
@@ -420,13 +425,6 @@ export default {
             arg: [],
           })
           break
-        case 'updateIsYearlyShadingHeatmapActive':
-          methodList.push({
-            name: 'updateModuleFieldsVisibility',
-            method: this.updateModuleFieldsVisibility,
-            arg: [!params.value],
-          })
-          break
         case 'updateModuleFieldsVisibility':
           methodList.push({
             name: 'updateModuleFieldsVisibility',

package/src/store/hydrateData.js

@@ -2,13 +2,18 @@
 import {
   Polygon,
   updateComputedGeometryPolygon,
-  getRoofMarginOutline,
   getObstacleMarginOutline,
-  midPoint,
+  multiplyVector,
+  addVector,
+  Vector,
 } 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 (
@@ -24,6 +29,33 @@ function sanitizedOutline(outline) {
     return accumulator
   }, [])
 }
+export function getModuleOutline({ module, grid, offset }) {
+  // const convertedOffset =
+  //   offset == 33 ? 100 / 3 : offset == 66 ? 200 / 3 : offset
+
+  const rowIndex = module.row_index
+  const colIndex = module.col_index
+  const gridRowVector = new Vector(grid.grid_row_vector)
+  const gridColVector = new Vector(grid.grid_column_vector)
+  // const rowOffsetVector = multiplyVector(
+  //   (convertedOffset * rowIndex) / 100,
+  //   gridColVector
+  // )
+  const panelHeightVector = new Vector(grid.panel_height_vector)
+  const panelWidthVector = new Vector(grid.panel_width_vector)
+  const gridOrigin = new Vector(grid.grid_origin)
+  //const offsetOrigin = addVector(gridOrigin, rowOffsetVector)
+  const localA = addVector(
+    multiplyVector(rowIndex, gridRowVector),
+    multiplyVector(colIndex, gridColVector)
+  )
+  const A = addVector(gridOrigin, localA)
+  const B = addVector(A, panelHeightVector)
+  const C = addVector(A, addVector(panelHeightVector, panelWidthVector))
+  const D = addVector(A, panelWidthVector)
+  return [A, B, C, D]
+}
+
 export async function hydratePolygons({
   roofsResponse = [],
   obstaclesResponse = [],
@@ -128,6 +160,7 @@ 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
@@ -138,7 +171,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 =
@@ -166,56 +200,45 @@ export async function hydratePolygons({
     moduleField.pvModuleId = moduleFieldResp.pv_module_id
     moduleField.mountingSystemId = moduleFieldResp.mounting_system_id
 
+    moduleField.data.moduleGrids = moduleFieldResp.module_grids
+
     const modules = []
-    moduleFieldResp.modules.forEach((module) => {
-      modules.push({
-        ...module,
-        status: module.status || 'active',
-        clipped: module.clipped === undefined ? false : module.clipped,
-      })
-    })
-    if (moduleFieldResp.user_deactivated_modules) {
-      moduleFieldResp.user_deactivated_modules.forEach((module) => {
+    moduleFieldResp.module_grids.forEach((grid, gridIndex) => {
+      grid.modules.forEach((module) => {
         modules.push({
           ...module,
-          status: 'user_deactivated',
-          clipped: module.clipped === undefined ? false : module.clipped,
-        })
-      })
-    }
-    moduleField.data.modules = modules
-    modules
-      .filter((m) => !m.clipped)
-      .forEach((module) => {
-        const outline = module.outline.map((p) => {
-          return { x: p[0], y: p[1], z: p[2] }
+          outline: getModuleOutline({
+            module,
+            grid,
+            offset: moduleFieldResp.offset_percent,
+          }),
+          gridIndex: gridIndex,
         })
-        let panel = new Polygon(outline, '')
-        panel.id = module.module_uuid
-        panel.row_index = module.row_index
-        panel.col_index = module.col_index
-        panel.status = module.status
-        panel.clipped = module.clipped
-        panel.moduleField = moduleField
-        panel.poolGroupUuid = module.project_variant_pool_group_uuid
-        if (panel.poolGroupUuid) {
-          panel.poolGroupUuidColor = `#${panel.poolGroupUuid.slice(0, 6)}`
-        }
-        panel.available = true
-        switch (module.status) {
-          case 'active':
-            panel.layer = 'panel'
-            MFpanels.push(panel)
-            panels.push(panel)
-            break
-          case 'user_deactivated':
-            panel.layer = 'user_deactivated_panel'
-            MFuserDeactivatedPanels.push(panel)
-            userDeactivatedPanels.push(panel)
-            break
-        }
-        panel = updateComputedGeometryPolygon(panel)
       })
+    })
+
+    modules.forEach((module) => {
+      const panel = new Polygon(module.outline, '')
+      panel.id = module.module_uuid
+      panel.row_index = module.row_index
+      panel.col_index = module.col_index
+      panel.is_active = module.is_active
+      panel.moduleField = moduleField
+      panel.poolGroupUuid = module.project_variant_pool_group_uuid
+      if (panel.poolGroupUuid) {
+        panel.poolGroupUuidColor = `#${panel.poolGroupUuid.slice(0, 6)}`
+      }
+      panel.available = true
+      if (module.is_active) {
+        panel.layer = 'panel'
+        MFpanels.push(panel)
+        panels.push(panel)
+      } else {
+        panel.layer = 'user_deactivated_panel'
+        MFuserDeactivatedPanels.push(panel)
+        userDeactivatedPanels.push(panel)
+      }
+    })
 
     const roof = roofs.find((r) => r.id == moduleFieldResp.roof_uuid)
     if (roof) {
@@ -295,4 +318,10 @@ 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)
+    })
 }