@eturnity/eturnity_maths 8.16.1 → 8.19.0

package/package.json

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

package/src/geometry.js

@@ -413,6 +413,45 @@ export function getPointInsideOutline(vs, firstLevelHoles = []) {
   }
   return result
 }
+export function distanceTo2DPolyline(point, polyline) {
+  let minDistance = Infinity
+  if (polyline.length < 2) {
+    throw new Error('not enough points in polyline')
+  }
+  for (let i = 0; i < polyline.length - 1; i++) {
+    let A = polyline[i]
+    let B = polyline[i + 1]
+    const distance = distanceTo2DSegment(point, A, B)
+    if (distance < minDistance) {
+      minDistance = distance
+    }
+  }
+  return minDistance
+}
+export function distanceTo2DSegment(point, A, B) {
+  const vectorAB = { x: B.x - A.x, y: B.y - A.y }
+  const vectorAP = { x: point.x - A.x, y: point.y - A.y }
+  const lengthABSquared = vectorAB.x * vectorAB.x + vectorAB.y * vectorAB.y
+  if (lengthABSquared === 0) {
+    return Math.sqrt(vectorAP.x * vectorAP.x + vectorAP.y * vectorAP.y)
+  }
+  const t =
+    (vectorAP.x * vectorAB.x + vectorAP.y * vectorAB.y) / lengthABSquared
+  if (t < 0) {
+    return Math.sqrt(vectorAP.x * vectorAP.x + vectorAP.y * vectorAP.y)
+  }
+  if (t > 1) {
+    const vectorBP = { x: point.x - B.x, y: point.y - B.y }
+    return Math.sqrt(vectorBP.x * vectorBP.x + vectorBP.y * vectorBP.y)
+  }
+  const projection = {
+    x: A.x + t * vectorAB.x,
+    y: A.y + t * vectorAB.y,
+  }
+  const dx = point.x - projection.x
+  const dy = point.y - projection.y
+  return Math.sqrt(dx * dx + dy * dy)
+}
 
 export function distanceToEdge2D(M, A, B) {
   const pA = { x: A.x, y: A.y, z: 0 }

package/src/tests/geometry/distanceTo2DSegment.spec.js

@@ -0,0 +1,51 @@
+import { distanceTo2DSegment } from '../../index'
+
+describe('distanceTo2DSegment function', () => {
+  test('top middle', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 5, y: 10, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('bottom', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 5, y: -10, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('diagonal', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: -3, y: 4, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(5, 4)
+  })
+  test('point aligned with A and B', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: -10, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('point aligned with A and B right', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 20, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('AB in diagonal', () => {
+    const A = { x: 0, y: 10, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 0, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(7.07106, 4)
+  })
+  test('point and A and A', () => {
+    const A = { x: 0, y: 10, z: 0 }
+    const point = { x: 0, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, A)).toBeCloseTo(10, 4)
+  })
+  test('point vertical to B', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 10, y: 10, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+})