@eturnity/eturnity_maths 7.2.3 → 7.4.0-EPDM-7379.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "7.2.3",
+  "version": "7.4.0-EPDM-7379.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()
@@ -89,7 +98,7 @@ export function getParallelLinePassingByPoint(A, B, C) {
     console.error("A == B Can't make a parallel line")
     return null
   }
-  const D = new Point(C.x + B.x - A.x, C.y + B.y - A.y)
+  const D = new Point(C.x + B.x - A.x, C.y + B.y - A.y, C.z + B.z - A.z)
   return new Line(C, D, '')
 }
 
@@ -101,10 +110,15 @@ export function getDataAboutTwo3DLines(A,u,B,v){
     [u.z,v.z,w.z]
   ]
   let mInv=inverse3x3matrix(m)
+  if(!mInv){
+    return null
+  }
   let AB=substractVector(B,A)
   let [t1,t2,t3] = multiplyMatrices(mInv,[[AB.x],[AB.y],[AB.z]])
+  //M point on Au
   let M=addVector(A,multiplyVector(t1,u))
-  let N=addVector(B,multiplyVector(t2,v))
+  //N point on Bv
+  let N=addVector(B,multiplyVector(-t2,v))
   let distance=get3DDistanceBetweenPoints(M,N)
   return {m,mInv,M,N,A,B,u,v,w,distance,t1,t2,t3}
 
@@ -131,11 +145,15 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
     )
     return distance
   }
-  
+
+  export function getDegreeVectors(u,v){
+    return getDegree(u,{x:0,y:0,z:0},v)
+  }
+
   export function getDegree(H, I, J) {
-    const a = getDistanceBetweenPoints(H, I)
-    const b = getDistanceBetweenPoints(I, J)
-    const c = getDistanceBetweenPoints(H, J)
+    const a = get3DDistanceBetweenPoints(H, I)
+    const b = get3DDistanceBetweenPoints(I, J)
+    const c = get3DDistanceBetweenPoints(H, J)
   
     let angle = (Math.acos((a * a + b * b - c * c) / (2 * a * b)) * 180) / Math.PI
     
@@ -539,27 +557,56 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
       return null
     }
     let P = {}
