@eturnity/eturnity_maths 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,

package/src/objects/Polygon.js

@@ -226,7 +226,7 @@ export class Polygon {
         base_line_index: this.data.base_line_index,
         justify_percent: this.data.justify_percent,
 
-        number_of_panels_overrid:this.data.number_of_panels_override,
+        number_of_panels_override:this.data.number_of_panels_override,
         number_of_panel:this.data.number_of_panels,
         yearly_yield_manual_entr:this.data.yearly_yield_manual_entry,
         yearly_yield_kwh_kw:this.data.yearly_yield_kwh_kwp,

package/src/objects/derivedState/UpdateRoofModuleFieldRelations.js

@@ -1,119 +0,0 @@
-import {
-  isInsidePolygon,
-  verticalProjectionOnPlane,
-} from '../../geometry'
-//this function just update the "roof" and "moduleField(s)" properties of panels,moduleFields and roofs
-export function UpdateRoofModuleFieldRelations(state) {
-  const roofPolygons = state.polygons.filter((poly) => poly.layer == 'roof')
-  const moduleFieldPolygons = state.polygons.filter(
-    (poly) => poly.layer == 'moduleField'
-    )
-  const panelPolygons = state.polygons.filter((poly) =>
-    ['panel', 'user_deactivated_panel'].includes(poly.layer)
-  )
-  //let's remove all moduleFields from roofs
-  roofPolygons.forEach((roofPolygon) => {
-    //breaking circular reference for memory management
-    for (let k in roofPolygon.moduleFields) {
-      roofPolygon.moduleFields[k] = null
-    }
-    roofPolygon.moduleFields = []
-  })
-  moduleFieldPolygons.forEach((moduleFieldPolygon) => {
-    moduleFieldPolygon.roof = null
-  })
-  panelPolygons.forEach((panelPolygon) => {
-    panelPolygon.roof = null
-  })
-
-  for (let k in moduleFieldPolygons) {
-    const moduleField = moduleFieldPolygons[k]
-    //check if everypoint is in the same roof and if they are not too far from the flat surface.(at least above)
-    const roofPolygonCandidates = roofPolygons.filter((roof) =>
-      {
-        return moduleField.outline.every(p=>isInsidePolygon(p, roof.margins.innerOutline))
-      }
-    )
-    //roofs on roof can lead to multiple roof under a point. moduleField is in the smallest
-    let smallestRoof = null
-    for (let roof of roofPolygonCandidates) {
-      if (!smallestRoof || smallestRoof.area > roof.area) {
-        smallestRoof = roof
-      }
-    }
-    let roofPolygon = smallestRoof
-
-    if (!roofPolygon) {
-      //no roof found under first node of moduleField => moduleField will be deleted
-      continue
-    }
-    let moduleFieldBelongsToRoof = true
-    moduleField.outline.forEach((p) => {
-      const distanceToFlatRoof =
-        p.z -
-        verticalProjectionOnPlane(
-          p,
-          roofPolygon.normalVector,
-          roofPolygon.flatOutline[0]
-        ).z
-      if (
-        !isInsidePolygon(p, roofPolygon.margins.innerOutline) ||
-        distanceToFlatRoof < -1 ||
-        distanceToFlatRoof > 50
-      ) {
-        // one point from moduleField is not inside the roof or too far from it's flat surface => moduleField will be deleted
-        moduleFieldBelongsToRoof = false
-      }
-    })
-    if (moduleFieldBelongsToRoof) {
-      roofPolygon.moduleFields.push(moduleField)
-      moduleField.roof = roofPolygon
-      moduleField.panels.forEach((panel) => (panel.roof = roofPolygon))
-      panelPolygons.forEach((p) => {
-        if (p.moduleField.id == moduleField.id) {
-          p.roof = roofPolygon
-        }
-      })
-    }
-  }
-
-  let newPolygons = state.polygons.map((p) => {
-    if (
-      !['roof', 'moduleField', 'panel', 'user_deactivated_panel'].includes(
-        p.layer
-      )
-    )
-      return p
-    if (p.layer == 'roof') return roofPolygons.find((r) => r.id == p.id)
-    if (p.layer == 'moduleField')
-      return moduleFieldPolygons.find((mf) => mf.id == p.id)
-    if (['panel', 'user_deactivated_panel'].includes(p.layer))
-      return panelPolygons.find((panel) => panel.id == p.id)
-  })
-  state = { ...state, polygons: newPolygons }
-  state = removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state)
-  return state
-}
-
-export function removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state) {
-  const remainingPolygons = state.polygons.filter((polygon) =>
-    ['roof', 'obstacle'].includes(polygon.layer)
-  )
-  const remainingModuleFields = state.polygons.filter(
-    (polygon) => polygon.layer == 'moduleField' && !!polygon.roof
-  )
-  const remainingPanels = state.polygons.filter(
-    (polygon) => polygon.layer == 'panel' && !!polygon.roof
-  )
-  const remainingUserDeactivatedPanels = state.polygons.filter(
-    (polygon) => polygon.layer == 'user_deactivated_panel' && !!polygon.roof
-  )
-  
-  state.polygons = [
-    ...remainingPolygons,
-    ...remainingModuleFields,
-    ...remainingPanels,
-    ...remainingUserDeactivatedPanels
-  ]
-  return state
-}

