@eturnity/eturnity_maths 1.0.2

package/src/objects/derivedState/UpdateRoofObstacleRelations.js

@@ -0,0 +1,86 @@
+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
+}

package/src/objects/derivedState/index.js

@@ -0,0 +1,2 @@
+export * from './AddMargin'
+export * from './updateComputedGeometryPolygon'

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -0,0 +1,168 @@
+import {
+  meanVector,
+  substractVector,
+  multiplyVector
+} from '../../vector'
+import {
+  verticalProjectionOnPlane,
+  inclineWithNormalVector,
+  directionWithNormalVector,
+  isClockWise,
+  calculateArea
+} from '../../geometry'
+import { maximumGapLimit } from '../../config'
+import { SVD } from 'svd-js'
+import {updateMarginOutlinePolygon} from './AddMargin'
+
+//This function calculate derived field from polygon outline and margin outline
+export function updateComputedGeometryState(state) {
+  state.polygons.forEach(polygon=>{
+    polygon=updateComputedGeometryPolygon(polygon)
+  })
+  return state
+}
+export function updateOutlineFromInclineDirection(incline, direction, outline,initialAverageHeight) {
+  const newNormalVector = {}
+  newNormalVector.x =
+    Math.sin((incline * Math.PI) / 180) * Math.sin((direction * Math.PI) / 180)
+  newNormalVector.y =
+    Math.sin((incline * Math.PI) / 180) * Math.cos((direction * Math.PI) / 180)
+  newNormalVector.z = Math.cos((incline * Math.PI) / 180)
+  let meanPoint = meanVector(outline)
+  meanPoint.z=initialAverageHeight
+  outline = outline.map((p) => {
+    return verticalProjectionOnPlane(p, newNormalVector, meanPoint)
+  })
+  //if some points are with negative altitude, we offset the whole roof
+  const altitudeOffset = Math.min(...outline.map((p) => p.z))
+  if (altitudeOffset < 0) {
+    outline.forEach((p) => (p.z -= altitudeOffset))
+  }
+  //if some points are with altitude>50000, we limit those points
+  outline.forEach((p) => (p.z = Math.max(0, Math.min(p.z, 50000))))
+
+  return outline
+}
+export function updateComputedGeometryPolygon(polygon) {
+  if(!['roof','obstacle','moduleField'].includes(polygon.layer)){
+    return polygon
+  }
+  const {
+    projectedOutline,
+    maximumGap,
+    normalVector,
+    meanPoint,
+    incline,
+    direction
+  } = calculateBestFittingPlanePolygon(polygon.outline)
+  polygon.flatOutline = projectedOutline
+  polygon.maximumGap = maximumGap
+  polygon.isFlat = maximumGap < maximumGapLimit
+  polygon.normalVector = normalVector
+  polygon.meanPoint = meanPoint
+  polygon.incline = incline
+  polygon.direction = direction
+  polygon.area=calculateArea(polygon.flatOutline)/1000000
+  polygon.isClockwise = isClockWise(polygon.outline)
+  polygon=updateMarginOutlinePolygon(polygon)
+ 
+  return polygon
+}
+
+export function calculateBestFittingPlanePolygon(fullOutline) {
+  if (fullOutline.length < 3) {
+    return null
+  }
+  let isIncludingAllNodes=false
+  let outline=fullOutline.filter(p=>!p.selected)
+  if(outline.length<3){
+    isIncludingAllNodes=true
+    outline=fullOutline
+  }
+  const meanPoint = meanVector(outline)
+
+  const centralizedOutline = outline.map((p) => substractVector(p, meanPoint))
+  const a = centralizedOutline.map((p) => [p.x, p.y, p.z])
+
+  let { v, q } = SVD(a, false)
+  let vt = [[], [], []]
+  for (let i in v) {
+    for (let j in v[i]) {
+      vt[j][i] = v[i][j]
+    }
+  }
+  v = vt
+  let normalVectorIndex=0
+  for(let index in q){
+    if(!isNaN(q[index]) && q[index]<q[normalVectorIndex]){
+      normalVectorIndex=index
+    }
+  }
+  let normalVectorArray = v[normalVectorIndex]
+  let normalVector = {x:0,y:0,z:1}
+  if(!normalVectorArray){
+    console.error("no normalVector found for:q",q,"v",v,"meanPoint",meanPoint,"a",a,'normal index',normalVectorIndex,'v',v,'outline',outline)
+  }else{
+  normalVector.x = normalVectorArray[0]
+  normalVector.y = normalVectorArray[1]
+  normalVector.z = normalVectorArray[2]
+  }
+
+  if (normalVector.z < 0) {
+    normalVector = multiplyVector(-1, normalVector)
+  }
+  //gard to prevent crazy inclinaison roof
+  if(normalVector.z<0.1){
+    normalVector = {x:0,y:0,z:1}
+  }
+  //plane equation is ax+by+cz=d
+  //where normalvector=(a,b,c)
+  //let's calculate d knowing our plane passes by the point with the
+  const projectedOutline = fullOutline.map((p) =>{
+    const proj=verticalProjectionOnPlane(p, normalVector, meanPoint)
+    return {
+      x:proj.x,
+      y:proj.y,
+      z:Math.max(0,Math.min(50000,proj.z))
+    }
+    }
+  )
+  const maximumGap = Math.max(
+    ...fullOutline.map((p, index) => {
+      let gap=Math.abs(p.z - projectedOutline[index].z)
+      return gap
+    })
+  )
+  //let's find the the biggest positive gap to reposition the plan passing by this point in order to have an always visible plane
+  
+  let biggestPositivGap = Math.max(
+    ...fullOutline.map((p, index) => p.selected && !isIncludingAllNodes ? 0:p.z - projectedOutline[index].z)
+  )
+  projectedOutline.forEach((p) => (p.z += biggestPositivGap))
+  
+  //if less than 3 unselected node=>flat roof on top.
+  const biggestAbsoluteGap = Math.max(
+    ...fullOutline.map((p, index) => p.selected ? 0:Math.abs(p.z - projectedOutline[index].z))
+  )
+  for(let index in fullOutline){
+    let p=fullOutline[index]
+    let hasWarning=(Math.abs(p.z-projectedOutline[index].z)==biggestAbsoluteGap && biggestAbsoluteGap>maximumGapLimit)
+    //I add warning if hasWarning and I remove it if shift is smaller then maxGapLimit. Otherwise, I do not change anything
+    p.hasWarning=hasWarning?
+      hasWarning:
+      Math.abs(p.z-projectedOutline[index].z)<maximumGapLimit?
+      false:p.hasWarning
+  }
+
+  //set warning to the furthest
+  const incline = inclineWithNormalVector(normalVector)
+  const direction = directionWithNormalVector(normalVector)
+  return {
+    projectedOutline,
+    maximumGap,
+    normalVector,
+    meanPoint,
+    incline,
+    direction
+  }
+}

