@eturnity/eturnity_maths 7.2.3 → 7.4.0

package/package.json

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

package/src/config.js

@@ -5,7 +5,7 @@ export const snapToPointTolerance = 15
 export const snapToIntersectionPointTolerance = 15
 export const snapToLineTolerance = 10
 export const distanceToCloseNode = 70
-export const mmTolerance=50
+export const mmTolerance=1
 export const earthRadius=6371008
 
 export const layerColors = {

package/src/geometry.js

@@ -15,13 +15,22 @@ import {Point} from './objects/Point'
 import {Line} from './objects/Line'
 import concaveman from 'concaveman'
 
-export function getConcaveOutline(selectedPanels,onPanelOutline){
+export function getConcaveOutlines(selectedPanels,onePanelOutline){
+  let buckets=groupAdjacentObjects(selectedPanels)
+  const outlines = []
+  for(let bucketIndex=0;bucketIndex<buckets.length;bucketIndex++){
+    outlines.push(getConcaveOutline(selectedPanels.filter((p,i)=>buckets[bucketIndex].includes(i)),onePanelOutline))
+  }
+  return {outlines,buckets}
+}
+
+export function getConcaveOutline(selectedPanels,onePanelOutline){
   const points = selectedPanels.reduce((acc, cur) => {
     acc.push(...cur.outline.map((p) => [p.x, p.y]))
     return acc
   }, [])
-  let AB = getDistanceBetweenPoints(onPanelOutline[0], onPanelOutline[1])
-  let AD = getDistanceBetweenPoints(onPanelOutline[0], onPanelOutline[3])
+  let AB = getDistanceBetweenPoints(onePanelOutline[0], onePanelOutline[1])
+  let AD = getDistanceBetweenPoints(onePanelOutline[0], onePanelOutline[3])
   let longEdgeLength = Math.max(AB, AD)+100
   var concaveResult = concaveman(points, 1, longEdgeLength)
   concaveResult.pop()
@@ -719,9 +728,54 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
     const det = (B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y)
     return det < 0
   }
-  
+  export function groupAdjacentObjects(objects){
+    if(!objects || objects.length==0) return []
+    // objects with 2D indexes
+    // Check if the objects form an adjacent group
+    let numberOfObjects=objects.length
+    let indexList=Array.from({length: numberOfObjects}, (e, i)=> i)
+    let buckets = []
+    let inBucket=0
+    while (inBucket<objects.length)
+    {
+      let detatchedIndex=indexList.find(i=>!buckets.flat().includes(i))
+      if(detatchedIndex==null) break
+      let queue = [detatchedIndex]
+      let visited = []
+      while (queue.length > 0) {
+        const currentObjectIndex = queue.pop()
+        if (visited.indexOf(currentObjectIndex) == -1) {
+          //if next queued index hasn't been visited, we mark it as visited and we collect all neighbourg to queue
+          visited.push(currentObjectIndex)
+          let x = objects[currentObjectIndex].index[0]
+          let y = objects[currentObjectIndex].index[1]
+          const left = objects.findIndex(
+            (o) => o.index[0] == x - 1 && o.index[1] == y
+          )
+          const right = objects.findIndex(
+            (o) => o.index[0] == x + 1 && o.index[1] == y
+          )
+          const top = objects.findIndex(
+            (o) => o.index[0] == x && o.index[1] == y - 1
+          )
+          const bottom = objects.findIndex(
+            (o) => o.index[0] == x && o.index[1] == y + 1
+          )
+          if (left != -1 && visited.indexOf(left) == -1) queue.push(left)
+          if (right != -1 && visited.indexOf(right) == -1) queue.push(right)
+          if (top != -1 && visited.indexOf(top) == -1) queue.push(top)
+          if (bottom != -1 && visited.indexOf(bottom) == -1) queue.push(bottom)
+        }
+      }
+      inBucket+=visited.length
+      buckets.push(visited)
+    }
+
+    return buckets
+  }
   // Function to check if two indexes are adjacent
   export function areAdjacent(objects) {
+    if(!objects || objects.length==0) return false
     // objects with 2D indexes
     // Check if the objects form an adjacent group
     let visited = []

package/src/intersectionPolygon.js

@@ -73,6 +73,7 @@ export function logicOperationOnPolygons(outline1,outline2,mode='intersect')
     return {outline:[p,fig2[(index+1)%fig2.length]]}
   })
   let intersections = getIntersections({outline:fig1}, edges)
+
   //2. gather all nodes+intersection in a list[[x,y],[x,y]]
   const nodeList = getNodeList(intersections, edges, {outline:fig1})
   //3. generate all edges not cut, those cut and those from construction polyline
@@ -86,9 +87,13 @@ export function logicOperationOnPolygons(outline1,outline2,mode='intersect')
     1
   )
   //4. run planar-face-discovery to get all cycles and rebuild our polygons
