@eturnity/eturnity_maths 7.2.3-qa-7.6.0 → 7.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "7.2.3-qa-7.6.0",
+  "version": "7.4.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, C.z + B.z - A.z)
+  const D = new Point(C.x + B.x - A.x, C.y + B.y - A.y)
   return new Line(C, D, '')
 }
 
@@ -110,15 +110,10 @@ 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))
-  //N point on Bv
-  let N=addVector(B,multiplyVector(-t2,v))
+  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}
 
@@ -145,15 +140,11 @@ 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 = get3DDistanceBetweenPoints(H, I)
-    const b = get3DDistanceBetweenPoints(I, J)
-    const c = get3DDistanceBetweenPoints(H, J)
+    const a = getDistanceBetweenPoints(H, I)
+    const b = getDistanceBetweenPoints(I, J)
+    const c = getDistanceBetweenPoints(H, J)
   
     let angle = (Math.acos((a * a + b * b - c * c) / (2 * a * b)) * 180) / Math.PI
     
@@ -557,56 +548,27 @@ export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
       return null
     }
     let P = {}
-    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
-      }
+    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
     }
     //projection of the point to the line
     return P

package/src/objects/Circle.js

@@ -1,13 +1,12 @@
 
 import {
+  getDistanceBetweenPoints,
   translate2D,
   verticalProjectionOnPlane,
-  get3DDistanceBetweenPoints,
-  getDistanceBetweenPoints,
+  get3DDistanceBetweenPoints
 } from '../geometry'
 import { v4 as uuidv4 } from 'uuid'
 import {Point} from './Point'
-import { addVector, multiplyVector, substractVector,vectorLength,crossProduct,dotProduct,normalizeVector } from '../vector'
 
 
 
@@ -31,25 +30,6 @@ 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)
@@ -61,20 +41,6 @@ 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
@@ -88,13 +54,9 @@ 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 z = this.center.z + (point.z - this.center.z) * (this.radius / distance)
-    let P = new Point(x, y, z, this.layer)
+    let P = new Point(x, y, 0, this.layer)
     return P
   }
-  getVerticalProjectedPoint(point) {
-   return this.getProjectedPoint(point)
-  }
   translate(vectorInMm) {
     this.center = translate2D(this.center, vectorInMm)
   }

package/src/objects/Line.js

@@ -6,12 +6,9 @@ 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 {
@@ -38,35 +35,6 @@ 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]) /
@@ -101,47 +69,8 @@ export class Line {
     }
 
     let realityRefPoint = toRealityRef(point)
-    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
+    let P = getPointOnLine(realityRefPoint, this.outline[0], this.outline[1])
+    return getDistanceBetweenPoints(realityRefPoint, P) / canvasContext.mmPerPx
   }
   getProjectedPoint(point) {
     if (this.outline.length == 0) {

package/src/objects/Point.js

@@ -1,12 +1,9 @@
 
-import { v4 as uuidv4 } from 'uuid'
 import {
   getDistanceBetweenPoints,
-  get3DDistanceBetweenPoints,
-  isSamePoint3D,
   translate2D,
 } from '../geometry'
-import { substractVector,dotProduct } from '../vector'
+import { v4 as uuidv4 } from 'uuid'
 
 export class Point {
   constructor(x = 0, y = 0, z = 0, layer = null) {
@@ -22,24 +19,6 @@ 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)
@@ -48,21 +27,6 @@ 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,10 +124,7 @@ 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/vector.js

@@ -25,12 +25,6 @@ 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