@eturnity/eturnity_maths 9.7.0 → 9.10.0

package/package.json

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

package/src/coords.js

@@ -1,13 +1,33 @@
-export function toRealityRefFunction(canvasSize, mmPerPx, layoutOffset) {
+import { multiplyMatrices } from './matrix'
+import { Point } from './objects/Point'
+import { defaultPlane } from './objects/Plane'
+export function toRealityRefFunction(
+  canvasSize,
+  mmPerPx,
+  layoutOffset,
+  plane = defaultPlane
+) {
   return (point) => {
-    let realityX = (point.x - layoutOffset.x) * mmPerPx
-    // let realityY = -(point.y - layoutOffset.y - (canvasSize.height*layoutOffset.zoom)/(100 * 2)) * mmPerPx
-    let realityY = -(point.y - layoutOffset.y) * mmPerPx
-
-    return { x: realityX, y: realityY, z: point.z }
+    let xMm = (point.x - layoutOffset.x) * mmPerPx
+    let yMm = -(point.y - layoutOffset.y) * mmPerPx
+    let zMm = 0
+    if (plane) {
+      const pointInRealityCoordinates = plane.toRealityCoordinates({
+        x: xMm,
+        y: yMm,
+        z: zMm,
+      })
+      return pointInRealityCoordinates
+    }
+    return { x: xMm, y: yMm, z: point.z }
   }
 }
-export function toCanvasRefFunction(canvasSize, mmPerPx, layoutOffset) {
+export function toCanvasRefFunction(
+  canvasSize,
+  mmPerPx,
+  layoutOffset,
+  plane = defaultPlane
+) {
   return (point) => {
     if (!point) {
       console.error('no point', point)
@@ -16,9 +36,22 @@ export function toCanvasRefFunction(canvasSize, mmPerPx, layoutOffset) {
       console.error('no canvas Size')
       return null
     }
-    let canvasX = layoutOffset.x + point.x / mmPerPx
-    let canvasY = layoutOffset.y - point.y / mmPerPx
-
-    return { x: canvasX, y: canvasY, z: point.z }
+    let xMm = point.x
+    let yMm = point.y
+    if (point.z === undefined || isNaN(point.z)) {
+      point.z = 0
+    }
+    if (plane) {
+      const pointInPlaneCoordinates = plane.toPlaneCoordinates({
+        x: point.x,
+        y: point.y,
+        z: point.z,
+      })
+      xMm = pointInPlaneCoordinates.x
+      yMm = pointInPlaneCoordinates.y
+    }
+    let canvasX = layoutOffset.x + xMm / mmPerPx
+    let canvasY = layoutOffset.y - yMm / mmPerPx
+    return new Point(canvasX, canvasY, 0)
   }
 }

package/src/geometry.js

@@ -102,8 +102,8 @@ export function getSnapedValue(value, snaps, tolerance) {
   return closeSnapsItem.value
 }
 export function getAngleInDegFrom2DENUVector(v) {
-  const angle = Math.atan2(v.y, -v.x)
-  return ((angle * 180) / Math.PI + 90 + 360) % 360
+  const angle = Math.atan2(v.x, v.y)
+  return ((angle * 180) / Math.PI + 360) % 360
 }
 export function getAngleInDegFromCanvasVector(v) {
   const angle = Math.atan2(v.y, v.x)
@@ -135,8 +135,15 @@ export function getParallelLinePassingByPoint(A, B, C) {
   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, '')
 }
-
-export function getDataAboutTwo3DLines(A, u, B, v) {
+export function getDistanceBetweenTwoParallelInfiniteLines(line0, line1) {
+  const A = line0.outline[0]
+  const u = line0.getDirectionVector()
+  const B = line1.outline[0]
+  const AB = substractVector(B, A)
+  const distance = vectorLength(crossProduct(AB, u))
+  return distance
+}
+export function getDataAboutTwo3DLines(A, u, B, v, isInfinite = true) {
   let w = crossProduct(u, v)
   let m = [
     [u.x, v.x, w.x],
@@ -150,12 +157,17 @@ export function getDataAboutTwo3DLines(A, u, B, v) {
   let AB = substractVector(B, A)
   let [t1, t2, t3] = multiplyMatrices(mInv, [[AB.x], [AB.y], [AB.z]])
   //M point on Au
+  if (!isInfinite) {
+    t1 = Math.max(0, Math.min(t1, 1))
+    t2 = Math.max(0, Math.min(t2, -1))
+  }
   let M = addVector(A, multiplyVector(t1, u))
   //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 }
 }
+
 export function vectorFromAngleInDegCanvas(angle) {
   return {
     x: Math.sin((angle * Math.PI) / 180),
@@ -540,7 +552,6 @@ export function isOnBorderOfPolygon(point, vs) {
 export function isStrictlyInsidePolygon(point, vs) {
   return isInsidePolygon(point, vs) && !isOnBorderOfPolygon(point, vs)
 }
-
 export function isInsidePolygon(point, vs) {
   // ray-casting algorithm based on
   // https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html/pnpoly.html
@@ -676,7 +687,7 @@ export function get2PolygonsOutlineFrom3Paths(path1, path2, path3) {
   return [poly1, poly2]
 }
 
-export function getPointOnLine(M, A, B) {
+export function getPointOnLine(M, A, B, isIncludedInSegment = false) {
   function zValueNotDefined(P) {
     return P.z == undefined || isNaN(P.z)
   }
@@ -705,9 +716,12 @@ export function getPointOnLine(M, 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
+      let normalizedDot = dot / (distanceAB * distanceAB)
+      if (isIncludedInSegment) {
+        normalizedDot = Math.max(0, Math.min(normalizedDot, 1))
+      }
+      P.x = A.x + normalizedDot * AB.x
+      P.y = A.y + normalizedDot * AB.y
     }
   } else {
     //make 3D projection on line
@@ -731,10 +745,13 @@ export function getPointOnLine(M, 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
+      let normalizedDot = dot / (distanceAB * distanceAB)
+      if (isIncludedInSegment) {
+        normalizedDot = Math.max(0, Math.min(normalizedDot, 1))
+      }
+      P.x = A.x + normalizedDot * AB.x
+      P.y = A.y + normalizedDot * AB.y
+      P.z = A.z + normalizedDot * AB.z
     }
   }
   //projection of the point to the line
@@ -768,7 +785,7 @@ export function isPointBetweenSegment(A, B, C) {
   const AB = getDistanceBetweenPoints(A, B)
   const AC = getDistanceBetweenPoints(A, C)
   const BC = getDistanceBetweenPoints(C, B)
-  const isBetween = AB < BC && AC < BC
+  const isBetween = AB <= BC && AC <= BC
   return isBetween
 }
 export function get3pointNotAlignedFromOutline(outline) {
@@ -870,6 +887,22 @@ export function verticalProjectionOnPlane(p, n, o) {
   const projectedPoint = { ...p, z: projectedHeight }
   return projectedPoint
 }
+export function projectionOnPlaneFollowingVector(p, n, o, v) {
+  // if p belongs to (n,o) plane return p
+  const opn = dotProduct(substractVector(p, o), n)
+  if (opn == 0) {
+    return p
+  }
+  //if n and v are normal to each other, return error
+  const nv = dotProduct(n, v)
+  if (nv == 0) {
+    console.warn('projection plane and vector are coplanar')
+    throw new Error('Cannot project: normal vector and direction vector are perpendicular')
+  }
+  const lambda = -opn / nv
+  const projectedPoint = addVector(p, multiplyVector(lambda, v))
+  return projectedPoint
+}
 
 export function calcPolygonArea(vertices) {
   var total = 0

package/src/geometryShortDistance.js

@@ -0,0 +1,442 @@
+import {
+  getDistanceBetweenPoints,
+  get3DDistanceBetweenPoints,
+  isSamePoint3D,
+  getDataAboutTwo3DLines,
+  verticalProjectionOnPlane,
+  getDistanceBetweenTwoParallelInfiniteLines,
+} from './geometry'
+import { areAlmostCollinear, substractVector, dotProduct } from './vector'
+import { Point } from './objects/Point'
+import { Line } from './objects/Line'
+import { Circle } from './objects/Circle'
+import { Polygon } from './objects/Polygon'
+import { areObjectsIntersecting } from './intersectionCheck'
+import { defaultPlane } from './objects/Plane'
+/**
+ * Returns the shortest segment between two objects
+ * @param {Object} obj0 - First object (Point, Line, Circle, or Polygon)
+ * @param {Object} obj1 - Second object (Point, Line, Circle, or Polygon)
+ * @param {Object} point - Reference point (used to disambiguate when multiple segments exist)
+ * @returns {Array} [pointOnObj0, pointOnObj1] - Two points forming the shortest segment
+ */
+export function getShortestSegmentBetweenObjects(
+  obj0,
+  obj1,
+  point,
+  projectionPlane = defaultPlane
+) {
+  // Check if objects intersect
+  if (areObjectsIntersecting(obj0, obj1)) {
+    if (point) {
+      point = new Point(point.x, point.y, point.z)
+      return getShortestSegmentBetweenObjects(
+        obj0,
+        point,
+        null,
+        projectionPlane
+      )
+    } else if (obj1.type === 'point') {
+      return [obj1, obj1]
+    } else if (obj0.type === 'point') {
+      return [obj0, obj0]
+    } else {
+      return null
+    }
+  }
+
+  // Handle Point cases
+  if (obj0.type === 'point' && obj1.type === 'point') {
+    return getShortestSegmentPointPoint(obj0, obj1, point, projectionPlane)
+  }
+  if (obj0.type === 'point' && obj1.type === 'line') {
+    return getShortestSegmentPointLine(obj0, obj1, point, projectionPlane)
+  }
+  if (obj0.type === 'point' && obj1.type === 'circle') {
+    return getShortestSegmentPointCircle(obj0, obj1, point, projectionPlane)
+  }
+  if (obj0.type === 'point' && obj1.type === 'polygon') {
+    return getShortestSegmentPointPolygon(obj0, obj1, point, projectionPlane)
+  }
+
+  // Handle Line cases
+  if (obj0.type === 'line' && obj1.type === 'point') {
+    const result = getShortestSegmentPointLine(
+      obj1,
+      obj0,
+      point,
+      projectionPlane
+    )
+    if (result) {
+      return [result[1], result[0]]
+    }
+  }
+  if (obj0.type === 'line' && obj1.type === 'line') {
+    return getShortestSegmentLineLine(obj0, obj1, point, projectionPlane)
+  }
+  if (obj0.type === 'line' && obj1.type === 'circle') {
+    return getShortestSegmentLineCircle(obj0, obj1, point, projectionPlane)
+  }
+  if (obj0.type === 'line' && obj1.type === 'polygon') {
+    return getShortestSegmentLinePolygon(obj0, obj1, point, projectionPlane)
+  }
+  // Handle Circle cases
+  if (obj0.type === 'circle' && obj1.type === 'point') {
+    const result = getShortestSegmentPointCircle(
+      obj1,
+      obj0,
+      point,
+      projectionPlane
+    )
+    if (result) {
+      return [result[1], result[0]]
+    }
+  }
+  if (obj0.type === 'circle' && obj1.type === 'line') {
+    const result = getShortestSegmentLineCircle(
+      obj1,
+      obj0,
+      point,
+      projectionPlane
+    )
+    if (result) {
+      return [result[1], result[0]]
+    }
+    return [result[1], result[0]]
+  }
+  if (obj0.type === 'circle' && obj1.type === 'circle') {
+    return getShortestSegmentCircleCircle(obj0, obj1, point, projectionPlane)
+  }
+
+  if (obj0.type === 'circle' && obj1.type === 'polygon') {
+    return getShortestSegmentCirclePolygon(obj0, obj1, point, projectionPlane)
+  }
+  //handle polygon cases
+  if (obj0.type === 'polygon' && obj1.type === 'point') {
+    const result = getShortestSegmentPointPolygon(
+      obj1,
+      obj0,
+      point,
+      projectionPlane
+    )
+    if (result) {
+      return [result[1], result[0]]
+    }
+  }
+  if (obj0.type === 'polygon' && obj1.type === 'line') {
+    const result = getShortestSegmentLinePolygon(
+      obj1,
+      obj0,
+      point,
+      projectionPlane
+    )
+    if (result) {
+      return [result[1], result[0]]
+    } else {
+      return null
+    }
+  }
+  if (obj0.type === 'polygon' && obj1.type === 'circle') {
+    const result = getShortestSegmentCirclePolygon(
+      obj1,
+      obj0,
+      point,
+      projectionPlane
+    )
+    return [result[1], result[0]]
+  }
+  if (obj0.type === 'polygon' && obj1.type === 'polygon') {
+    return getShortestSegmentPolygonPolygon(obj0, obj1, point, projectionPlane)
+  }
+
+  console.error('Unsupported object types get shortest:', obj0.type, obj1.type)
+  console.trace()
+  return [point, point]
+}
+
+/**
+ * Check if two objects intersect
+ * @param {Object} obj0 - First object
+ * @param {Object} obj1 - Second object
+ * @returns {Boolean} True if objects intersect
+ */
+
+/**
+ * Get shortest segment between two points
+ * @param {Point} p0 - First point
+ * @param {Point} p1 - Second point
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [point0, point1]
+ */
+export function getShortestSegmentPointPoint(
+  p0,
+  p1,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  // The segment is just the two points
+  return [p0, p1]
+}
+
+/**
+ * Get shortest segment between point and line
+ * @param {Point} point - Point object
+ * @param {Line} line - Line object
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnPoint, pointOnLine]
+ */
+export function getShortestSegmentPointLine(
+  point,
+  line,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  return [
+    point,
+    line.getProjectedPointFromPlane(point, {
+      isIncludedInSegment: false,
+      plane: projectionPlane,
+    }),
+  ]
+}
+
+/**
+ * Get shortest segment between point and circle
+ * @param {Point} point - Point object
+ * @param {Circle} circle - Circle object
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnPoint, pointOnCircle]
+ */
+export function getShortestSegmentPointCircle(
+  point,
+  circle,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  if (get3DDistanceBetweenPoints(point, circle.center) <= circle.radius) {
+    return circle.getCircleDiameterPoints(point, { plane: projectionPlane })
+  }
+  return [
+    point,
+    circle.getProjectedPointFromPlane(point, { plane: projectionPlane }),
+  ]
+}
+
+/**
+ * Get shortest segment between point and polygon
+ * @param {Point} point - Point object
+ * @param {Polygon} polygon - Polygon object
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnPoint, pointOnPolygon]
+ */
+export function getShortestSegmentPointPolygon(
+  point,
+  polygon,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  // TODO: Find the point on the polygon (vertex or edge) closest to the point
+  // TODO: If multiple solutions exist, choose the one closest to refPoint
+  const P = verticalProjectionOnPlane(
+    point,
+    polygon.normalVector,
+    polygon.outline[0]
+  )
+  const pointInPlane = new Point(P.x, P.y, P.z)
+  const closestEdge = polygon.getClosestPolygonEdgeFromPlane(
+    pointInPlane,
+    projectionPlane
+  )
+
+  if (refPoint) {
+    const projectedPointOnPolygonEdge = closestEdge.getProjectedPointFromPlane(
+      refPoint,
+      true,
+      projectionPlane
+    )
+    // const closestPoint = findClosestPoint(projectedPoints, refPoint)
+    return [pointInPlane, projectedPointOnPolygonEdge]
+  } else {
+    const projectedPointOnPolygonEdge = closestEdge.getProjectedPointFromPlane(
+      pointInPlane,
+      true,
+      projectionPlane
+    )
+
+    return [pointInPlane, projectedPointOnPolygonEdge]
+  }
+}
+
+/**
+ * Get shortest segment between two lines
+ * @param {Line} line0 - First line
+ * @param {Line} line1 - Second line
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnLine0, pointOnLine1]
+ */
+export function getShortestSegmentLineLine(
+  line0,
+  line1,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  if (line0.id == line1.id) {
+    return [line0.outline[0], line0.outline[1]]
+  }
+  const A = line0.outline[0]
+  const u = substractVector(line0.outline[1], line0.outline[0])
+  const B = line1.outline[0]
+  const v = substractVector(line1.outline[1], line1.outline[0])
+  let P1 = line0.getProjectedPointFromPlane(refPoint, {
+    isIncludedInSegment: false,
+    plane: projectionPlane,
+  })
+  const P2 = line1.getIntersectionWithPointVectorLineFromPlane(
+    P1,
+    line0.getNormalVectorInPlane(projectionPlane),
+    projectionPlane
+  )
+  if (P2 && P1) {
+    return [P1, P2]
+  }
+  return null
+}
+
+/**
+ * Get shortest segment between line and circle
+ * @param {Line} line - Line object
+ * @param {Circle} circle - Circle object
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnLine, pointOnCircle]
+ */
+export function getShortestSegmentLineCircle(
+  line,
+  circle,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  const A = line.getProjectedPointFromPlane(circle.center, {
+    isIncludedInSegment: false,
+    plane: projectionPlane,
+  })
+  const B = circle.getProjectedPointFromPlane(A, { plane: projectionPlane })
+  return [A, B]
+}
+
+/**
+ * Get shortest segment between line and polygon
+ * @param {Line} line - Line object
+ * @param {Polygon} polygon - Polygon object
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnLine, pointOnPolygon] or null
+ */
+export function getShortestSegmentLinePolygon(
+  line,
+  polygon,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  const polygonEdges = polygon.outline.map((p, index) => {
+    const nextP = polygon.outline[(index + 1) % polygon.outline.length]
+    return new Line(p, nextP)
+  })
+  let polygonEdgesData = polygonEdges
+    .map((edge) => {
+      const data = getShortestSegmentLineLine(
+        line,
+        edge,
+        refPoint,
+        projectionPlane
+      )
+      if (!!data) {
+        const [M, N] = data
+        const distance = getDistanceBetweenPoints(M, N)
+        return { distance, M, N }
+      } else {
+        return null
+      }
+    })
+    .filter((data) => !!data)
+  polygonEdgesData.sort((a, b) => a.distance - b.distance)
+  if (polygonEdgesData.length) {
+    //intersection between a line orthogonal to the line and one of the polygon edges
+    return [polygonEdgesData[0].M, polygonEdgesData[0].N]
+  } else {
+    //get the polygon outline closest to the line and its projection on the line
+    const polygonOutline = polygon.outline
+    const distances = polygonOutline.map((p) => {
+      return line.getHorizontalDistanceToPoint(p)
+    })
+    const minDistance = Math.min(...distances)
+    const minIndex = distances.indexOf(minDistance)
+    const minPoint = polygonOutline[minIndex]
+    const projectionPoint = line.getProjectedPointFromPlane(minPoint, {
+      isIncludedInSegment: true,
+      plane: projectionPlane,
+    })
+    return [projectionPoint, minPoint]
+  }
+}
+
+/**
+ * Get shortest segment between two circles
+ * @param {Circle} circle0 - First circle
+ * @param {Circle} circle1 - Second circle
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnCircle0, pointOnCircle1]
+ */
+export function getShortestSegmentCircleCircle(
+  circle0,
+  circle1,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  return [circle0.center, circle1.center]
+}
+
+/**
+ * Get shortest segment between circle and polygon
+ * @param {Circle} circle - Circle object
+ * @param {Polygon} polygon - Polygon object
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnCircle, pointOnPolygon]
+ */
+export function getShortestSegmentCirclePolygon(
+  circle,
+  polygon,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  return getShortestSegmentPointPolygon(circle.center, polygon, refPoint)
+}
+
+/**
+ * Get shortest segment between two polygons
+ * @param {Polygon} polygon0 - First polygon
+ * @param {Polygon} polygon1 - Second polygon
+ * @param {Object} refPoint - Reference point
+ * @returns {Array} [pointOnPolygon0, pointOnPolygon1]
+ */
+export function getShortestSegmentPolygonPolygon(
+  polygon0,
+  polygon1,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  const pointsP0 = polygon0.getProjectedPoints(refPoint, true)
+  const closestPoint0 = findClosestPoint(pointsP0, refPoint)
+  const pointsP1 = polygon1.getProjectedPoints(closestPoint0, true)
+  const closestPoint1 = findClosestPoint(pointsP1, refPoint)
+  return [closestPoint0, closestPoint1]
+}
+
+export function findClosestPoint(
+  points,
+  refPoint,
+  projectionPlane = defaultPlane
+) {
+  const distances = points.map((p) => getDistanceBetweenPoints(refPoint, p))
+  const minDistance = Math.min(...distances)
+  const minIndex = distances.indexOf(minDistance)
+  return points[minIndex]
+}

package/src/index.js

@@ -1,6 +1,8 @@
 export * from './coords'
 export * from './geo'
 export * from './geometry'
+export * from './geometryShortDistance'
+export * from './intersectionCheck'
 export * from './matrix'
 export * from './vector'
 export * from './snap'
@@ -14,3 +16,4 @@ export * from './spherical'
 export * from './SHPSolver'
 export * from './panelFunctions'
 export * from './stringPatchMatching'
+export * from './plane'