package/src/objects/graph/DFS.js

@@ -0,0 +1,80 @@
+
+// Javascript program to print DFS
+// traversal from a given
+// graph
+ 
+// This class represents a
+// directed graph using adjacency
+// list representation
+export class Graph
+{
+     
+    // Constructor
+    //v=number of vertices
+    constructor()
+    {
+        this.visited=[]
+        this.dict= []
+        this.adj = []
+            
+    }
+     
+    // Function to add an edge into the graph
+    addEdge(uuid1, uuid2)
+    {
+        let v=this.dict.indexOf(uuid1)
+        let length
+        if(v==-1){
+          length=this.dict.length
+          this.dict[length]=uuid1
+          this.adj[length]=[]
+          v=length
+        }
+        let w=this.dict.indexOf(uuid2)
+        if(w==-1){
+          length=this.dict.length
+          this.dict[length]=uuid2
+          this.adj[length]=[]
+          w=length
+        }
+        // Add w to v's list.
+       if(!this.adj[v]){this.adj[v]=[]}
+       this.adj[v].push(w);
+       if(!this.adj[w]){this.adj[w]=[]}
+        this.adj[w].push(v);
+    }
+     
+    // A function used by DFS
+    DFSUtil(v, visited)
+    {
+         
+        // Mark the current node as visited and print it
+        visited[v] = true;
+        this.visited.push(v)
+  
+        // Recur for all the vertices adjacent to this
+        // vertex
+        for(let i in this.adj[v])
+        {
+            let n = this.adj[v][i]
+            if (!visited[n])
+                this.DFSUtil(n, visited);
+        }
+    }
+     
+    // The function to do DFS traversal.
+    // It uses recursive
+    // DFSUtil()
+    DFS(uuidStart){
+        let v=this.dict.indexOf(uuidStart)
+        // Mark all the vertices as
+        // not visited(set as
+        // false by default in java)
+        let visited = [];
+        // Call the recursive helper
+        // function to print DFS
+        // traversal
+        this.DFSUtil(v, visited);
+        return [...new Set(this.visited.map((i)=>{return this.dict[i]}))]
+    }
+}

