@eturnity/eturnity_maths 7.20.0 → 7.24.1

package/src/geometry.js

@@ -1,535 +1,534 @@
-import { polygonCloseTolerance } from "./config";
+import { polygonCloseTolerance } from './config'
 
 import {
-  addVector,
-  substractVector,
-  multiplyVector,
-  dotProduct,
-  crossProduct,
-  meanVector,
-  vectorLength,
-  normalizeVector,
-} from "./vector";
-import { inverse3x3matrix, multiplyMatrices } from "./matrix";
-import { Point } from "./objects/Point";
-import { Line } from "./objects/Line";
-import concaveman from "./lib/concaveman";
+	addVector,
+	substractVector,
+	multiplyVector,
+	dotProduct,
+	crossProduct,
+	meanVector,
+	vectorLength,
+	normalizeVector
+} from './vector'
+import { inverse3x3matrix, multiplyMatrices } from './matrix'
+import { Point } from './objects/Point'
+import { Line } from './objects/Line'
+import concaveman from './lib/concaveman'
 
 export function getConcaveOutlines(selectedPanels, onePanelOutline) {
-  let buckets = groupAdjacentObjects(selectedPanels);
-  const outlines = [];
-  for (let bucketIndex = 0; bucketIndex < buckets.length; bucketIndex++) {
-    outlines.push(
-      getConcaveOutline(
-        selectedPanels.filter((p, i) => buckets[bucketIndex].includes(i)),
-        onePanelOutline
-      )
-    );
-  }
-  return { outlines, buckets };
+	let buckets = groupAdjacentObjects(selectedPanels)
+	const outlines = []
+	for (let bucketIndex = 0; bucketIndex < buckets.length; bucketIndex++) {
+		outlines.push(
+			getConcaveOutline(
+				selectedPanels.filter((p, i) => buckets[bucketIndex].includes(i)),
+				onePanelOutline
+			)
+		)
+	}
+	return { outlines, buckets }
 }
 
 export function getConcaveOutline(selectedPanels, onePanelOutline) {
-  const points = selectedPanels.reduce((acc, cur) => {
-    acc.push(...cur.outline.map((p) => [p.x, p.y]));
-    return acc;
-  }, []);
-  let AB = getDistanceBetweenPoints(onePanelOutline[0], onePanelOutline[1]);
-  let AD = getDistanceBetweenPoints(onePanelOutline[0], onePanelOutline[3]);
-  let longEdgeLength = Math.max(AB, AD) + 100;
-  var concaveResult = concaveman(points, 1, longEdgeLength);
-  concaveResult.pop();
-  let moduleFieldOutline = concaveResult.map((p) => {
-    return {
-      x: p[0],
-      y: p[1],
-      z: 0,
-    };
-  });
-  //remove aligned nodes
-  moduleFieldOutline = simplifyOutline(moduleFieldOutline);
-  return moduleFieldOutline;
+	const points = selectedPanels.reduce((acc, cur) => {
+		acc.push(...cur.outline.map((p) => [p.x, p.y]))
+		return acc
+	}, [])
+	let AB = getDistanceBetweenPoints(onePanelOutline[0], onePanelOutline[1])
+	let AD = getDistanceBetweenPoints(onePanelOutline[0], onePanelOutline[3])
+	let longEdgeLength = Math.max(AB, AD) + 100
+	var concaveResult = concaveman(points, 1, longEdgeLength)
+	concaveResult.pop()
+	let moduleFieldOutline = concaveResult.map((p) => {
+		return {
+			x: p[0],
+			y: p[1],
+			z: 0
+		}
+	})
+	//remove aligned nodes
+	moduleFieldOutline = simplifyOutline(moduleFieldOutline)
+	return moduleFieldOutline
 }
 export function simplifyOutline(initialOutline) {
-  const simplifiedOutline = [];
-  initialOutline.forEach((p, k, outline) => {
-    let len = outline.length;
-    let A = outline[(k - 1 + len) % len];
-    let B = outline[(k + 1) % len];
-    let M = outline[k % len];
-    if (!isInsideEdge2D(M, A, B)) {
-      simplifiedOutline.push(M);
-    }
-  });
-  return simplifiedOutline;
+	const simplifiedOutline = []
+	initialOutline.forEach((p, k, outline) => {
+		let len = outline.length
+		let A = outline[(k - 1 + len) % len]
+		let B = outline[(k + 1) % len]
+		let M = outline[k % len]
+		if (!isInsideEdge2D(M, A, B)) {
+			simplifiedOutline.push(M)
+		}
+	})
+	return simplifiedOutline
 }
 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;