-  const  outlineList = getOutlineList(nodeList, edgeList)
-
-  return filterPolygons(outlineList, fig1, fig2, mode)
+  try{
+    const  outlineList = getOutlineList(nodeList, edgeList)
+    return filterPolygons(outlineList, fig1, fig2, mode)
+  }catch(err){
+    console.error("error with getOutlineList",nodeList, edgeList,err)
+    return []
+  }
 }
 
 function filterPolygons(polygons, fig1, fig2, mode) {

package/src/objects/Polygon.js

@@ -166,6 +166,7 @@ export class Polygon {
       extraSerialization.mountingData = this.mountingData?{...this.mountingData}:null
       extraSerialization.modules = modules
       extraSerialization.needsOptimisation = this.needsOptimisation
+      extraSerialization.priority = this.priority
 
     } else if (this.layer == 'panel') {
       extraSerialization.index = this.index
@@ -210,27 +211,7 @@ export class Polygon {
       if (!this.userDeactivatedPanels) {
         this.userDeactivatedPanels = []
       }
-      const modules = this.panels.map((p) => {
-        return {
-          index: p.index,
-          outline: p.outline.map((v) => [v.x, v.y, v.z]),
-          status: p.status || "active",
-          clipped: p.clipped === undefined ? false : p.clipped
-        }
-      })
-      const user_deactivated_modules = this.userDeactivatedPanels.map((p) => {
-        return {
-          index: p.index,
-          outline: p.outline.map((v) => [v.x, v.y, v.z]),
-        }
-      })
-      user_deactivated_modules.forEach(p=>{
-        modules.push({
-          ...p,
-          status: p.status || "user_deactivated",
-          clipped: p.clipped === undefined ? false : p.clipped
-        })
-      })
+      const modules = this.data.modules
       return {
         module_field_uuid: this.id,
         roof_uuid: this.roof.id,

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -16,9 +16,10 @@ import {
   isAlmostSamePoint2D,
   getDistanceBetweenPoints
 } from '../../geometry'
-import { maximumGapLimit } from '../../config'
+import { maximumGapLimit, mmTolerance } from '../../config'
 import { SVD } from 'svd-js'
 import {updateMarginOutlinePolygon} from './AddMargin'
+import { isSelfIntersecting } from '../../intersectionPolygon'
 
 //This function calculate derived field from polygon outline and margin outline
 export function updateComputedGeometryState(state) {
@@ -100,28 +101,41 @@ export function updateComputedGeometryPolygon(polygon) {
 export function calculateValidOutlineFromPolygon(outline){
 //check if two nodes are same
   const nodeIndexToSplit=[]
+  const nodesToRemove=[]
   for(let k=0;k<outline.length-1;k++){
     for(let i=k+1;i<outline.length;i++){
-      if(isAlmostSamePoint2D(outline[k],outline[i],100)){
-        nodeIndexToSplit.push([k,i])
+      if(isAlmostSamePoint2D(outline[k],outline[i],2*mmTolerance)){
+        if(i==k+1){
+          nodesToRemove.push(i)
+        }else{
+          nodeIndexToSplit.push([k,i])
+        }
       }
     }
   }
+  
   for(let coupleToSplit of nodeIndexToSplit){
   const A = outline[(coupleToSplit[0]-1+outline.length)%outline.length]
   const B = outline[coupleToSplit[0]]
   const C = outline[(coupleToSplit[0]+1)%outline.length]
-  let v = normalizedVectorTowardInsideAngle(A,B,C)
-  // let v0=normalizeVector(substractVector())
+  const D = outline[(coupleToSplit[1]-1+outline.length)%outline.length]
+  const E = outline[coupleToSplit[1]]
+  const F = outline[(coupleToSplit[1]+1)%outline.length]
+  let u = normalizedVectorTowardInsideAngle(A,B,C)
+  let v = normalizedVectorTowardInsideAngle(D,E,F)
+  
   outline[coupleToSplit[0]] = {
-      ...addVector(multiplyVector(-50,v),B),
+      ...addVector(multiplyVector(-mmTolerance,u),B),
       z:outline[coupleToSplit[0]].z
     }
   outline[coupleToSplit[1]] = {
-      ...addVector(multiplyVector(50,v),B),
+      ...addVector(multiplyVector(mmTolerance,v),E),
       z:outline[coupleToSplit[1]].z
     }
   }
+  for(let index=nodesToRemove.length-1;index>=0;index--){
+    outline.splice(nodesToRemove[index],1)
+  }
   return outline
 }