@eturnity/eturnity_maths 7.4.0 → 7.10.0

package/package.json

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

package/src/geometry.js

@@ -98,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, '')
 }
 
@@ -110,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}
 
@@ -140,11 +145,20 @@ 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)
+    let distanceFunction = get3DDistanceBetweenPoints
+    if(H.z==undefined || I.z==undefined || J.z==undefined || isNaN(H.z) || isNaN(I.z) || isNaN(J.z) ){
+      distanceFunction=getDistanceBetweenPoints
+    }
+    const a = distanceFunction(H, I)
+    const b = distanceFunction(I, J)
+    const c = distanceFunction(H, J)
+  
   
     let angle = (Math.acos((a * a + b * b - c * c) / (2 * a * b)) * 180) / Math.PI
     
@@ -542,33 +556,65 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
   }
   
   export function getPointOnLine(M, A, B) {
+    function zValueNotDefined(P){
+      return P.z==undefined || isNaN(P.z)
+    }
     //Calcul of P, Projection of M on line AB
     if (isSamePoint3D(A, B)) {
       console.error("A and B don't make a line : A==B")
       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(zValueNotDefined(M) || zValueNotDefined(A) || zValueNotDefined(B)){
+      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
@@ -584,10 +630,10 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
   
   
   export function normalizedVectorTowardInsideAngle(H, I, J) {
-    const IH_angle = Math.atan2(H.y - I.y, H.x - I.x)
-    const JI_angle = Math.atan2(J.y - I.y, J.x - I.x)
-    const angle = (IH_angle + JI_angle) / 2
-    return { x: Math.cos(angle), y: Math.sin(angle) }
+    const IH = normalizeVector(substractVector(H, I))
+    const IJ = normalizeVector(substractVector(J, I))
+    const res = normalizeVector(addVector(IH,IJ))
+    return res
   }
   
   
@@ -904,4 +950,40 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
     }
     return { x: handleX, y: handleY, z: outline[i].z }
   }
+  export function triangleArea(A,B,C){
+      var AB = substractVector(B,A)
+      var AC = substractVector(C,A)
+      const product = crossProduct(AB, AC)
+      let area = vectorLength(product)/2
+      return area
+  }
+  export function getIndexesOfBiggestTrangle(points){
+    return getIndexesOfBiggestTrangleWithFixedIndexes(points,[])
+  }
+  export function getIndexesOfBiggestTrangleWithFixedIndexes(points,fixedIndexes){
+    if(points.length<3){
+      throw new Error("not enough points to make a triangle")
+      return 
+    }
+    let maxArea = -1
+    let maxTriangle = [ 0, 1, 2]
+    fixedIndexes=[...new Set(...fixedIndexes)].slice(0,3)
+    if(fixedIndexes.length==3){return fixedIndexes}
+      for (let i = 0; i < points.length - 2; i++) {
+        if(fixedIndexes.length==0 || fixedIndexes.includes(i)){
+          for (let j = i + 1; j < points.length - 1; j++) {
+            if(fixedIndexes.length<2 || fixedIndexes.includes(j)){
+              for (let k = j + 1; k < points.length; k++) {
+                const area = triangleArea(points[i], points[j], points[k]);
+                if (area > maxArea) {
+                    maxArea = area;
+                    maxTriangle = [i, j, k];
+                }
+              }
+            }
+          }
+        }
+      }
+    return maxTriangle
+  }
   

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,50 @@ 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(M, A, B)
+    P.z = 0
+    if(!this.infiniteLine && !isPointBetweenSegment(P,A,B)){
+      return (Math.min(getDistanceBetweenPoints(M, A),getDistanceBetweenPoints(M, B))) / canvasContext.mmPerPx
+    }
+    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,

package/src/objects/derivedState/AddMargin.js

@@ -37,7 +37,11 @@ export function getRoofMarginOutline(polygon){
     polygon.margins.outterOutline=polygon.flatOutline
     polygon.margins.innerOutline=[]
     const length=polygon.outline.length
+    polygon.margins.distances = polygon.margins.distances.slice(0, length)
     for(let index=0;index<length;index++){
+      if(polygon.margins.distances[index] == undefined){
+        polygon.margins.distances[index] = polygon.margins.sameMargin
+      }
       const B=polygon.margins.outterOutline[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
@@ -78,7 +82,11 @@ export function getObstacleMarginOutline(polygon){
   polygon.margins.innerOutline=polygon.flatOutline
   polygon.margins.outterOutline=[]
   const length=polygon.margins.innerOutline.length
+  polygon.margins.distances = polygon.margins.distances.slice(0, length)
   for(let index=0;index<length;index++){
+    if(polygon.margins.distances[index] == undefined){
+        polygon.margins.distances[index] = polygon.margins.sameMargin
+      }
     const B=polygon.margins.innerOutline[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

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -62,7 +62,7 @@ export function updateComputedGeometryPolygon(polygon) {
   if(!['roof','obstacle','moduleField'].includes(polygon.layer)){
     return polygon
   }
-  if(isAlmostSamePoint2D(polygon.outline[0],polygon.outline[polygon.outline.length-1],10)){
+  if(polygon.outline.length > 0 && isAlmostSamePoint2D(polygon.outline[0],polygon.outline[polygon.outline.length-1],10)){
     polygon.outline.pop()
   }
   polygon.outline = calculateValidOutlineFromPolygon(polygon.outline)
@@ -125,10 +125,12 @@ export function calculateValidOutlineFromPolygon(outline){
   let v = normalizedVectorTowardInsideAngle(D,E,F)
   
   outline[coupleToSplit[0]] = {
+      ...outline[coupleToSplit[0]],
       ...addVector(multiplyVector(-mmTolerance,u),B),
       z:outline[coupleToSplit[0]].z
     }
   outline[coupleToSplit[1]] = {
+      ...outline[coupleToSplit[1]],
       ...addVector(multiplyVector(mmTolerance,v),E),
       z:outline[coupleToSplit[1]].z
     }
@@ -144,7 +146,7 @@ export function calculateBestFittingPlanePolygon(fullOutline) {
     return null
   }
   let isIncludingAllNodes=false
-  let outline=fullOutline.filter(p=>!p.selected)
+  let outline=fullOutline
   if(outline.length<3){
     isIncludingAllNodes=true
     outline=fullOutline

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