+	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;
+	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, "");
+	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, "");
+	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, C.z + B.z - A.z);
-  return new Line(C, D, "");
+	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, C.z + B.z - A.z)
+	return new Line(C, D, '')
 }
 
 export function getDataAboutTwo3DLines(A, u, B, v) {
-  let w = crossProduct(u, v);
-  let m = [
-    [u.x, v.x, w.x],
-    [u.y, v.y, w.y],
-    [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 distance = get3DDistanceBetweenPoints(M, N);
-  return { m, mInv, M, N, A, B, u, v, w, distance, t1, t2, t3 };
+	let w = crossProduct(u, v)
+	let m = [
+		[u.x, v.x, w.x],
+		[u.y, v.y, w.y],
+		[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 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),
-    y: -Math.cos((angle * Math.PI) / 180),
-  };
+	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;
+	const distance = Math.hypot(
+		firstPoint.x - secondPoint.x,
+		firstPoint.y - secondPoint.y
+	)
+	return distance
 }
 
 export function get3DDistanceBetweenPoints(firstPoint, secondPoint) {
-  const distance = Math.hypot(
-    firstPoint.x - secondPoint.x,
-    firstPoint.y - secondPoint.y,
-    firstPoint.z - secondPoint.z
-  );
-  return distance;
+	const distance = Math.hypot(
+		firstPoint.x - secondPoint.x,
+		firstPoint.y - secondPoint.y,
+		firstPoint.z - secondPoint.z
+	)
+	return distance
 }
 
 export function getDegreeVectors(u, v) {
-  return getDegree(u, { x: 0, y: 0, z: 0 }, v);
+	return getDegree(u, { x: 0, y: 0, z: 0 }, v)
 }
 
 export function getDegree(H, I, J) {
-  let distanceFunction = get3DDistanceBetweenPoints;
-  if (
-    H.z == undefined ||
+	let distanceFunction = get3DDistanceBetweenPoints
+	if (
+		H.z == undefined ||
     I.z == undefined ||
     J.z == undefined ||
     isNaN(H.z) ||
     isNaN(I.z) ||
     isNaN(J.z)
-  ) {
-    distanceFunction = getDistanceBetweenPoints;
-  }
-  const a = distanceFunction(H, I);
-  const b = distanceFunction(I, J);
-  const c = distanceFunction(H, J);
+	) {
+		distanceFunction = getDistanceBetweenPoints
+	}
+	const a = distanceFunction(H, I)
+	const b = distanceFunction(I, J)
+	const c = distanceFunction(H, J)
 
-  let angle =
-    (Math.acos((a * a + b * b - c * c) / (2 * a * b)) * 180) / Math.PI;
+	let angle = (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;
-  }
+	//if 3 points are aligned
+	if (isNaN(angle)) {
+		angle = c < a ? 0 : 180
+	}
 
-  let sgn = -Math.sign(
-    crossProduct(substractVector(H, I), substractVector(J, I)).z
-  );
-  angle = sgn * angle;
-  return angle;
+	let sgn = -Math.sign(
+		crossProduct(substractVector(H, I), substractVector(J, I)).z
+	)
+	angle = sgn * angle
+	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,
-  };
+	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;
+	return A.x == B.x && A.y == B.y && A.z == B.z
 }
 export function isAlmostSamePoint3D(A, B, tolerance) {
-  return (
-    Math.abs(A.x - B.x) < tolerance &&
+	return (
+		Math.abs(A.x - B.x) < tolerance &&
     Math.abs(A.y - B.y) < tolerance &&
     Math.abs(A.z - B.z) < tolerance
-  );
+	)
 }
 export function isSamePoint2D(A, B) {
-  return A.x == B.x && A.y == B.y;
+	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;
+	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;
+	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 =
+	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[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;
+    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;
+	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 isAlmostSameSegment3D(seg_0, seg_1, tolerance) {
-  let check_1 =
+	let check_1 =
     isAlmostSamePoint3D(seg_0[0], seg_1[0], tolerance) &&
-    isAlmostSamePoint3D(seg_0[1], seg_1[1], tolerance);
-  let check_2 =
+    isAlmostSamePoint3D(seg_0[1], seg_1[1], tolerance)
+	let check_2 =
     isAlmostSamePoint3D(seg_0[0], seg_1[1], tolerance) &&
-    isAlmostSamePoint3D(seg_0[1], seg_1[0], tolerance);
-  return check_1 || check_2;
+    isAlmostSamePoint3D(seg_0[1], seg_1[0], tolerance)
+	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;
+	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;
-  }
+	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;
+	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;
+	//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;
-  }
+	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;
-  }
+	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 polygonsHaveSame2DOutline(outline1, outline2) {
-  let sameLength = outline1.length == outline2.length;
-  return (
-    sameLength &&
+	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 polygonsHaveSame3DOutline(outline1, outline2) {
-  let sameLength = outline1.length == outline2.length;
-  return (
-    sameLength &&
+	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;
+	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);
+	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
+	// 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;
+	const x = point.x
+	const y = point.y
 
-  let inside = false;
+	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;
+	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;
+		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));
+	return innerOutline.every((p) => isInsidePolygon(p, outterOutline))
 }
 
 export function get3PathsFromPolyAndSplittingPath(
-  outline,
-  splittingPath,
-  mmPerPx
+	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) <
+	//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 =
+	)
+	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];
+      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 &&
+	//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 &&
@@ -537,474 +536,576 @@ export function get2PolygonsOutlineFrom3Paths(path1, path2, path3) {
       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];
