@eturnity/eturnity_maths 7.20.0 → 7.24.1

package/src/objects/Line.js

@@ -1,185 +1,283 @@
-
 import {
-  getDistanceBetweenPoints,
-  get3DDistanceBetweenPoints,
-  getPointOnLine,
-  isSamePoint3D,
-  translate2D,
-  midPoint,
-  getDataAboutTwo3DLines,
-  isPointBetweenSegment,
+	getDistanceBetweenPoints,
+	get3DDistanceBetweenPoints,
+	getPointOnLine,
+	isSamePoint3D,
+	isSamePoint2D,
+	translate2D,
+	midPoint,
+	getDataAboutTwo3DLines,
+	isPointBetweenSegment,
+  verticalProjectionOnPlane
 } from '../geometry'
 import { v4 as uuidv4 } from 'uuid'
-import {Point} from './Point'
-import { substractVector,normalizeVector, addVector, multiplyVector,dotProduct } from '../vector'
-
+import { Point } from './Point'
+import {
+	substractVector,
+	normalizeVector,
+	addVector,
+	multiplyVector,
+	dotProduct
+} from '../vector'
 
 export class Line {
-  constructor(firstPoint, lastPoint, layer, infiniteLine = false) {
-    this.id = uuidv4()
-    this.version = 0
-    this.type = 'line'
-    if (firstPoint && lastPoint) {
-      this.outline = [firstPoint, lastPoint]
-    } else {
-      this.outline = []
-    }
-    this.layer = layer
-    this.visible = true
-    this.infiniteLine = infiniteLine
-  }
-  clone() {
-    const line = new Line()
-    this.outline.forEach((p) => {
-      line.outline.push(new Point(p.x, p.y, p.z))
-    })
-    line.id = uuidv4()
-    line.layer = this.layer
-    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]) /
+	constructor(firstPoint, lastPoint, layer, infiniteLine = false) {
+		this.id = uuidv4()
+		this.version = 0
+		this.type = 'line'
+		if (firstPoint && lastPoint) {
+			this.outline = [firstPoint, lastPoint]
+		} else {
+			this.outline = []
+		}
+		this.layer = layer
+		this.visible = true
+		this.infiniteLine = infiniteLine
+	}
+	clone() {
+		const line = new Line()
+		this.outline.forEach((p) => {
+			line.outline.push(new Point(p.x, p.y, p.z))
+		})
+		line.id = uuidv4()
+		line.layer = this.layer
+		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]) /
       canvasContext.mmPerPx
