@eturnity/eturnity_maths 6.34.3 → 6.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "6.34.3",
+  "version": "6.37.0",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,
@@ -17,7 +17,8 @@
     "lodash": "^4.17.21",
     "planar-face-discovery": "^2.0.7",
     "svd-js": "^1.1.1",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.0",
+    "concaveman": "^1.2.1"
   },
   "devDependencies": {
     "@babel/core": "^7.21.4",
@@ -26,4 +27,4 @@
     "jest": "^29.5.0"
   },
   "description": ""
-}
+}

package/src/geometry.js

@@ -12,7 +12,42 @@ import {addVector,
   normalizeVector} from './vector'
 import {Point} from './objects/Point'
 import {Line} from './objects/Line'
+import concaveman from 'concaveman'
 
+export function getConcaveOutline(selectedPanels,onPanelOutline){
+  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 longEdgeLength = Math.max(AB, AD) + 100
+  var concaveResult = concaveman(points, 1, longEdgeLength)
+  concaveResult.pop()
+  let moduleFieldOutline = concaveResult.map((p) => {
+    return {
+      x: p[0],
+      y: p[1],
+      z: 0
+    }
+  })
+  //remove aligned nodes
+  moduleFieldOutline=simplifyOutline(moduleFieldOutline)
+  return moduleFieldOutline
+}
+export function simplifyOutline(initialOutline){
+  const simplifiedOutline=[]
+  initialOutline.forEach((p, k, outline) => {
+    let len = outline.length
+    let A = outline[(k - 1 + len) % len]
+    let B = outline[(k + 1) % len]
+    let M = outline[k % len]
+    if (!isInsideEdge2D(M, A, B)) {
+      simplifiedOutline.push(M)
+    }
+  })
+  return simplifiedOutline
+}
 export function getSnapedValue(value, snaps, tolerance) {
   let closeSnapsItem = snaps.reduce(
     (acc, cur) => {

package/src/objects/derivedState/AddMargin.js

@@ -1,7 +1,8 @@
 import {
     multiplyVector
   } from '../../vector'
-import {getMarginPoint} from '../../geometry'
+import {getMarginPoint,isClockWise} from '../../geometry'
+import {calculateBestFittingPlanePolygon} from './updateComputedGeometryPolygon'
   //update and calculate margins for all polygon
   export function updateMarginsOutline(state){
     state.polygons.forEach(polygon=>{
@@ -107,3 +108,35 @@ export function getObstacleMarginOutline(polygon){
   }
   return polygon
   }
+
+  export function getOutterOutlineWithConstantMargin(outline,margin){
+    const isClockwise = isClockWise(outline)
+    const {
+      projectedOutline,
+      maximumGap,
+      normalVector,
+      meanPoint,
+      incline,
+      direction
+    } = calculateBestFittingPlanePolygon(outline)
+    let clockwiseNormalVector=normalVector
+    if(isClockwise){
+      clockwiseNormalVector=multiplyVector(-1,clockwiseNormalVector)
+    }
+    //outterOutline is the outline close to the wall
+  const outterOutline=[]
+  const length=outline.length
+  for(let index=0;index<length;index++){
+    const B=projectedOutline[index]
+    //A,B,C three consecutive points on the polygon.
+    //n is a vector in the plan normal to AB of length margin[A] directed towards the inside
+    //m is a vector in the plan normal to BC of length margin[B] directed towards the inside
+    //K is the margin outline linked with B
+    const A=projectedOutline[(index-1+length)%length]
+    const C=projectedOutline[(index+1)%length]
+    //filling the margins values if not initiated.
+    let K=getMarginPoint(A,B,C,margin,margin,clockwiseNormalVector)
+    outterOutline.push(K)
+  }
+  return outterOutline
+}

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -8,7 +8,8 @@ import {
   inclineWithNormalVector,
   directionWithNormalVector,
   isClockWise,
-  calculateArea
+  calculateArea,
+  getConcaveOutline
 } from '../../geometry'
 import { maximumGapLimit } from '../../config'
 import { SVD } from 'svd-js'
@@ -73,7 +74,18 @@ export function updateComputedGeometryPolygon(polygon) {
   polygon.area=calculateArea(polygon.flatOutline)/1000000
   polygon.isClockwise = isClockWise(polygon.outline)
   polygon=updateMarginOutlinePolygon(polygon)
- 
+  if(polygon.layer=="moduleField"){
+    let trimedOutline=[]
+    if(polygon.panels.length>0){
+      trimedOutline = getConcaveOutline(polygon.panels,polygon.panels[0].outline)
+      trimedOutline = trimedOutline.map(p=>{return{
+        x:p.x,
+        y:p.y,
+        z:verticalProjectionOnPlane(p,polygon.roof.normalVector,polygon.roof.flatOutline[0]).z
+      }})
+    }
+    polygon.trimedOutline = trimedOutline
+  }
   return polygon
 }