package/src/objects/derivedState/UpdateRoofObstacleRelations.js

@@ -1,86 +0,0 @@
-import {
-  verticalProjectionOnPlane,
-  calculateArea
-} from '../../geometry'
-import {
-  intersectOutlines
-} from '../../intersectionPolygon'
-//this function just update the "roof" and "holes" properties of roofs and obstacles
-export function UpdateRoofObstacleRelations(state,updateVersionEnable=true) {
-  //let's remove all holes from roofs which are not obstacle then check for every obstacle and add them to roofs
-  const roofPolygons = state.polygons.filter((poly) => poly.layer == 'roof')
-  const initialRelation={}
-
-  roofPolygons.forEach((roofPolygon) => {
-    initialRelation[roofPolygon.id]=[]
-    //breaking circular reference for memory management
-    for (let k in roofPolygon.holes) {
-      initialRelation[roofPolygon.id].push(roofPolygon.holes.id)
-      roofPolygon.holes[k] = null
-    }
-    roofPolygon.holes = []
-  })
-  const holePolygons = state.polygons.filter((poly) =>
-    ['roof','obstacle'].includes(poly.layer)
-  )
-  
-  holePolygons.forEach((obstacle) => {
-    //breaking circular reference for memory management
-    for (let k in obstacle.roofs) {
-      obstacle.roofs[k] = null
-    }
-    obstacle.roofs = []
-    
-    let roofsWithObstacle=roofPolygons.filter(roof=>{
-      let intersection=intersectOutlines(obstacle.outline,roof.outline)[0]||[]
-      if(intersection.length==0)return false
-      if(obstacle.layer=='obstacle')return true
-
-      let deltaArea=calculateArea(roof.outline)-calculateArea(intersection)
-      if(deltaArea<100)return false
-      return true
-    })
-    
-    let heightReference = 0      
-      for (let roof of roofsWithObstacle) {
-        
-        heightReference = obstacle.outline.reduce((acc,cur)=>{
-          acc=Math.max(
-            acc,
-            verticalProjectionOnPlane(cur, roof.normalVector, roof.flatOutline[0])
-              .z
-          )
-          return acc
-        },0)
-        
-        if (!obstacle.roofs.map((r) => r.id).includes(roof.id) && obstacle.id!=roof.id) {
-          obstacle.roofs.push(roof)
-        }
-        if (!roof.holes.map((h) => h.id).includes(obstacle.id) && obstacle.id!=roof.id) {
-          roof.holes.push(obstacle)
-        }
-      }
-      obstacle.heightReference = heightReference
-    
-    
-  })
-
-  roofPolygons.forEach((roof)=>{
-    if(roof.holes.map(h=>h.id).sort().join()!=initialRelation[roof.id].sort().join()){
-      if(updateVersionEnable){
-        roof.version++
-      }
-    }
-  })
-
-  state = removeStandaloneObstacles(state)
-  
-  return state
-}
-
-export function removeStandaloneObstacles(state) {
-  state.polygons = state.polygons.filter(
-    (polygon) => polygon.layer != 'obstacle' || polygon.roofs.length > 0
-  )
-  return state
-}