+		)
+	) {
+		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) {
-  function zValueNotDefined(P) {
-    return P.z == undefined || isNaN(P.z);
-  }
-  //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 = {};
-  if (zValueNotDefined(M) || zValueNotDefined(A) || zValueNotDefined(B)) {
-    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;
-    }
-  }
-  //projection of the point to the line
-  return P;
+	function zValueNotDefined(P) {
+		return P.z == undefined || isNaN(P.z)
+	}
+	//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 = {}
+	if (zValueNotDefined(M) || zValueNotDefined(A) || zValueNotDefined(B)) {
+		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
+		}
+	}
+	//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,
-  };
+	return {
+		...point,
+		x: point.x + vector.x,
+		y: point.y + vector.y,
+		z: point.z
+	}
 }
 
 export function normalizedVectorTowardInsideAngle(H, I, J) {
-  const IH = normalizeVector(substractVector(H, I));
-  const IJ = normalizeVector(substractVector(J, I));
-  const res = normalizeVector(addVector(IH, IJ));
-  return res;
+	const IH = normalizeVector(substractVector(H, I))
+	const IJ = normalizeVector(substractVector(J, I))
+	const sumVector = addVector(IH, IJ)
+	let res = {}
+	if (vectorLength(sumVector) < 0.1) {
+		res.x = IJ.y
+		res.y = -IJ.x
+		res.z = 0
+	} else {
+		res = normalizeVector(sumVector)
+	}
+	return res
 }
 
 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;
+	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];
+	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);
-  }
+	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;
+	const AB = substractVector(B, A)
+	const BC = substractVector(C, B)
+	const normalVector = normalizeVector(crossProduct(AB, BC))
+	return normalVector
 }
 export function normalVectorWithDirectionAndIncline(direction, incline) {
-  return {
-    x:
+	return {
+		x:
       Math.sin((direction * Math.PI) / 180) *
       Math.sin((incline * Math.PI) / 180),
-    y:
+		y:
       Math.cos((direction * Math.PI) / 180) *
       Math.sin((incline * Math.PI) / 180),
-    z: Math.cos((incline * Math.PI) / 180),
-  };
+		z: Math.cos((incline * Math.PI) / 180)
+	}
 }
 export function inclineWithNormalVector(normalVector) {
-  const angleRad = Math.acos(dotProduct(normalVector, { x: 0, y: 0, z: 1 }));
-  const angleDeg = (angleRad * 180) / Math.PI;
-  return angleDeg;
+	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;
+	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;
+	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;
+	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;
+	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;
-  }
+		total += addX * addY * 0.5
+		total -= subX * subY * 0.5
+	}
 