-    const AM = {
-      x: M.x - A.x,
-      y: M.y - A.y
-    }
-    const AB = {
-      x: B.x - A.x,
-      y: B.y - A.y
-    }
-  
-    const dot = AM.x * AB.x + AM.y * AB.y
-    const distanceAB = getDistanceBetweenPoints(A, B)
-    let param = -1
-    if (distanceAB == 0) {
-      //A et B sont confondu
-      console.error("A and B don't make a line : A==B")
-      P = M
-    } else {
-      // in case of 0 length line
-      const distanceAP = dot / distanceAB
-      P.x = A.x + (distanceAP * AB.x) / distanceAB
-      P.y = A.y + (distanceAP * AB.y) / distanceAB
+    if(M.z == undefined || A.z== undefined || B.z== undefined){
+      const AM = {
+        x: M.x - A.x,
+        y: M.y - A.y
+      }
+      const AB = {
+        x: B.x - A.x,
+        y: B.y - A.y
+      }
+    
+      const dot = AM.x * AB.x + AM.y * AB.y
+      const distanceAB = getDistanceBetweenPoints(A, B)
+      let param = -1
+      if (distanceAB == 0) {
+        //A et B sont confondu
+        console.error("A and B don't make a line : A==B")
+        P = M
+      } else {
+        // in case of 0 length line
+        const distanceAP = dot / distanceAB
+        P.x = A.x + (distanceAP * AB.x) / distanceAB
+        P.y = A.y + (distanceAP * AB.y) / distanceAB
+      }
+    }else{
+      //make 3D projection on line
+      const AM = {
+        x: M.x - A.x,
+        y: M.y - A.y,
+        z: M.z - A.z,
+      }
+      const AB = {
+        x: B.x - A.x,
+        y: B.y - A.y,
+        z: B.z - A.z
+      }
+    
+      const dot = AM.x * AB.x + AM.y * AB.y + AM.z * AB.z
+      const distanceAB = get3DDistanceBetweenPoints(A, B)
+      let param = -1
+      if (distanceAB == 0) {
+        //A et B sont confondu
+        console.error("A and B don't make a line : A==B")
+        P = M
+      } else {
+        // in case of 0 length line
+        const distanceAP = dot / distanceAB
+        P.x = A.x + (distanceAP * AB.x) / distanceAB
+        P.y = A.y + (distanceAP * AB.y) / distanceAB
+        P.z = A.z + (distanceAP * AB.z) / distanceAB
+      }
     }
     //projection of the point to the line
     return P
@@ -719,9 +766,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/Circle.js

@@ -1,12 +1,13 @@
 
 import {
-  getDistanceBetweenPoints,
   translate2D,
   verticalProjectionOnPlane,
-  get3DDistanceBetweenPoints
+  get3DDistanceBetweenPoints,
+  getDistanceBetweenPoints,
 } from '../geometry'
 import { v4 as uuidv4 } from 'uuid'
 import {Point} from './Point'
+import { addVector, multiplyVector, substractVector,vectorLength,crossProduct,dotProduct,normalizeVector } from '../vector'
 
 
 
@@ -30,6 +31,25 @@ export class Circle {
     circle.id = uuidv4()
     return circle
   }
+  getIntersections(object){
+    const intersections=[]
+    if(!object)return
+    if(object.type=="point"){
+      if(get3DDistanceBetweenPoints(object,this.center)==this.radius){
+        intersections.push({...object})
+      }
+    }else if(object.type=="line"){
+      let P=object.getProjectedPoint(this.center)
+      let distance = get3DDistanceBetweenPoints(P,this.center)
+      if(distance<=this.radius){
+        let A=addVector(P,multiplyVector(Math.sqrt(Math.pow(this.radius,2)-Math.pow(distance,2)),object.getDirectionVector()))
+        let B=addVector(P,multiplyVector(-Math.sqrt(Math.pow(this.radius,2)-Math.pow(distance,2)),object.getDirectionVector()))
+        intersections.push({...A})
+        intersections.push({...B})
+      }
+    }
+    return intersections
+  }
   getPxDistanceTo(point, canvasContext) {
     const toCanvasRef = canvasContext.toCanvasRef
     let pxCenter = toCanvasRef(this.center)
@@ -41,6 +61,20 @@ export class Circle {
     }
     return Math.abs(get3DDistanceBetweenPoints(point, pxCenter) - pxRadius)
   }
+  getDistanceToPoint(point) {
+    return get3DDistanceBetweenPoints(point, this.getProjectedPoint(point))
+   }
+   getHorizontalDistanceToPoint(point) {
+   return getDistanceBetweenPoints(point, this.getVerticalProjectedPoint(point))
+  }
+  isInPlane(plane){
+    if(!plane) return false
+    const {point,normalVector}=plane
+    const circleNormalVector=this.normalVector || {x:0,y:0,z:1}
+    if(vectorLength(crossProduct(circleNormalVector,normalVector))>0.1) return false
+    if(dotProduct(normalizeVector(substractVector(point,this.center)),normalVector)>0.1) return false
+    return true
+   }
   getProjectedPoint(point) {
     if(this.normalVector){
       point.z=verticalProjectionOnPlane(point,this.normalVector,this.center).z
@@ -54,9 +88,13 @@ export class Circle {
     }
     let x = this.center.x + (point.x - this.center.x) * (this.radius / distance)
     let y = this.center.y + (point.y - this.center.y) * (this.radius / distance)
-    let P = new Point(x, y, 0, this.layer)
+    let z = this.center.z + (point.z - this.center.z) * (this.radius / distance)
+    let P = new Point(x, y, z, this.layer)
     return P
   }
+  getVerticalProjectedPoint(point) {
+   return this.getProjectedPoint(point)
+  }
   translate(vectorInMm) {
     this.center = translate2D(this.center, vectorInMm)
   }

package/src/objects/Line.js

@@ -6,9 +6,12 @@ import {
   isSamePoint3D,
   translate2D,
   midPoint,
+  getDataAboutTwo3DLines,
+  isPointBetweenSegment,
 } from '../geometry'
 import { v4 as uuidv4 } from 'uuid'
 import {Point} from './Point'
+import { substractVector,normalizeVector, addVector, multiplyVector,dotProduct } from '../vector'
 
 
 export class Line {
@@ -35,6 +38,35 @@ export class Line {
     line.infiniteLine = this.infiniteLine
     return line
   }
+  getDirectionVector(){
+    return normalizeVector(substractVector(this.outline[1],this.outline[0]))
+  }
+  getIntersections(object){
+    const intersections=[]
+    if(!object)return
+    if(object.type=="point"){
+      if(isSamePoint3D(this.getProjectedPoint(object),object)){
+        intersections.push({...object})
+      }
+    }else if(object.type=="line"){
+      const data = getDataAboutTwo3DLines(this.outline[0],this.getDirectionVector(),object.outline[0],object.getDirectionVector())
+      if(!data){return []}
+      let {distance,N} = data
+      if(distance<0.1 && !!N){
+        intersections.push({...N})
+      }
+    }else if(object.type=="circle"){
+      let P=this.getProjectedPoint(object.center)
+      let distance = get3DDistanceBetweenPoints(P,object.center)
+      if(distance<=object.radius){
+        let A=addVector(P,multiplyVector(Math.sqrt(Math.pow(object.radius,2)-Math.pow(distance,2)),this.getDirectionVector()))
+        let B=addVector(P,multiplyVector(-Math.sqrt(Math.pow(object.radius,2)-Math.pow(distance,2)),this.getDirectionVector()))
+        intersections.push({...A})
+        intersections.push({...B})
+      }
+    }
+    return intersections
+  }
   pxLength(canvasContext) {
     return (
       getDistanceBetweenPoints(this.outline[0], this.outline[1]) /
@@ -69,8 +101,47 @@ export class Line {
     }
 
     let realityRefPoint = toRealityRef(point)
-    let P = getPointOnLine(realityRefPoint, this.outline[0], this.outline[1])
-    return getDistanceBetweenPoints(realityRefPoint, P) / canvasContext.mmPerPx
+    let A={x:this.outline[0].x,y:this.outline[0].y,z:0}
+    let B={x:this.outline[1].x,y:this.outline[1].y,z:0}
+    let M={x:realityRefPoint.x,y:realityRefPoint.y,z:0}
+    let P = getPointOnLine(realityRefPoint, A, B)
+    P.z = 0
+    return getDistanceBetweenPoints(M, P) / canvasContext.mmPerPx
+  }
+   isInPlane(plane){
+    if(!plane) return false
+    const {point,normalVector}=plane
+    if(dotProduct(this.getDirectionVector(),normalVector)>0.1) return false
+    if(dotProduct(normalizeVector(substractVector(point,this.outline[0])),normalVector)>0.1) return false
+    return true
+   }
+  includesPoint2D(point,tolerance){
+    const projection=this.getVerticalProjectedPoint(point)
+    return this.getHorizontalDistanceToPoint(point) < tolerance && isPointBetweenSegment( projection, this.outline[0], this.outline[1])
+  }
+  getDistanceToPoint(point) {
+   return get3DDistanceBetweenPoints(point, this.getProjectedPoint(point))
+  }
+  getHorizontalDistanceToPoint(point) {
+   return getDistanceBetweenPoints(point, this.getVerticalProjectedPoint(point))
+  }
+  getVerticalProjectedPoint(point){
+    if (this.outline.length == 0) {
+      return null
+    }
+    if (isSamePoint3D(this.outline[0], this.outline[1])) {
+      console.error("A == B Can't project point on Line")
+      return null
+    }
+    let A= {...this.outline[0],z:0}
+    let B= {...this.outline[1],z:0}
+    let P = getPointOnLine({...point,z:0}, A,B)
+    let AP = substractVector(P,A)
+    let AB = substractVector(B,A)
+    let k=dotProduct(AP,AB)/dotProduct(AB,AB)
+    let zP=this.outline[0].z+k*(this.outline[1].z-this.outline[0].z)
+    P.z=zP
+    return P
   }
   getProjectedPoint(point) {
     if (this.outline.length == 0) {

package/src/objects/Point.js

@@ -1,9 +1,12 @@
 
+import { v4 as uuidv4 } from 'uuid'
 import {
   getDistanceBetweenPoints,
+  get3DDistanceBetweenPoints,
+  isSamePoint3D,
   translate2D,
 } from '../geometry'
-import { v4 as uuidv4 } from 'uuid'
+import { substractVector,dotProduct } from '../vector'
 
 export class Point {
   constructor(x = 0, y = 0, z = 0, layer = null) {
@@ -19,6 +22,24 @@ export class Point {
     this.visible = true
     this.hasWarning = false
   }  
+  getIntersections(object){
+    const intersections=[]
+    if(!object)return
+    if(object.type=="line"){
+      if(isSamePoint3D(object.getProjectedPoint(this),this)){
+        intersections.push({...this})
+      }
+    }else if(object.type=="point"){
+        if(isSamePoint3D(object,this)){
+        intersections.push({...object})
+        }
+    }else if(object.type=="circle"){
+      if(get3DDistanceBetweenPoints(this,object.center)==object.radius){
+        intersections.push({...this})
+      }
+    }
+    return intersections
+  }
   getPxDistanceTo(point, canvasContext) {
     const toRealityRef = canvasContext.toRealityRef
     const realityPoint = toRealityRef(point)
@@ -27,6 +48,21 @@ export class Point {
   getProjectedPoint(point) {
     return this
   }
+  getVerticalProjectedPoint(point) {
+   return this
+  }
+  getDistanceToPoint(point) {
+    return get3DDistanceBetweenPoints(point, this.getProjectedPoint(point))
+   }
+   getHorizontalDistanceToPoint(point) {
+   return getDistanceBetweenPoints(point, this.getVerticalProjectedPoint(point))
+  }
+   isInPlane(plane){
+    if(!plane) return false
+    const {point,normalVector}=plane
+    if(dotProduct(substractVector(point,this),normalVector)>0.1) return false
+    return true
+   }
   translate(vectorInMm) {
     let translatedPoint = translate2D({ x: this.x, y: this.y }, vectorInMm)
     this.x = translatedPoint.x

package/src/objects/Polygon.js

@@ -124,7 +124,10 @@ export class Polygon {
         x: p.x,
         y: p.y,
         z: p.z,
-      }}),
+        selected:p.selected,
+        open:p.open,
+        }
+      }),
       holes: this.holes.map((p) => p.id),
       layer: this.layer,
       highlight: this.highlight,
@@ -166,6 +169,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 +214,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
 }
 

package/src/vector.js

@@ -25,6 +25,12 @@ export function addVector(u, v) {
     const result = u.x * v.x + u.y * v.y + u.z * v.z
     return result
   }
+  export function areCollinear(u,v){
+    return vectorLength(crossProduct(u,v)) == 0
+  }
+  export function areAlmostCollinear(u,v,tolerance){
+    return vectorLength(crossProduct(u,v)) < tolerance
+  }
   export function crossProduct(u, v) {
     const result = {}
     result.x = u.y * v.z - u.z * v.y