-    )
-  }
-  mmLength() {
-    return get3DDistanceBetweenPoints(this.outline[0], this.outline[1])
-  }
-  
-  getMidPoint() {
-    return midPoint(this.outline[0], this.outline[1])
-  }
-  getAngleDeg(){
-    const angle = Math.atan2(
-      this.outline[1].y - this.outline[0].y,
-      this.outline[0].x - this.outline[1].x
-    )
-    return (angle * 180) / Math.PI
-  }
-  getPxDistanceTo(point, canvasContext) {
-    const toCanvasRef = canvasContext.toCanvasRef
-    const toRealityRef = canvasContext.toRealityRef
+		)
+	}
+	mmLength() {
+		return get3DDistanceBetweenPoints(this.outline[0], this.outline[1])
+	}
+
+	getMidPoint() {
+		return midPoint(this.outline[0], this.outline[1])
+	}
+	getAngleDeg() {
+		const angle = Math.atan2(
+			this.outline[1].y - this.outline[0].y,
+			this.outline[0].x - this.outline[1].x
+		)
+		return (angle * 180) / Math.PI
+	}
+	getPxDistanceTo(point, canvasContext) {
+		const toCanvasRef = canvasContext.toCanvasRef
+		const toRealityRef = canvasContext.toRealityRef
 
-    if (this.outline.length < 2) {
-      console.error('line undefined')
-      return null
-    }
-    if (isSamePoint3D(this.outline[0], this.outline[1])) {
-      console.error('line undefined')
-      return null
-    }
+		if (this.outline.length < 2) {
+			console.error('line undefined')
+			return null
+		}
+		if (isSamePoint3D(this.outline[0], this.outline[1])) {
+			console.error('line undefined')
+			return null
+		}
 
-    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(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) {
-      return null
-    }
-    if (isSamePoint3D(this.outline[0], this.outline[1])) {
-      console.error("A == B Can't project point on Line")
-      return null
-    }
-    let P = getPointOnLine(point, this.outline[0], this.outline[1])
-    return P
-  }
-  translate(vectorInMm) {
-    this.outline = this.outline.map((point) => {
-      return translate2D(point, vectorInMm)
-    })
-  }
-  serialize() {
-    if (!this.belongsTo) {
-      this.belongsTo = []
-    }
-    const belongsTo = this.belongsTo.map((item) => {
-      return {
-        polygon: item.polygon.serialize(),
-        polygonId: item.polygonId,
-        index: item.index
-      }
-    })
-    const serializedEdge={
-      outline: [this.outline[0], this.outline[1]],
-      layer: this.layer,
-      type: this.type,
-      belongsTo: belongsTo || [],
-      itemType: this.itemType
-    }
-    return JSON.parse(JSON.stringify(serializedEdge))
-  }
-}
+		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(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) {
+			return null
+		}
+		if (isSamePoint3D(this.outline[0], this.outline[1])) {
+			console.error('A == B Can\'t project point on Line')
+			return null
+		}
+		let P = getPointOnLine(point, this.outline[0], this.outline[1])
+		return P
+	}
+	isEffectivelySplit(polygons) {
+		if (this.belongsTo.length != 2) {
+			return false
+		}
+		const polygon0 = polygons.find((p) => p.id == this.belongsTo[0].polygonId)
+		const polygon1 = polygons.find((p) => p.id == this.belongsTo[1].polygonId)
+		if(!polygon0 || !polygon1){
+			return false
+		}
+		let A, B, C, D
+		if (this.belongsTo[0].index !== null) {
+			A = polygon0.outline[this.belongsTo[0].index]
+			B =
+        polygon0.outline[
+        	(this.belongsTo[0].index + 1) % polygon0.outline.length
+        ]
+		}
+		if (this.belongsTo[1].index !== null) {
+			C = polygon1.outline[this.belongsTo[1].index]
+			D =
+        polygon1.outline[
+        	(this.belongsTo[1].index + 1) % polygon1.outline.length
+        ]
+		}
+		if (!A || !B) {
+			A = verticalProjectionOnPlane(
+				C,
+				polygon0.normalVector,
+				polygon0.flatOutline[0]
+			)
+			B = verticalProjectionOnPlane(
+				D,
+				polygon0.normalVector,
+				polygon0.flatOutline[0]
+			)
+		}
+		if (!C || !D) {
+			C = verticalProjectionOnPlane(
+				A,
+				polygon1.normalVector,
+				polygon1.flatOutline[0]
+			)
+			D = verticalProjectionOnPlane(
+				B,
+				polygon1.normalVector,
+				polygon1.flatOutline[0]
+			)
+		}
+		if (isSamePoint2D(A, C)) {
+			const isSplit = Math.abs(A.z - C.z) > 10 || Math.abs(B.z - D.z) > 10
+			return isSplit
+		} else {
+			const isSplit = Math.abs(A.z - D.z) > 10 || Math.abs(B.z - C.z) > 10
+			return isSplit
+		}
+	}
+	translate(vectorInMm) {
+		this.outline = this.outline.map((point) => {
+			return translate2D(point, vectorInMm)
+		})
+	}
+	serialize() {
+		if (!this.belongsTo) {
+			this.belongsTo = []
+		}
+		const belongsTo = this.belongsTo.map((item) => {
+			return {
+				polygon: item.polygon.serialize(),
+				polygonId: item.polygonId,
+				index: item.index
+			}
+		})
+		const serializedEdge = {
+			outline: [this.outline[0], this.outline[1]],
+			layer: this.layer,
+			type: this.type,
+			belongsTo: belongsTo || [],
+			itemType: this.itemType
+		}
+		return JSON.parse(JSON.stringify(serializedEdge))
+	}
+}

package/src/objects/Point.js

@@ -1,12 +1,11 @@
-
 import { v4 as uuidv4 } from 'uuid'
 import {
   getDistanceBetweenPoints,
   get3DDistanceBetweenPoints,
   isSamePoint3D,
-  translate2D,
+  translate2D
 } from '../geometry'
-import { substractVector,dotProduct } from '../vector'
+import { substractVector, dotProduct } from '../vector'
 
 export class Point {
   constructor(x = 0, y = 0, z = 0, layer = null) {
@@ -21,21 +20,21 @@ export class Point {
     this.selected = false
     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})
+  }
+  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=="point"){
-        if(isSamePoint3D(object,this)){
-        intersections.push({...object})
-        }
-    }else if(object.type=="circle"){
-      if(get3DDistanceBetweenPoints(this,object.center)==object.radius){
-        intersections.push({...this})
+    } else if (object.type == 'circle') {
+      if (get3DDistanceBetweenPoints(this, object.center) == object.radius) {
+        intersections.push({ ...this })
       }
     }
     return intersections
@@ -49,20 +48,24 @@ export class Point {
     return this
   }
   getVerticalProjectedPoint(point) {
-   return this
+    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
+  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
@@ -90,4 +93,4 @@ export class Point {
       itemType: this.itemType
     }
   }
-}
+}