-  return Math.abs(total);
+	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;
+	//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;
+	//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
 }
 export function groupAdjacentObjects(objects) {
-  if (!objects || objects.length == 0) return [];
-  // objects with 2D indexes
-  // Check if the objects form an adjacent group
-  let numberOfObjects = objects.length;
-  let indexList = Array.from({ length: numberOfObjects }, (e, i) => i);
-  let buckets = [];
-  let inBucket = 0;
-  while (inBucket < objects.length) {
-    let detatchedIndex = indexList.find((i) => !buckets.flat().includes(i));
-    if (detatchedIndex == null) break;
-    let queue = [detatchedIndex];
-    let visited = [];
-    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);
-      }
-    }
-    inBucket += visited.length;
-    buckets.push(visited);
-  }
-
-  return buckets;
+	if (!objects || objects.length == 0) return []
+	// objects with 2D indexes
+	// Check if the objects form an adjacent group
+	let numberOfObjects = objects.length
+	let indexList = Array.from({ length: numberOfObjects }, (e, i) => i)
+	let buckets = []
+	let inBucket = 0
+	while (inBucket < objects.length) {
+		let detatchedIndex = indexList.find((i) => !buckets.flat().includes(i))
+		if (detatchedIndex == null) break
+		let queue = [detatchedIndex]
+		let visited = []
+		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)
+			}
+		}
+		inBucket += visited.length
+		buckets.push(visited)
+	}
+
+	return buckets
 }
 // Function to check if two indexes are adjacent
 export function areAdjacent(objects) {
-  if (!objects || objects.length == 0) return false;
-  // 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;
+	if (!objects || objects.length == 0) return false
+	// 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
+	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 =
+	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;
+      	? 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]);
-    const product = crossProduct(v_current, v_next);
-    const sgn = product.z > 0 ? -1 : 1;
-    area += 0.5 * sgn * vectorLength(product);
-  }
-  return Math.abs(area);
+	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])
+		const product = crossProduct(v_current, v_next)
+		const sgn = product.z > 0 ? -1 : 1
+		area += 0.5 * sgn * vectorLength(product)
+	}
+	return Math.abs(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;
+	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 };
+	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 }
 }
 export function triangleArea(A, B, C) {
-  var AB = substractVector(B, A);
-  var AC = substractVector(C, A);
-  const product = crossProduct(AB, AC);
-  let area = vectorLength(product) / 2;
-  return area;
-}
-export function getIndexesOfBiggestTrangle(points) {
-  return getIndexesOfBiggestTrangleWithFixedIndexes(points, []);
-}
-export function getIndexesOfBiggestTrangleWithFixedIndexes(
-  points,
-  fixedIndexes
+	var AB = substractVector(B, A)
+	var AC = substractVector(C, A)
+	const product = crossProduct(AB, AC)
+	let area = vectorLength(product) / 2
+	return area
+}
+export function getIndexesOfBiggestTriangle(points) {
+	return getIndexesOfBiggestTriangleWithFixedIndexes(points, [])
+}
+export function arrayIntersection(array1, array2) {
+	return array1.filter((value) => array2.includes(value))
+}
+export function getIndexesOfBiggestTriangleWithFixedIndexes(
+	points,
+	fixedIndexes,
+	preferedIndexes = [],
+	areaMinFactor = 4
+) {
+	if (points.length < 3) {
+		throw new Error('not enough points to make a triangle')
+	}
+	fixedIndexes = [...new Set(fixedIndexes)]
+	if (fixedIndexes.length >= 3) {
+		return getIndexesOfBiggestTriangleWithFixedIndexes(points, [], fixedIndexes)
+	}
+	let minArea = calculateArea(points) / areaMinFactor
+	let preferedAndFixedIndexes = [...fixedIndexes, ...preferedIndexes]
+	preferedAndFixedIndexes = [...new Set(preferedAndFixedIndexes)]
+	let maxArea = minArea
+	let maxNumberOfPreferedOrFixedIndexes = -1
+	let maxTriangle = [0, 1, 2]
+	let triangleFound = false
+	for (let i = 0; i < points.length - 2; i++) {
+		for (let j = i + 1; j < points.length - 1; j++) {
+			for (let k = j + 1; k < points.length; k++) {
+				if (
+					arrayIntersection(fixedIndexes, [i, j, k]).length ==
+          fixedIndexes.length
+				) {
+					const numberOfPreferedOrFixedIndexes = arrayIntersection(
+						preferedAndFixedIndexes,
+						[i, j, k]
+					).length
+					if (
+						numberOfPreferedOrFixedIndexes >= maxNumberOfPreferedOrFixedIndexes
+					) {
+						let area = triangleArea(points[i], points[j], points[k])
+						if (
+							area >= minArea &&
+              numberOfPreferedOrFixedIndexes > maxNumberOfPreferedOrFixedIndexes
+						) {
+							maxArea = minArea
+						}
+						if (area >= maxArea) {
+							triangleFound = true
+							maxArea = area
+							maxNumberOfPreferedOrFixedIndexes = numberOfPreferedOrFixedIndexes
+							maxTriangle = [i, j, k]
+						}
+					}
+				}
+			}
+		}
+	}
+	if (!triangleFound && areaMinFactor <= 8) {
+		areaMinFactor += 2
+		return getIndexesOfBiggestTriangleWithFixedIndexes(
+			points,
+			fixedIndexes,
+			preferedIndexes,
+			areaMinFactor
+		)
+	}
+	return maxTriangle
+}
+export function getIndexesOfBiggestTriangleWithTwoFixedIndexes(
+	points,
+	fixedIndexes,
+	preferedIndexes = [],
+	areaMinFactor = 4
 ) {
-  if (points.length < 3) {
-    throw new Error("not enough points to make a triangle");
-    return;
-  }
-  let maxArea = -1;
-  let maxTriangle = [0, 1, 2];
-  fixedIndexes = [...new Set(...fixedIndexes)].slice(0, 3);
-  if (fixedIndexes.length == 3) {
-    return fixedIndexes;
-  }
-  for (let i = 0; i < points.length - 2; i++) {
-    if (fixedIndexes.length == 0 || fixedIndexes.includes(i)) {
-      for (let j = i + 1; j < points.length - 1; j++) {
-        if (fixedIndexes.length < 2 || fixedIndexes.includes(j)) {
-          for (let k = j + 1; k < points.length; k++) {
-            const area = triangleArea(points[i], points[j], points[k]);
-            if (area > maxArea) {
-              maxArea = area;
-              maxTriangle = [i, j, k];
-            }
-          }
-        }
-      }
-    }
-  }
-  return maxTriangle;
+	fixedIndexes = [...new Set(fixedIndexes)]
+	let preferedAndFixedIndexes = [...fixedIndexes, ...preferedIndexes]
+	preferedAndFixedIndexes = [...new Set(preferedAndFixedIndexes)]
+	if (points.length < 3 || fixedIndexes.length < 3) {
+		throw new Error('not enough points to make a triangle')
+		return
+	}
+	let minArea = calculateArea(points) / areaMinFactor
+	let maxArea = minArea
+	let maxNumberOfPreferedOrFixedIndexes = -1
+	let maxTriangle = [0, 1, 2]
+	let triangleFound = false
+	for (let i = 0; i < points.length - 2; i++) {
+		for (let j = i + 1; j < points.length - 1; j++) {
+			for (let k = j + 1; k < points.length; k++) {
+				if (arrayIntersection(fixedIndexes, [i, j, k]).length == 2) {
+					const numberOfPreferedOrFixedIndexes = arrayIntersection(
+						preferedAndFixedIndexes,
+						[i, j, k]
+					).length
+					if (
+						numberOfPreferedOrFixedIndexes >= maxNumberOfPreferedOrFixedIndexes
+					) {
+						let area = triangleArea(points[i], points[j], points[k])
+						if (
+							area >= minArea &&
+              numberOfPreferedOrFixedIndexes > maxNumberOfPreferedOrFixedIndexes
+						) {
+							maxArea = minArea
+						}
+						//give advantages to connected area
+						if (area > maxArea) {
+							triangleFound = true
+							maxArea = area
+							maxNumberOfPreferedOrFixedIndexes = numberOfPreferedOrFixedIndexes
+							maxTriangle = [i, j, k]
+						}
+					}
+				}
+			}
+		}
+	}
+	if (!triangleFound && areaMinFactor <= 8) {
+		areaMinFactor += 2
+		return getIndexesOfBiggestTriangleWithTwoFixedIndexes(
+			points,
+			fixedIndexes,
+			preferedIndexes,
+			areaMinFactor
+		)
+	}
+	return maxTriangle
 }