package/src/objects/graph/graphCreation.js

@@ -0,0 +1,44 @@
+import {Graph} from './DFS'
+import {
+    isSameSegment2D,
+  } from '../../geometry'
+  
+export function generateGraph(polygons){
+    const edges2D=[]
+    const g=new Graph()
+    polygons
+      .filter((poly) => poly.layer=='roof')
+      .forEach((polygon,index) => {
+        g.dict.push(polygon.id)
+        const outline = polygon.outline
+        outline.forEach((point, i) => {
+          //check if edge2D already exist
+          const nextPoint = outline[(i + 1) % outline.length]
+          let edge2D = edges2D.find((edge) => {
+            return (
+              isSameSegment2D([point, nextPoint], edge.outline)
+            )
+          })
+          if (!edge2D) {
+            //create an edge at this position
+            edge2D = {}
+            edge2D.outline=[point, nextPoint]
+            edge2D.belongsTo = []
+            edges2D.push(edge2D)
+          }
+          //add BelongToPolygon
+          edge2D.belongsTo.push({
+            polygonId: polygon.id,
+            index: i,
+            polygon
+          })
+        })
+      })
+    for(let k in edges2D){
+        let edge=edges2D[k]
+        if(edge.belongsTo.length==2){
+            g.addEdge(edge.belongsTo[0].polygonId,edge.belongsTo[1].polygonId)
+        }
+    }  
+    return g
+}

package/src/objects/hydrate.js

@@ -0,0 +1,24 @@
+export function hydratePolygon(serializedPolygon){
+    const layer=serializedPolygon.layer
+    let polygon=new Polygon(serializedPolygon.outline,layer)
+    polygon.id=serializedPolygon.id
+    polygon.name=serializedPolygon.name
+    polygon.margins=serializedPolygon.margins
+    if(layer=="obstacle"){
+      polygon.isParallel=serializedPolygon.isParallel
+      polygon.height=serializedPolygon.height
+    }else if(layer=="moduleField"){
+      polygon.data=serializedPolygon.data
+      polygon.pvData=serializedPolygon.pvData
+      polygon.mountingData=serializedPolygon.mountingData
+      polygon.panels=[]
+      polygon.userDeactivatedPanels=[]
+    }else if(layer=="panel"){
+      polygon.index=serializedPolygon.index
+      polygon.moduleField=serializedPolygon.moduleField
+    }else if(layer=="user_deactivated_panel"){
+      polygon.index=serializedPolygon.index
+      polygon.moduleField=serializedPolygon.moduleField
+    }
+    return polygon
+  }

package/src/objects/index.js

@@ -0,0 +1,8 @@
+export * from './Point'
+export * from './Line'
+export * from './Polygon'
+export * from './Circle'
+export * from './hydrate'
+
+export * from './derivedState'
+export * from './graph/graphCreation'