@eturnity/eturnity_maths 7.20.0 → 7.24.0

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -1,280 +1,301 @@
 import {
-  meanVector,
-  substractVector,
-  multiplyVector,
-  addVector,
-} from "../../vector";
+	meanVector,
+	substractVector,
+	multiplyVector,
+	addVector
+} from '../../vector'
 import {
-  verticalProjectionOnPlane,
-  inclineWithNormalVector,
-  directionWithNormalVector,
-  isClockWise,
-  calculateArea,
-  getConcaveOutline,
-  normalizedVectorTowardInsideAngle,
-  isAlmostSamePoint2D,
-} from "../../geometry";
-import { maximumGapLimit, mmTolerance } from "../../config";
-import { SVD } from "svd-js";
-import { updateMarginOutlinePolygon } from "./AddMargin";
+	verticalProjectionOnPlane,
+	inclineWithNormalVector,
+	directionWithNormalVector,
+	isClockWise,
+	calculateArea,
+	getConcaveOutline,
+	normalizedVectorTowardInsideAngle,
+	isAlmostSamePoint2D
+} from '../../geometry'
+import { maximumGapLimit, mmTolerance } from '../../config'
+import { SVD } from 'svd-js'
+import { updateMarginOutlinePolygon } from './AddMargin'
 
 //This function calculate derived field from polygon outline and margin outline
 export function updateComputedGeometryState(state) {
-  state.polygons.forEach((polygon) => {
-    polygon = updateComputedGeometryPolygon(polygon);
-  });
-  return state;
+	state.polygons.forEach((polygon) => {
+		updateComputedGeometryPolygon(polygon)
+	})
+	return state
 }
 export function updateOutlineFromInclineDirection(
-  incline,
-  direction,
-  outline,
-  initialAverageHeight,
-  isRoofOnRoof = false
+	incline,
+	direction,
+	outline,
+	initialAverageHeight,
+	isRoofOnRoof = false
 ) {
-  const newNormalVector = {};
-  newNormalVector.x =
-    Math.sin((incline * Math.PI) / 180) * Math.sin((direction * Math.PI) / 180);
-  newNormalVector.y =
-    Math.sin((incline * Math.PI) / 180) * Math.cos((direction * Math.PI) / 180);
-  newNormalVector.z = Math.cos((incline * Math.PI) / 180);
-  let meanPoint = meanVector(outline);
-  meanPoint.z = initialAverageHeight;
-  let newOutline = outline.map((p) => {
-    return verticalProjectionOnPlane(p, newNormalVector, meanPoint);
-  });
-  //if some points are with negative altitude, we offset the whole roof
-  let altitudeOffset;
-  let minAltitude = Math.min(...outline.map((p) => p.z));
-  let maxAltitude = Math.max(...outline.map((p) => p.z));
-  let newMinAltitude = Math.min(...newOutline.map((p) => p.z));
-  let newMaxAltitude = Math.max(...newOutline.map((p) => p.z));
-  if (isRoofOnRoof && maxAltitude != 0) {
-    altitudeOffset = newMaxAltitude - maxAltitude;
-  } else {
-    altitudeOffset = newMinAltitude - minAltitude;
-  }
-  newOutline.forEach((p) => (p.z -= altitudeOffset));
+	const newNormalVector = {}
+	newNormalVector.x =
+    Math.sin((incline * Math.PI) / 180) * Math.sin((direction * Math.PI) / 180)
+	newNormalVector.y =
+    Math.sin((incline * Math.PI) / 180) * Math.cos((direction * Math.PI) / 180)
+	newNormalVector.z = Math.cos((incline * Math.PI) / 180)
+	let meanPoint = meanVector(outline)
+	meanPoint.z = initialAverageHeight
+	let newOutline = outline.map((p) => {
+		return verticalProjectionOnPlane(p, newNormalVector, meanPoint)
+	})
+	//if some points are with negative altitude, we offset the whole roof
+	let altitudeOffset
+	let minAltitude = Math.min(...outline.map((p) => p.z))
+	let maxAltitude = Math.max(...outline.map((p) => p.z))
+	let newMinAltitude = Math.min(...newOutline.map((p) => p.z))
+	let newMaxAltitude = Math.max(...newOutline.map((p) => p.z))
+	if (isRoofOnRoof && maxAltitude != 0) {
+		altitudeOffset = newMaxAltitude - maxAltitude
+	} else {
+		altitudeOffset = newMinAltitude - minAltitude
+	}
+	newOutline.forEach((p) => (p.z -= altitudeOffset))
 
-  //if some points are with altitude>50000, we limit those points
-  newOutline.forEach((p) => (p.z = Math.max(0, Math.min(p.z, 50000))));
+	//if some points are with altitude>50000, we limit those points
+	newOutline.forEach((p) => (p.z = Math.max(0, Math.min(p.z, 50000))))
 
-  return newOutline;
+	return newOutline
 }
 export function updateComputedGeometryPolygon(polygon) {
-  if (!["roof", "obstacle", "moduleField"].includes(polygon.layer)) {
-    return polygon;
-  }
-  if (
-    polygon.outline.length > 0 &&
-    isAlmostSamePoint2D(
-      polygon.outline[0],
-      polygon.outline[polygon.outline.length - 1],
-      10
-    )
-  ) {
-    polygon.outline.pop();
-  }
-  polygon.outline = calculateValidOutlineFromPolygon(polygon.outline);
-  const {
-    projectedOutline,
-    maximumGap,
-    normalVector,
-    meanPoint,
-    incline,
-    direction,
-  } = calculateBestFittingPlanePolygon(polygon.outline);
-  polygon.flatOutline = projectedOutline;
-  polygon.maximumGap = maximumGap;
-  polygon.isFlat = maximumGap < maximumGapLimit;
-  polygon.normalVector = normalVector;
-  polygon.meanPoint = meanPoint;
-  polygon.incline = incline;
-  polygon.direction = direction;
-  polygon.area = calculateArea(polygon.flatOutline) / 1000000;
-  polygon.isClockwise = isClockWise(polygon.outline);
-  polygon = updateMarginOutlinePolygon(polygon);
-  if (polygon.layer == "moduleField") {
-    let trimedOutline = [];
-    if (polygon.panels.length > 0) {
-      trimedOutline = getConcaveOutline(
-        polygon.panels,
-        polygon.panels[0].outline
-      );
-      trimedOutline = trimedOutline.map((p) => {
-        return {
-          x: p.x,
-          y: p.y,
-          z: verticalProjectionOnPlane(
-            p,
-            polygon.roof.normalVector,
-            polygon.roof.flatOutline[0]
-          ).z,
-        };
-      });
-    }
-    polygon.trimedOutline = trimedOutline;
-  }
-  return polygon;
+	if (!['roof', 'obstacle', 'moduleField'].includes(polygon.layer)) {
+		return polygon
+	}
+	let newOutline = [...polygon.outline]
+	if (
+		newOutline.length > 0 &&
+    isAlmostSamePoint2D(newOutline[0], newOutline[newOutline.length - 1], 10)
+	) {
+		console.log(
+			'Outline warning: first and last points of outline not far enough:',
+			newOutline
+		)
+		newOutline.pop()
+	}
+	newOutline = calculateValidOutlineFromPolygon(newOutline)
+
+	if (newOutline.length < 3) {
+		throw new Error('outline not valid')
+	}
+	polygon.outline = newOutline
+	const {
+		projectedOutline,
+		maximumGap,
+		normalVector,
+		meanPoint,
+		incline,
+		direction
+	} = calculateBestFittingPlanePolygon(polygon.outline)
+	polygon.flatOutline = projectedOutline
+	polygon.maximumGap = maximumGap
+	polygon.isFlat = maximumGap < maximumGapLimit
+	polygon.normalVector = normalVector
+	polygon.meanPoint = meanPoint
+	polygon.incline = incline
+	polygon.direction = direction
+	polygon.area = calculateArea(polygon.flatOutline) / 1000000
+	polygon.isClockwise = isClockWise(polygon.outline)
+	polygon = updateMarginOutlinePolygon(polygon)
+	if (polygon.layer == 'moduleField') {
+		let trimedOutline = []
+		if (polygon.panels.length > 0) {
+			trimedOutline = getConcaveOutline(
+				polygon.panels,
+				polygon.panels[0].outline
+			)
+			trimedOutline = trimedOutline.map((p) => {
+				return {
+					x: p.x,
+					y: p.y,
+					z: verticalProjectionOnPlane(
+						p,
+						polygon.roof.normalVector,
+						polygon.roof.flatOutline[0]
+					).z
+				}
+			})
+		}
+		polygon.trimedOutline = trimedOutline
+	}
+	return polygon
 }
 export function calculateValidOutlineFromPolygon(outline) {
-  //check if two nodes are same
-  const nodeIndexToSplit = [];
-  const nodesToRemove = [];
-  for (let k = 0; k < outline.length - 1; k++) {
-    for (let i = k + 1; i < outline.length; i++) {
-      if (isAlmostSamePoint2D(outline[k], outline[i], 2 * mmTolerance)) {
-        if (i == k + 1) {
-          nodesToRemove.push(i);
-        } else {
-          nodeIndexToSplit.push([k, i]);
-        }
-      }
-    }
-  }
+	//check if two nodes are same
+	outline = [...outline]
+	const nodeIndexToSplit = []
+	const nodesToRemove = []
+	for (let k = 0; k < outline.length - 1; k++) {
+		for (let i = k + 1; i < outline.length; i++) {
+			if (isAlmostSamePoint2D(outline[k], outline[i], 2 * mmTolerance)) {
+				if (i == k + 1) {
+					nodesToRemove.push(i)
+				} else {
+					nodeIndexToSplit.push([k, i])
+				}
+			}
+		}
+	}
 
-  for (let coupleToSplit of nodeIndexToSplit) {
-    const A = outline[(coupleToSplit[0] - 1 + outline.length) % outline.length];
-    const B = outline[coupleToSplit[0]];
-    const C = outline[(coupleToSplit[0] + 1) % outline.length];
-    const D = outline[(coupleToSplit[1] - 1 + outline.length) % outline.length];
-    const E = outline[coupleToSplit[1]];
-    const F = outline[(coupleToSplit[1] + 1) % outline.length];
-    let u = normalizedVectorTowardInsideAngle(A, B, C);
-    let v = normalizedVectorTowardInsideAngle(D, E, F);
+	for (let coupleToSplit of nodeIndexToSplit) {
+		const A = outline[(coupleToSplit[0] - 1 + outline.length) % outline.length]
+		const B = outline[coupleToSplit[0]]
+		const C = outline[(coupleToSplit[0] + 1) % outline.length]
+		const D = outline[(coupleToSplit[1] - 1 + outline.length) % outline.length]
+		const E = outline[coupleToSplit[1]]
+		const F = outline[(coupleToSplit[1] + 1) % outline.length]
+		let u = normalizedVectorTowardInsideAngle(A, B, C)
+		let v = normalizedVectorTowardInsideAngle(D, E, F)
 
-    outline[coupleToSplit[0]] = {
-      ...outline[coupleToSplit[0]],
-      ...addVector(multiplyVector(-mmTolerance, u), B),
-      z: outline[coupleToSplit[0]].z,
-    };
-    outline[coupleToSplit[1]] = {
-      ...outline[coupleToSplit[1]],
-      ...addVector(multiplyVector(mmTolerance, v), E),
-      z: outline[coupleToSplit[1]].z,
-    };
-  }
-  for (let index = nodesToRemove.length - 1; index >= 0; index--) {
-    outline.splice(nodesToRemove[index], 1);
-  }
-  return outline;
+		outline[coupleToSplit[0]] = {
+			...outline[coupleToSplit[0]],
+			...addVector(multiplyVector(-mmTolerance, u), B),
+			z: outline[coupleToSplit[0]].z
+		}
+		outline[coupleToSplit[1]] = {
+			...outline[coupleToSplit[1]],
+			...addVector(multiplyVector(mmTolerance, v), E),
+			z: outline[coupleToSplit[1]].z
+		}
+	}
+	for (let index = nodesToRemove.length - 1; index >= 0; index--) {
+		outline.splice(nodesToRemove[index], 1)
+	}
+	if (nodeIndexToSplit.length) {
+		console.log(
+			'two nodes of the outline are too close one to another:',
+			nodeIndexToSplit,
+			outline,
+			' - tolerance:',
+			2 * mmTolerance,
+			'mm'
+		)
+	}
+	if (nodesToRemove.length) {
+		console.log(
+			'two consecutive nodes of the outline are too close one to another:',
+			nodesToRemove,
+			outline,
+			' - tolerance:',
+			2 * mmTolerance,
+			'mm'
+		)
+	}
+	return outline
 }
 
 export function calculateBestFittingPlanePolygon(fullOutline) {
-  if (fullOutline.length < 3) {
-    return null;
-  }
-  let isIncludingAllNodes = false;
-  let outline = fullOutline;
-  if (outline.length < 3) {
-    isIncludingAllNodes = true;
-    outline = fullOutline;
-  }
-  const meanPoint = meanVector(outline);
+	if (fullOutline.length < 3 || fullOutline.some((p) => isNaN(p.z))) {
+		return null
+	}
+	let outline = fullOutline
+	if (outline.length < 3) {
+		outline = fullOutline
+	}
+	const meanPoint = meanVector(outline)
 
-  const centralizedOutline = outline.map((p) => substractVector(p, meanPoint));
-  const a = centralizedOutline.map((p) => [p.x, p.y, p.z]);
+	const centralizedOutline = outline.map((p) => substractVector(p, meanPoint))
+	const a = centralizedOutline.map((p) => [p.x, p.y, p.z])
 
-  let { v, q } = SVD(a, false);
-  let vt = [[], [], []];
-  for (let i in v) {
-    for (let j in v[i]) {
-      vt[j][i] = v[i][j];
-    }
-  }
-  v = vt;
-  let normalVectorIndex = 0;
-  for (let index in q) {
-    if (!isNaN(q[index]) && q[index] < q[normalVectorIndex]) {
-      normalVectorIndex = index;
-    }
-  }
-  let normalVectorArray = v[normalVectorIndex];
-  let normalVector = { x: 0, y: 0, z: 1 };
-  if (!normalVectorArray) {
-    console.error(
-      "no normalVector found for:q",
-      q,
-      "v",
-      v,
-      "meanPoint",
-      meanPoint,
-      "a",
-      a,
-      "normal index",
-      normalVectorIndex,
-      "v",
-      v,
-      "outline",
-      outline
-    );
-  } else {
-    normalVector.x = normalVectorArray[0];
-    normalVector.y = normalVectorArray[1];
-    normalVector.z = normalVectorArray[2];
-  }
+	let { v, q } = SVD(a, false)
+	let vt = [[], [], []]
+	for (let i in v) {
+		for (let j in v[i]) {
+			vt[j][i] = v[i][j]
+		}
+	}
+	v = vt
+	let normalVectorIndex = 0
+	for (let index in q) {
+		if (!isNaN(q[index]) && q[index] < q[normalVectorIndex]) {
+			normalVectorIndex = index
+		}
+	}
+	let normalVectorArray = v[normalVectorIndex]
+	let normalVector = { x: 0, y: 0, z: 1 }
+	if (!normalVectorArray || isNaN(normalVectorArray[0])) {
+		console.error(
+			'no normalVector found for:q',
+			q,
+			'v',
+			v,
+			'meanPoint',
+			meanPoint,
+			'a',
+			a,
+			'normal index',
+			normalVectorIndex,
+			'v',
+			v,
+			'outline',
+			outline
+		)
+	} else {
+		normalVector.x = normalVectorArray[0]
+		normalVector.y = normalVectorArray[1]
+		normalVector.z = normalVectorArray[2]
+	}
 
-  if (normalVector.z < 0) {
-    normalVector = multiplyVector(-1, normalVector);
-  }
-  //gard to prevent crazy inclinaison roof
-  if (normalVector.z < 0.1) {
-    normalVector = { x: 0, y: 0, z: 1 };
-  }
-  //plane equation is ax+by+cz=d
-  //where normalvector=(a,b,c)
-  //let's calculate d knowing our plane passes by the point with the
-  const projectedOutline = fullOutline.map((p) => {
-    const proj = verticalProjectionOnPlane(p, normalVector, meanPoint);
-    return {
-      x: proj.x,
-      y: proj.y,
-      z: Math.max(0, Math.min(50000, proj.z)),
-    };
-  });
-  const maximumGap = Math.max(
-    ...fullOutline.map((p, index) => {
-      let gap = Math.abs(p.z - projectedOutline[index].z);
-      return gap;
-    })
-  );
-  //let's find the the biggest positive gap to reposition the plan passing by this point in order to have an always visible plane
+	if (normalVector.z < 0) {
+		normalVector = multiplyVector(-1, normalVector)
+	}
+	//gard to prevent crazy inclinaison roof
+	if (normalVector.z < 0.1) {
+		normalVector = { x: 0, y: 0, z: 1 }
+	}
+	//plane equation is ax+by+cz=d
+	//where normalvector=(a,b,c)
+	//let's calculate d knowing our plane passes by the point with the
+	const projectedOutline = fullOutline.map((p) => {
+		const proj = verticalProjectionOnPlane(p, normalVector, meanPoint)
+		return {
+			x: proj.x,
+			y: proj.y,
+			z: Math.max(0, Math.min(50000, proj.z))
+		}
+	})
+	const maximumGap = Math.max(
+		...fullOutline.map((p, index) => {
+			let gap = Math.abs(p.z - projectedOutline[index].z)
+			return gap
+		})
+	)
+	//let's find the the biggest positive gap to reposition the plan passing by this point in order to have an always visible plane
 
-  let biggestPositivGap = Math.max(
-    ...fullOutline.map((p, index) =>
-      p.selected && !isIncludingAllNodes ? 0 : p.z - projectedOutline[index].z
-    )
-  );
-  projectedOutline.forEach((p) => (p.z += biggestPositivGap));
+	let biggestPositivGap = Math.max(
+		...fullOutline.map((p, index) => p.z - projectedOutline[index].z)
+	)
+	projectedOutline.forEach((p) => (p.z += biggestPositivGap))
 
-  //if less than 3 unselected node=>flat roof on top.
-  const biggestAbsoluteGap = Math.max(
-    ...fullOutline.map((p, index) =>
-      p.selected ? 0 : Math.abs(p.z - projectedOutline[index].z)
-    )
-  );
-  for (let index in fullOutline) {
-    let p = fullOutline[index];
-    let hasWarning =
+	//if less than 3 unselected node=>flat roof on top.
+	const biggestAbsoluteGap = Math.max(
+		...fullOutline.map((p, index) => Math.abs(p.z - projectedOutline[index].z))
+	)
+	for (let index in fullOutline) {
+		let p = fullOutline[index]
+		let hasWarning =
       Math.abs(p.z - projectedOutline[index].z) == biggestAbsoluteGap &&
-      biggestAbsoluteGap > maximumGapLimit;
-    //I add warning if hasWarning and I remove it if shift is smaller then maxGapLimit. Otherwise, I do not change anything
-    p.hasWarning = hasWarning
-      ? hasWarning
-      : Math.abs(p.z - projectedOutline[index].z) < maximumGapLimit
-      ? false
-      : p.hasWarning;
-  }
+      biggestAbsoluteGap > maximumGapLimit
+		//I add warning if hasWarning and I remove it if shift is smaller then maxGapLimit. Otherwise, I do not change anything
+		p.hasWarning = hasWarning
+			? hasWarning
+			: Math.abs(p.z - projectedOutline[index].z) < maximumGapLimit
+				? false
+				: p.hasWarning
+	}
 
-  //set warning to the furthest
-  const incline = inclineWithNormalVector(normalVector);
-  const direction = directionWithNormalVector(normalVector);
-  return {
-    projectedOutline,
-    maximumGap,
-    normalVector,
-    meanPoint,
-    incline,
-    direction,
-  };
+	//set warning to the furthest
+	const incline = inclineWithNormalVector(normalVector)
+	const direction = directionWithNormalVector(normalVector)
+	return {
+		projectedOutline,
+		maximumGap,
+		normalVector,
+		meanPoint,
+		incline,
+		direction
+	}
 }