@eturnity/eturnity_maths 1.0.2

package/src/geometry.js

@@ -0,0 +1,760 @@
+import {
+  polygonCloseTolerance,
+} from './config'
+
+import {addVector,
+  substractVector,
+  multiplyVector,
+  dotProduct,
+  crossProduct,
+  meanVector,
+  vectorLength,
+  normalizeVector} from './vector'
+import {Point} from './objects/Point'
+import {Line} from './objects/Line'
+
+export function getSnapedValue(value, snaps, tolerance) {
+  let closeSnapsItem = snaps.reduce(
+    (acc, cur) => {
+      let distance = Math.abs(cur - value)
+      if (distance <= Math.min(tolerance, acc.distance)) {
+        acc = { value: cur, distance }
+      }
+      return acc
+    },
+    { value, distance: tolerance }
+  )
+  return closeSnapsItem.value
+}
+export function getAngleInDegFromCanvasVector(v) {
+  const angle = Math.atan2(v.y, v.x)
+  return ((angle * 180) / Math.PI + 90 + 360) % 360
+}
+export function getOrthogonalLineABPassingInB(A, B) {
+  if (isSamePoint3D(A, B)) {
+    console.error("A == B Can't make a 90° line")
+    return null
+  }
+  const C = new Point(A.x + A.y - B.y, A.y + B.x - A.x)
+  return new Line(A, C, '')
+}
+// Return orthogonal line passing by C
+export function getOrthogonalLinePassingByPoint(A, B, C) {
+  if (isSamePoint3D(A, B)) {
+    console.error("A == B Can't make a orthogonal line")
+    return null
+  }
+  const M = new Point(C.x + B.y - A.y, C.y + A.x - B.x)
+  return new Line(C, M, '')
+}
+
+export function getParallelLinePassingByPoint(A, B, C) {
+  if (isSamePoint3D(A, B)) {
+    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)
+  return new Line(C, D, '')
+}
+export function vectorFromAngleInDegCanvas(angle) {
+  return {
+    x: Math.sin((angle * Math.PI) / 180),
+    y: -Math.cos((angle * Math.PI) / 180)
+  }
+}
+export function getDistanceBetweenPoints(firstPoint, secondPoint) {
+    const distance = Math.hypot(
+      firstPoint.x - secondPoint.x,
+      firstPoint.y - secondPoint.y
+    )
+    return distance
+  }
+  
+  export function getDegree(H, I, J) {
+    const a = getDistanceBetweenPoints(H, I)
+    const b = getDistanceBetweenPoints(I, J)
+    const c = getDistanceBetweenPoints(H, J)
+  
+    let angle = Math.round(
+      (Math.acos((a * a + b * b - c * c) / (2 * a * b)) * 180) / Math.PI
+    )
+    //if 3 points are aligned
+    if (isNaN(angle)) {
+      angle = c < a ? 0 : 180
+    }
+    return angle
+  }
+  
+  export function midPoint(firstPoint, secondPoint) {
+    firstPoint.z = firstPoint.z || 0
+    secondPoint.z = secondPoint.z || 0
+    return {
+      x: (firstPoint.x + secondPoint.x) / 2,
+      y: (firstPoint.y + secondPoint.y) / 2,
+      z: (firstPoint.z + secondPoint.z) / 2
+    }
+  }
+
+  export function isSamePoint3D(A, B) {
+    return A.x == B.x && A.y == B.y && A.z == B.z
+  }
+  export function isSamePoint2D(A, B) {
+    return A.x == B.x && A.y == B.y
+  }
+  export function isAlmostSamePoint2D(A, B, tolerance) {
+    return Math.abs(A.x - B.x) < tolerance && Math.abs(A.y - B.y) < tolerance
+  }
+  export function isSameSegment2D(seg_0, seg_1) {
+    let check_1 =
+      isSamePoint2D(seg_0[0], seg_1[0]) && isSamePoint2D(seg_0[1], seg_1[1])
+    let check_2 =
+      isSamePoint2D(seg_0[0], seg_1[1]) && isSamePoint2D(seg_0[1], seg_1[0])
+    return check_1 || check_2
+  }
+  export function isAlmostSameSegment2D(seg_0, seg_1, tolerance) {
+    let check_1 =
+      isAlmostSamePoint2D(seg_0[0], seg_1[0], tolerance) &&
+      isAlmostSamePoint2D(seg_0[1], seg_1[1], tolerance)
+    let check_2 =
+      isAlmostSamePoint2D(seg_0[0], seg_1[1], tolerance) &&
+      isAlmostSamePoint2D(seg_0[1], seg_1[0], tolerance)
+    return check_1 || check_2
+  }
+  export function isSameSegment3D(seg_0, seg_1) {
+    let check_1 =
+      isSamePoint3D(seg_0[0], seg_1[0]) && isSamePoint3D(seg_0[1], seg_1[1])
+    let check_2 =
+      isSamePoint3D(seg_0[0], seg_1[1]) && isSamePoint3D(seg_0[1], seg_1[0])
+    return check_1 || check_2
+  }
+  export function isSameLine(AB, CD) {
+    if (!AB || !CD) {
+      console.error('AB or CD not defined')
+      return false
+    }
+    if (AB.type != 'line' || CD.type != 'line') {
+      return false
+    }
+    // if(AB.outline.length<2){return false}
+    // if(CD.outline.length<2){return false}
+    const A = AB.outline[0]
+    const B = AB.outline[1]
+    const C = CD.outline[0]
+    const D = CD.outline[1]
+    //is A on (CD)
+    const P = getPointOnLine(A, C, D)
+    if (getDistanceBetweenPoints(A, P) > 1) {
+      return false
+    }
+    //is B on (CD)
+    const M = getPointOnLine(B, C, D)
+    if (getDistanceBetweenPoints(B, M) > 1) {
+      return false
+    }
+  
+    return true
+  }
+  export function distance2DToPolygon(point, vs) {
+    let distance = Infinity
+    if (isInsidePolygon(point, vs)) {
+      return 0
+    } else {
+      for (let v of vs) {
+        let distanceToNode = getDistanceBetweenPoints(point, v)
+        distance = Math.min(distanceToNode, distance)
+      }
+      for (let k in vs) {
+        let A = vs[k]
+        let B = vs[(k + 1) % vs.length]
+        //M projection of point on AB line
+        if (!isSamePoint2D(A, B)) {
+          let M = getPointOnLine(point, A, B)
+          if (isInsideEdge2D(M, A, B)) {
+            distance = Math.min(distance, getDistanceBetweenPoints(point, M))
+          }
+        }
+      }
+      return distance
+    }
+  }
+  export function get2DBoundOfPolygon(vs) {
+    const bound = {
+      xMin: Infinity,
+      xMax: -Infinity,
+      yMin: Infinity,
+      yMax: -Infinity
+    }
+    for (let v of vs) {
+      bound.xMin = Math.min(bound.xMin, v.x)
+      bound.xMax = Math.max(bound.xMax, v.x)
+      bound.yMin = Math.min(bound.yMin, v.y)
+      bound.yMax = Math.max(bound.yMax, v.y)
+    }
+    return bound
+  }
+  export function getPointInsideOutline(vs, holes = []) {
+    //draw an horizontal line between top and bottom
+    const bound = get2DBoundOfPolygon(vs)
+    const y = (bound.yMax + bound.yMin) / 2
+    let xOfCrossingEdgeY = []
+    for (let index = 0; index < vs.length; index++) {
+      let nextIndex = (index + 1) % vs.length
+      const A = vs[index]
+      const B = vs[nextIndex]
+      if ((A.y <= y && B.y > y) || (A.y >= y && B.y < y)) {
+        let x = A.x + (B.x - A.x) * ((y - A.y) / (B.y - A.y))
+        xOfCrossingEdgeY.push(x)
+      }
+    }
+    if (xOfCrossingEdgeY.length < 2) {
+      console.error('not enaugh edge crossing mid cut', vs)
+      return
+    }
+    xOfCrossingEdgeY.sort((a, b) => a - b)
+    let xLeft = xOfCrossingEdgeY[0]
+    let xRight = xOfCrossingEdgeY[1]
+    //dichotomy to get point outside of holes
+    for (let hole of holes) {
+      if (isPolygonInsidePolygon(vs, hole)) {
+        return { x: (xLeft + xRight) / 2, y }
+      }
+    }
+    let t = 0.1
+    let count = 0
+    let isInside = false
+    let testPoint
+    while (count < 10 && isInside == false) {
+      count++
+      let x = xLeft + t * (xRight - xLeft)
+      testPoint = { x, y }
+      isInside = true
+      for (let hole of holes) {
+        if (isInsidePolygon(testPoint, hole)) {
+          isInside = false
+          break
+        }
+      }
+      if (isInside) {
+        return testPoint
+      } else {
+        t = (Math.cos((count * Math.PI) / 11) + 1) / 2
+      }
+    }
+    return testPoint
+  }
+  
+  export function distanceToEdge2D(M, A, B) {
+    const pA = { x: A.x, y: A.y, z: 0 }
+    const pB = { x: B.x, y: B.y, z: 0 }
+    const pM = { x: M.x, y: M.y, z: 0 }
+    const AM = substractVector(pM, pA)
+    const AB = substractVector(pB, pA)
+    const det = AM.x * AB.y - AM.y * AB.x
+    const ABLength = vectorLength(AB)
+    const AMLength = vectorLength(AM)
+    if (ABLength == 0 && isSamePoint2D(pM, pA)) {
+      return true
+    } else if (ABLength == 0 && !isSamePoint2D(pM, pA)) {
+      return false
+    } else if (AMLength == 0) {
+      return true
+    }
+    const dotP = dotProduct(AM, AB) / (ABLength * AMLength)
+    if (Math.abs(det) < 0.01 && dotP <= 1 && dotP >= 0) {
+      return true
+    } else {
+      return false
+    }
+  }
+  
+  export function isInsideEdge2D(M, A, B) {
+    const pA = { x: A.x, y: A.y, z: 0 }
+    const pB = { x: B.x, y: B.y, z: 0 }
+    const pM = { x: M.x, y: M.y, z: 0 }
+    const AM = substractVector(pM, pA)
+    const BM = substractVector(pM, pB)
+    const AB = substractVector(pB, pA)
+    const det = AM.x * AB.y - AM.y * AB.x
+    const ABLength = vectorLength(AB)
+    const BMLength = vectorLength(BM)
+    const AMLength = vectorLength(AM)
+    if (ABLength == 0 && isSamePoint2D(pM, pA)) {
+      return true
+    } else if (ABLength == 0 && !isSamePoint2D(pM, pA)) {
+      return false
+    } else if (AMLength == 0) {
+      return true
+    }
+    if (Math.abs(det) < 0.01 && BMLength < ABLength && AMLength < ABLength) {
+      return true
+    } else {
+      return false
+    }
+  }
+  
+  export function polygonsHasSame2DOutline(outline1, outline2) {
+    let sameLength = outline1.length == outline2.length
+    return (
+      sameLength &&
+      outline1.every((p) => outline2.find((v) => v.x == p.x && v.y == p.y)) &&
+      outline2.every((p) => outline1.find((v) => v.x == p.x && v.y == p.y))
+    )
+  }
+  
+  export function isOnBorderOfPolygon(point, vs) {
+    let inside = false
+    for (let i = 0, j = vs.length - 1; i < vs.length; j = i++) {
+      if (isInsideEdge2D(point, vs[i], vs[j])) {
+        inside = true
+      }
+    }
+    return inside
+  }
+  
+  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
+  
+    const x = point.x
+    const y = point.y
+  
+    let inside = false
+  
+    for (let i = 0, j = vs.length - 1; i < vs.length; j = i++) {
+      const xi = vs[i].x
+      const yi = vs[i].y
+      const xj = vs[j].x
+      const yj = vs[j].y
+  
+      const intersect =
+        yi > y !== yj > y && x <= ((xj - xi) * (y - yi)) / (yj - yi) + xi
+      if (intersect) inside = !inside
+    }
+    //if not really inside, let's check of edge
+    if (!inside) {
+      inside = isOnBorderOfPolygon(point, vs)
+    }
+    return inside
+  }
+  
+  export function isPolygonInsidePolygon(innerOutline, outterOutline) {
+    return innerOutline.every((p) => isInsidePolygon(p, outterOutline))
+  }
+  
+  export function get3PathsFromPolyAndSplittingPath(
+    outline,
+    splittingPath,
+    mmPerPx
+  ) {
+    //both outline and splittingPath are in Reality coordinate system
+  
+    //starting and ending points are defined by the splitting path
+    let startingPoint = splittingPath[0]
+    let endingPoint = splittingPath[splittingPath.length - 1]
+    //We then identify which polygon vertex index is link to these points
+    let startingIndex = outline.findIndex(
+      (p) =>
+        getDistanceBetweenPoints(startingPoint, p) <
+        polygonCloseTolerance * mmPerPx
+    )
+    let endingIndex = outline.findIndex(
+      (p) =>
+        getDistanceBetweenPoints(endingPoint, p) < polygonCloseTolerance * mmPerPx
+    )
+    //let's set altitude of every created splitting point
+    let nberSplittingPoint = splittingPath.length
+    let startingAltitude = outline[startingIndex].z
+    let endingAltitude = outline[endingIndex].z
+    for (let k = 0; k < nberSplittingPoint; k++) {
+      splittingPath[k].z =
+        ((endingAltitude - startingAltitude) * k) / nberSplittingPoint +
+        startingAltitude
+    }
+  
+    let path1 = splittingPath
+  
+    if (startingIndex > endingIndex) {
+      let tmp = startingIndex
+      startingIndex = endingIndex
+      endingIndex = tmp
+  
+      tmp = endingPoint
+      endingPoint = startingPoint
+      startingPoint = tmp
+      path1.reverse()
+    }
+  
+    let path2 = outline
+    //rotate polygon to have startingIndex point at index 0
+    //rotate "startingIndex" times to the left
+    for (let k = 0; k < startingIndex; k++) {
+      path2.push(path2.shift())
+    }
+    let path3 = path2.splice(0, 1 + endingIndex - startingIndex) // start and finish with the commun points
+    path2 = [endingPoint, ...path2, startingPoint]
+    path2.reverse()
+    return [path1, path2, path3]
+  }
+  
+  export function get2PolygonsOutlineFrom3Paths(path1, path2, path3) {
+    //check if path starts and ends at the same point
+    if (
+      !(
+        path1[0].x == path2[0].x &&
+        path2[0].x == path3[0].x &&
+        path1[0].y == path2[0].y &&
+        path2[0].y == path3[0].y &&
+        path1[path1.length - 1].x == path2[path2.length - 1].x &&
+        path2[path2.length - 1].x == path3[path3.length - 1].x &&
+        path1[path1.length - 1].y == path2[path2.length - 1].y &&
+        path2[path2.length - 1].y == path3[path3.length - 1].y
+      )
+    ) {
+      console.error('path problem')
+    }
+    let refPoint1 = midPoint(path1[0], path1[1])
+    let refPoint2 = midPoint(path2[0], path2[1])
+    let poly1 = { outline: [] }
+    let poly2 = { outline: [] }
+  
+    if (isInsidePolygon(refPoint1, [...path2, ...path3])) {
+      //path1 is inside path2 & path 3
+      path1.reverse()
+      path1.pop()
+      path1.shift()
+      poly1.outline = [...path1, ...path2]
+      poly2.outline = [...path1, ...path3]
+    } else if (isInsidePolygon(refPoint2, [...path1, ...path3])) {
+      //path2 is inside path1 & path 3
+      path2.reverse()
+      path2.pop()
+      path2.shift()
+      poly1.outline = [...path2, ...path1]
+      poly2.outline = [...path2, ...path3]
+    } else {
+      //path3 is inside path1 & path 2
+      path3.reverse()
+      path3.pop()
+      path3.shift()
+      poly1.outline = [...path3, ...path1]
+      poly2.outline = [...path3, ...path2]
+    }
+  
+    return [poly1, poly2]
+  }
+  
+  export function getPointOnLine(M, A, B) {
+    //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
+    }
+    //projection of the point to the line
+    return P
+  }
+  export function translate2D(point, vector) {
+    return {
+      ...point,
+      x: point.x + vector.x,
+      y: point.y + vector.y,
+      z: point.z
+    }
+  }
+  
+  
+  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) }
+  }
+  
+  
+  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
+    return isBetween
+  }
+  export function get3pointNotAlignedFromOutline(outline) {
+    if (outline.length < 3) {
+      return null
+    }
+    const A = outline[0]
+    const B = outline[1]
+    let C = outline[2]
+    let k = 2
+    while (k < outline.length && getDegree(A, B, C) % 180 == 0) {
+      C = outline[k]
+      k++
+    }
+    if (k == outline.length) {
+      return null
+    }
+    return [A, B, C]
+  }
+  export function getNormalVectortoEdgeTowardPolygon(A, B, outline) {
+    const AB = substractVector(B, A)
+    const ABC = get3pointNotAlignedFromOutline(outline)
+    if (!ABC) {
+      return null
+    }
+    const PolyNormalVector = getNormalVectorFrom3Points(...ABC)
+    let ABnormal = crossProduct(AB, PolyNormalVector)
+    let u = normalizeVector(ABnormal)
+    const outlineMeanPoint = meanVector(outline)
+    const M = midPoint(A, B)
+    const dotProd = dotProduct(u, substractVector(outlineMeanPoint, M))
+  
+    if (dotProd >= 0) {
+      return u
+    } else {
+      return multiplyVector(-1, u)
+    }
+  }
+  export function getNormalVectorFrom3Points(A, B, C) {
+    const AB = substractVector(B, A)
+    const BC = substractVector(C, B)
+    const normalVector = normalizeVector(crossProduct(AB, BC))
+    return normalVector
+  }
+  
+  export function inclineWithNormalVector(normalVector) {
+    const angleRad = Math.acos(dotProduct(normalVector, { x: 0, y: 0, z: 1 }))
+    const angleDeg = (angleRad * 180) / Math.PI
+    return angleDeg
+  }
+  
+  export function directionWithNormalVector(normalVector) {
+    if (normalVector.z < 0) {
+      normalVector = multiplyVector(-1, normalVector)
+    }
+    const normalVectorProjectionToGround = normalizeVector({
+      ...normalVector,
+      z: 0
+    })
+    if (isSamePoint3D(normalVectorProjectionToGround, { x: 0, y: 0, z: 0 }))
+      return 0
+  
+    const angleRad = Math.acos(
+      dotProduct(normalVectorProjectionToGround, { x: 0, y: 1, z: 0 })
+    )
+    let angleDeg = (angleRad * 180) / Math.PI
+    if (normalVectorProjectionToGround.x < 0) {
+      angleDeg = 360 - angleDeg
+    }
+    return angleDeg
+  }
+  
+  export function verticalProjectionOnPlane(p, n, o) {
+    const d = dotProduct(n, o)
+    const projectedHeight = (d - n.x * p.x - n.y * p.y) / n.z
+    const projectedPoint = { ...p, z: projectedHeight }
+    return projectedPoint
+  }
+  
+  export function calcPolygonArea(vertices) {
+    var total = 0
+  
+    for (var i = 0, l = vertices.length; i < l; i++) {
+      var addX = vertices[i].x
+      var addY = vertices[i == vertices.length - 1 ? 0 : i + 1].y
+      var subX = vertices[i == vertices.length - 1 ? 0 : i + 1].x
+      var subY = vertices[i].y
+  
+      total += addX * addY * 0.5
+      total -= subX * subY * 0.5
+    }
+  
+    return Math.abs(total)
+  }
+  
+  export function pointProjectionOnPlane(p, n, o) {
+    //formula for p', projection of p on plane defined by normalvector n passing by o
+    //p' = p - (n ⋅ (p - o)) × n
+    const pPrim = substractVector(
+      p,
+      multiplyVector(dotProduct(n, substractVector(p, o)), n)
+    )
+    return pPrim
+  }
+  
+  export function isClockWise(outline) {
+    //find smallest x and y coord
+    const length = outline.length
+    let smallest_x = Infinity
+    let smallest_y = Infinity
+    let hullIndex = null
+    outline.forEach((p, index) => {
+      if (p.x <= smallest_x) {
+        smallest_x = p.x
+        if (p.y < smallest_y) {
+          smallest_y = p.y
+          hullIndex = index
+        }
+      }
+    })
+    const B = outline[hullIndex]
+    const A = outline[(hullIndex - 1 + length) % length]
+    const C = outline[(hullIndex + 1) % length]
+    const det = (B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y)
+    return det < 0
+  }
+  
+  // Function to check if two indexes are adjacent
+  export function areAdjacent(objects) {
+    // objects with 2D indexes
+    // Check if the objects form an adjacent group
+    let visited = []
+    let queue = [0]
+  
+    while (queue.length > 0) {
+      const currentObjectIndex = queue.pop()
+      if (visited.indexOf(currentObjectIndex) == -1) {
+        //if next queued index hasn't been visited, we mark it as visited and we collect all neighbourg to queue
+        visited.push(currentObjectIndex)
+        let x = objects[currentObjectIndex].index[0]
+        let y = objects[currentObjectIndex].index[1]
+        const left = objects.findIndex(
+          (o) => o.index[0] == x - 1 && o.index[1] == y
+        )
+        const right = objects.findIndex(
+          (o) => o.index[0] == x + 1 && o.index[1] == y
+        )
+        const top = objects.findIndex(
+          (o) => o.index[0] == x && o.index[1] == y - 1
+        )
+        const bottom = objects.findIndex(
+          (o) => o.index[0] == x && o.index[1] == y + 1
+        )
+        if (left != -1 && visited.indexOf(left) == -1) queue.push(left)
+        if (right != -1 && visited.indexOf(right) == -1) queue.push(right)
+        if (top != -1 && visited.indexOf(top) == -1) queue.push(top)
+        if (bottom != -1 && visited.indexOf(bottom) == -1) queue.push(bottom)
+      }
+    }
+    return visited.length == objects.length
+  }
+  export function getMarginPoint(
+    A,
+    B,
+    C,
+    marginA,
+    marginB,
+    clockwiseNormalVector
+  ) {
+    const n = multiplyVector(
+      marginA,
+      normalizeVector(crossProduct(substractVector(B, A), clockwiseNormalVector))
+    )
+    const m = multiplyVector(
+      marginB,
+      normalizeVector(crossProduct(substractVector(C, B), clockwiseNormalVector))
+    )
+    //K=B+[(m.m-n.m)/AB.m]*AB
+    const AB = substractVector(B, A)
+    const mAB = dotProduct(AB, m)
+  
+    let K
+    if (mAB == 0) {
+      K =
+        dotProduct(m, m) != 0
+          ? addVector(B, m)
+          : dotProduct(n, n) != 0
+          ? addVector(B, n)
+          : B
+    } else {
+      const mm = dotProduct(m, m)
+      const nm = dotProduct(n, m)
+      const lambda = (mm - nm) / mAB
+      K = addVector(addVector(B, n), multiplyVector(lambda, AB))
+    }
+    return K
+  }
+  export function calculateArea(vertices) {
+    var n = vertices.length
+    var area = 0
+    for (var i = 0; i < n; i++) {
+      var v_current = substractVector(vertices[i], vertices[0])
+      var v_next = substractVector(vertices[(i + 1) % n], vertices[0])
+      area += 0.5 * vectorLength(crossProduct(v_current, v_next))
+    }
+    return area
+  }
+  
+  export function hasNaN(arr) {
+    for (let i = 0; i < arr.length; i++) {
+      // check if array value is false or NaN
+      if (Number.isNaN(arr[i])) {
+        return true
+      }
+    }
+    return false
+  }
+  
+  
+  export function calculatePositionSubHandle(polygon, i, mmPerPx) {
+    const outline = polygon.outline
+    const length = outline.length
+  
+    const h = (i - 1 + length) % length
+    const j = (i + 1) % length
+  
+    //calculation of the angle where we need to insert the handle.
+    const IH_angle = Math.atan2(
+      outline[h].y - outline[i].y,
+      outline[h].x - outline[i].x
+    )
+    const JI_angle = Math.atan2(
+      outline[j].y - outline[i].y,
+      outline[j].x - outline[i].x
+    )
+    const handle_angle = (IH_angle + JI_angle) / 2
+  
+    //d is the handle distance in px inside polygon vertex
+    const d = 20 * mmPerPx
+    const r = d / 4
+    let handleX = outline[i].x + d * Math.cos(handle_angle)
+    let handleY = outline[i].y + d * Math.sin(handle_angle)
+    let handleZ = outline[i].z
+  
+    //check if handle is inside the polygon, if not, change where the handle is displayed
+    const isInside = isInsidePolygon(
+      { x: handleX, y: handleY, z: handleZ },
+      outline
+    )
+    if (!isInside) {
+      handleX = outline[i].x - d * Math.cos(handle_angle)
+      handleY = outline[i].y - d * Math.sin(handle_angle)
+    }
+    return { x: handleX, y: handleY, z: outline[i].z }
+  }
+