@cognite/reveal-components 1.0.2 → 1.48552.0

package/dist/foundation/utilities/cylinderFit/bestFitCylinder.d.ts

@@ -1,17 +1,17 @@
-import { Vector3 } from 'three';
-import { LeastSquareCylinderResult } from './LeastSquareCylinderResult';
+import { Vector3 } from "three";
+import { type LeastSquareCylinderResult } from "./LeastSquareCylinderResult";
 export declare const MAIN_AXES: Vector3[];
 export type AcceptCylinder = (cylinder: LeastSquareCylinderResult) => boolean;
-export declare const MEASUREMENT_ERROR = 0.005;
+export declare const MEASUREMENT_ERROR = .005;
 /**
- * Computes the best-fit cylinder for a given set of 3D points.
- *
- * Iterates through a set of main axes, attempting to fit a cylinder to the points
- * for each axis, and returns the cylinder with the lowest root mean square (RMS) error.
- * Optionally, an acceptance function can be provided to filter out cylinders that do not meet certain criteria.
- *
- * @param points - An array of `Vector3` points representing the 3D coordinates to fit the cylinder to.
- * @param accept - (Optional) A predicate function that takes a `Cylinder` and returns `true` if the cylinder is acceptable.
- * @returns The best-fit `Cylinder` object with the lowest RMS error, or `undefined` if no suitable cylinder is found.
- */
+* Computes the best-fit cylinder for a given set of 3D points.
+*
+* Iterates through a set of main axes, attempting to fit a cylinder to the points
+* for each axis, and returns the cylinder with the lowest root mean square (RMS) error.
+* Optionally, an acceptance function can be provided to filter out cylinders that do not meet certain criteria.
+*
+* @param points - An array of `Vector3` points representing the 3D coordinates to fit the cylinder to.
+* @param accept - (Optional) A predicate function that takes a `Cylinder` and returns `true` if the cylinder is acceptable.
+* @returns The best-fit `Cylinder` object with the lowest RMS error, or `undefined` if no suitable cylinder is found.
+*/
 export declare function bestFitCylinder(points: Vector3[], accept?: AcceptCylinder): LeastSquareCylinderResult | undefined;

package/dist/foundation/utilities/cylinderFit/bestFitCylinder.js

@@ -1,114 +1,288 @@
-import { count as e } from "../extensions/arrayUtils.js";
-import { horizontalLength as t } from "../extensions/vectorUtils.js";
-import { Range1 as n } from "../geometry/Range1.js";
-import { Vector3ArrayUtils as r } from "../primitives/Vector3ArrayUtils.js";
-import { getTransformedPoints as i } from "./getTransformedPoints.js";
-import { LeastSquare as a } from "./LeastSquare.js";
-import { getTranslationRotationMatrix as o } from "./LeastSquareCylinderResult.js";
-import { bestFitVerticalCylinder as s } from "./bestFitVerticalCylinder.js";
-import { Matrix4 as c, Vector3 as l } from "three";
-//#region libs/shared/reveal-components/src/foundation/utilities/cylinderFit/bestFitCylinder.ts
-var u = b(), d = .005, f = 1e-9;
-function p(e, t) {
-	let n = r.getCenterOfMass(e);
-	if (n === void 0) return;
-	let i, a = Array(Math.ceil(e.length / 2));
-	for (let r of u) {
-		let o = m(e, r, n);
-		o !== void 0 && (_(o, e, a), !(t !== void 0 && !t(o)) && (i !== void 0 && o.rms >= i.rms || (i = o)));
-	}
-	return i;
+import { Matrix4, Vector3 } from "three";
+import { count } from "../extensions/arrayUtils.js";
+import { horizontalLength } from "../extensions/vectorUtils.js";
+import { Range1 } from "../geometry/Range1.js";
+import { Vector3ArrayUtils } from "../primitives/Vector3ArrayUtils.js";
+import { bestFitVerticalCylinder } from "./bestFitVerticalCylinder.js";
+import { getTransformedPoints } from "./getTransformedPoints.js";
+import { LeastSquare } from "./LeastSquare.js";
+import { getTranslationRotationMatrix } from "./LeastSquareCylinderResult.js";
+export const MAIN_AXES = createMainAxes();
+export const MEASUREMENT_ERROR = 0.005;
+const EPSILON = 1e-9;
+/**
+ * Computes the best-fit cylinder for a given set of 3D points.
+ *
+ * Iterates through a set of main axes, attempting to fit a cylinder to the points
+ * for each axis, and returns the cylinder with the lowest root mean square (RMS) error.
+ * Optionally, an acceptance function can be provided to filter out cylinders that do not meet certain criteria.
+ *
+ * @param points - An array of `Vector3` points representing the 3D coordinates to fit the cylinder to.
+ * @param accept - (Optional) A predicate function that takes a `Cylinder` and returns `true` if the cylinder is acceptable.
+ * @returns The best-fit `Cylinder` object with the lowest RMS error, or `undefined` if no suitable cylinder is found.
+ */ export function bestFitCylinder(points, accept) {
+    const massCenter = Vector3ArrayUtils.getCenterOfMass(points);
+    if (massCenter === undefined) {
+        return undefined;
+    }
+    let bestCylinder;
+    const angularHistogram = new Array(Math.ceil(points.length / 2)); // Just to avoid to many allocation
+    // Try with all available axis as a starting point, and keep the best one
+    for (const axis of MAIN_AXES){
+        const cylinder = getCylinderByInitialAxis(points, axis, massCenter);
+        if (cylinder === undefined) {
+            continue;
+        }
+        // Calculate the Root mean square error
+        calculateFitness(cylinder, points, angularHistogram);
+        if (accept !== undefined && !accept(cylinder)) {
+            continue;
+        }
+        if (bestCylinder !== undefined && cylinder.rms >= bestCylinder.rms) {
+            continue;
+        }
+        bestCylinder = cylinder;
+    }
+    return bestCylinder;
 }
-function m(e, t, n) {
-	let r = o(t, n), i = r.clone().invert(), a = s(e, i);
-	if (a !== void 0) return a.axis.copy(t), a.center.applyMatrix4(r), g(e, a) && h(a, e), a;
+function getCylinderByInitialAxis(points, axis, massCenter) {
+    const matrix = getTranslationRotationMatrix(axis, massCenter);
+    const invMatrix = matrix.clone().invert();
+    const cylinder = bestFitVerticalCylinder(points, invMatrix);
+    if (cylinder === undefined) {
+        return undefined;
+    }
+    // Transform the cylinder back to original space
+    cylinder.axis.copy(axis);
+    cylinder.center.applyMatrix4(matrix);
+    // Find a better solution
+    if (!computeGaussNewton(points, cylinder)) {
+        return cylinder;
+    }
+    updateHeightAndCenter(cylinder, points);
+    return cylinder;
 }
-function h(e, t) {
-	let r = e.getTranslationRotationMatrix(), a = new n();
-	for (let e of i(t, r)) a.add(e.z);
-	e.height = a.delta, e.center.set(0, 0, a.center), e.center.applyMatrix4(r);
+function updateHeightAndCenter(cylinder, points) {
+    const matrix = cylinder.getTranslationRotationMatrix();
+    const zRange = new Range1();
+    for (const point of getTransformedPoints(points, matrix)){
+        zRange.add(point.z);
+    }
+    cylinder.height = zRange.delta;
+    cylinder.center.set(0, 0, zRange.center);
+    cylinder.center.applyMatrix4(matrix);
 }
-function g(e, n) {
-	let r = e.length < 100 ? 30 : 10, s = e.length < 100 ? 5 : 3, u = n.axis.clone(), d = n.center.clone(), p = n.radius, m = new a(5), h = [
-		,
-		,
-		,
-		,
-		,
-	], g = 0;
-	for (let n = 0;; n++) {
-		let a = o(u, d);
-		if (a.multiply(new c().makeScale(p, p, p)), Math.abs(a.determinant()) < f) return !1;
-		m.clear();
-		let _ = 0;
-		try {
-			for (let n of i(e, a)) {
-				let e = t(n);
-				if (e < f) continue;
-				let r = 1 - e;
-				h[0] = -n.x / e, h[1] = -n.y / e, h[2] = -n.x * n.z / e, h[3] = -n.y * n.z / e, h[4] = -1, m.addEquation(h, r), _ += r * r;
-			}
-		} catch {
-			return !1;
-		}
-		let v = Math.sqrt(_ / e.length);
-		if (n === 0) g = v;
-		else if (v > 20 * g) return !1;
-		let b = m.compute();
-		if (b === void 0) {
-			if (n === 0 || v > g) return !1;
-			break;
-		}
-		u.set(b[2], b[3], 1), u.normalize(), u.transformDirection(a), u.z < 0 && u.negate();
-		let x = new l(b[0], b[1], -b[0] * b[2] - b[1] * b[3]), S = x.length();
-		if (x.transformDirection(a), d.addScaledVector(x, S), p += p * b[4], p <= 0) return !1;
-		if (y(b) < 1e-4 && n >= s) break;
-		if (n >= r) {
-			if (v > g) return !1;
-			break;
-		}
-	}
-	return n.axis.copy(u), n.center.copy(d), n.radius = p, !0;
+function computeGaussNewton(points, cylinder) {
+    // Gauss-Newton algorithm:
+    //
+    // Min S(X) = Sum(Residual_i(X))
+    // Where J_ij = dResidual_i(X)/dX_j (jacobian)
+    //
+    // Update:
+    // X(i+1) = X(i) - (J*Jt)^(-1) * (Jt * Residual)
+    //
+    // Written in the form A*X = B
+    // -(J*Jt) * (X(i+1) - X(i)) = (Jt * Residual)
+    // -(J*Jt)*dX = (Jt * R)
+    // (A,B,C) axis vector
+    // (X0,Y0,Z0) point on axis
+    //
+    // The distance from a point to the cylinder is given by
+    // Di = Ri - R
+    //
+    // ObjectiveFunction = Sum(Di^2) ~ Sum(Ri*Ri-R*R)  Ri is distance from a point to the axis
+    // ObjectiveFunction = F(X0, Y0, Z0, A, B, C, R)
+    // Ri = Sqrt(Ui*Ui + Vi*Vi + WiWi)/Sqrt(A*A+B*B+C*C)    and Sqrt(A*A+B*B+C*C) = 1
+    // Ui = C*(Yi - Y0) - B*(Zi - Z0)
+    // Vi = A*(Zi - Z0) - C*(Xi - X0)
+    // Wi = B*(Xi - X0) - A*(Yi - Y0)
+    // When
+    // (A,B,C) = (0,0,1)
+    // (X0,Y0,Z0) = (0,0,0)
+    //
+    // Ri = Sqrt( (Xi)^2 + (Yi)^2)
+    // dDi/dX0 = dRi/dX0 = 1/(2*Ri) * (-2*Xi) = -Xi/Ri
+    // dDi/dY0 = dRi/dY0 = 1/(2*Ri) * (-2*Yi) = -Yi/Ri
+    //
+    // dDi/dA:
+    // Ui = Yi
+    // Vi = A*Zi - Xi
+    // Wi = -A*Yi
+    // dDi/dA = dRi/dA = 1/(2Ri)*d(Ui*Ui + Vi*Vi + WiWi)/dA =
+    // d(Ui*Ui + Vi*Vi + WiWi)/dA = 2Ui*dUi/dA + 2Vi*dVi/dA + 2Wi*dWi/dA =
+    // 2(0 + (A*Zi - Xi)*Zi + (- A*Yi)Yi) = -2Xi*Zi when A = 0
+    // dDi/dA = (-2Xi*Zi)/(2Ri) = -Xi*Zi
+    // dD/dX0 = -Xi/Ri
+    // dD/dY0 = -Yi/Ri
+    // dD/dZ0 = 0
+    // dD/dA = -Xi*Zi/Ri
+    // dD/dB = -Yi*Xi/Ri
+    // dD/dC = 0
+    // dD/dR = -1
+    // Jacobian:
+    //    dD/dX0    dD/dY0    dD/dA         dD/dB      dD/dR
+    // | -X_0/R_0  -Y_0/R_0  -X_0*Z_0/R_0  -Y_0*Z_0/R_0  -1 |   | X0 |    | D_0 |
+    // | -X_1/R_1  -Y_1/R_1  -X_1*Z_1/R_1  -Y_1*Z_1/R_1  -1 |   | Y0 |    | D_1 |
+    // | -X_2/R_2  -Y_2/R_2  -X_2*Z_2/R_2  -Y_2*Z_2/R_2  -1 |   | A  |    | D_2 |
+    // | -X_3/R_3  -Y_3/R_3  -X_3*Z_3/R_3  -Y_3*Z_3/R_3  -1 |   | B  | =  | D_3 |
+    // | -X_4/R_4  -Y_4/R_4  -X_4*Z_4/R_4  -Y_4*Z_4/R_4  -1 |   | R  |    | D_4 |
+    // Z0 = -P1*P3 - P2*P4
+    const minSumSquare = 0.0001;
+    const relativeRmsThresholdForDiverging = 20;
+    const maxIterationCount = points.length < 100 ? 30 : 10;
+    const minIterationCount = points.length < 100 ? 5 : 3;
+    const axis = cylinder.axis.clone();
+    const center = cylinder.center.clone();
+    let radius = cylinder.radius;
+    const normalEquation = new LeastSquare(5);
+    const leftHandSide = new Array(5); // Uses as temp array to avoid creating many arrays
+    let firstRms = 0;
+    for(let iterationCount = 0;; iterationCount++){
+        const matrix = getTranslationRotationMatrix(axis, center);
+        matrix.multiply(new Matrix4().makeScale(radius, radius, radius));
+        if (Math.abs(matrix.determinant()) < EPSILON) {
+            return false;
+        }
+        normalEquation.clear();
+        let sumErrorSquared = 0;
+        try {
+            for (const point of getTransformedPoints(points, matrix)){
+                const distanceToCenter = horizontalLength(point);
+                if (distanceToCenter < EPSILON) {
+                    continue; // Skip this in the calculation to avoid instability
+                }
+                const error = 1 - distanceToCenter;
+                leftHandSide[0] = -point.x / distanceToCenter; // dD/dX0
+                leftHandSide[1] = -point.y / distanceToCenter; // dD/dY0
+                leftHandSide[2] = -point.x * point.z / distanceToCenter; // dD/dA
+                leftHandSide[3] = -point.y * point.z / distanceToCenter; // dD/dB
+                leftHandSide[4] = -1; // dD/dR
+                normalEquation.addEquation(leftHandSide, error);
+                sumErrorSquared += error * error;
+            }
+        } catch  {
+            return false;
+        }
+        const rms = Math.sqrt(sumErrorSquared / points.length);
+        if (iterationCount === 0) {
+            firstRms = rms;
+        } else if (rms > relativeRmsThresholdForDiverging * firstRms) {
+            return false; // Diverging, give up
+        }
+        const x = normalEquation.compute();
+        if (x === undefined) {
+            if (iterationCount === 0) {
+                return false; // No solution found at the first attempt
+            }
+            if (rms > firstRms) {
+                return false; // No solution found and worse than the first attempt
+            }
+            break; // Use the solution in previous iteration
+        }
+        axis.set(x[2], x[3], 1);
+        axis.normalize();
+        axis.transformDirection(matrix);
+        if (axis.z < 0) {
+            axis.negate();
+        }
+        // Line given by A*x + B*y + C*z = 0;
+        // When we set C = 1, z = -A*x - B*y
+        const deltaCenter = new Vector3(x[0], x[1], -x[0] * x[2] - x[1] * x[3]);
+        // transformDirection is actually also scaling with the length of the vector, so we must
+        // compensate for that here
+        const length = deltaCenter.length();
+        deltaCenter.transformDirection(matrix);
+        center.addScaledVector(deltaCenter, length);
+        radius += radius * x[4];
+        if (radius <= 0) {
+            return false; // Should be impossible, but you never know...
+        }
+        // Check for convergence, the sum of squared changes is small, then we are done
+        const sumSquared = getSumSquared(x);
+        if (sumSquared < minSumSquare && iterationCount >= minIterationCount) {
+            break; // Better solution is found
+        }
+        if (iterationCount >= maxIterationCount) {
+            if (rms > firstRms) {
+                return false; // No solution found and worse than the first attempt
+            }
+            break; // Solution is found
+        }
+    }
+    cylinder.axis.copy(axis);
+    cylinder.center.copy(center);
+    cylinder.radius = radius;
+    return true;
 }
-function _(n, r, a) {
-	let o = n.getTranslationRotationMatrix(), s = 0;
-	a.fill(0);
-	let c = a.length > 1;
-	for (let e of i(r, o)) {
-		let r = t(e);
-		r > n.radius ? r = Math.max(n.radius, r - d) : r < n.radius && (r = Math.min(n.radius, r + d));
-		let i = n.radius > f ? 1 - r / n.radius : r;
-		c && v(e, a), s += i * i;
-	}
-	n.rms = Math.sqrt(s / r.length), n.angularCoverage = c ? e(a, (e) => e > 0) / a.length : 1;
+function calculateFitness(cylinder, points, angularHistogram) {
+    const matrix = cylinder.getTranslationRotationMatrix();
+    let sumError = 0;
+    angularHistogram.fill(0);
+    const useHistogram = angularHistogram.length > 1;
+    for (const point of getTransformedPoints(points, matrix)){
+        // Find relative radius error
+        let actualRadius = horizontalLength(point);
+        // Assume a small measurement error on the points, let say 5 mm.
+        // So remove this error from the actualRadius, by adjusting it towards the radius found in the cylinder detection.
+        // This will improve the detection of small cylinders, with radius less that about 10 * MEASUREMENT_ERROR. where
+        // the measurement error is a significant part of the radius
+        // This gave better detection on small cylinders when testing with real data
+        if (actualRadius > cylinder.radius) {
+            actualRadius = Math.max(cylinder.radius, actualRadius - MEASUREMENT_ERROR);
+        } else if (actualRadius < cylinder.radius) {
+            actualRadius = Math.min(cylinder.radius, actualRadius + MEASUREMENT_ERROR);
+        }
+        const error = cylinder.radius > EPSILON ? 1 - actualRadius / cylinder.radius : actualRadius;
+        if (useHistogram) {
+            addToAngularHistogram(point, angularHistogram);
+        }
+        sumError += error * error;
+    }
+    cylinder.rms = Math.sqrt(sumError / points.length);
+    if (!useHistogram) {
+        cylinder.angularCoverage = 1;
+    } else {
+        const nonZeroCount = count(angularHistogram, (value)=>value > 0);
+        cylinder.angularCoverage = nonZeroCount / angularHistogram.length;
+    }
 }
-function v(e, t) {
-	let n = Math.atan2(e.y, e.x), r = Math.floor(t.length * n / (2 * Math.PI));
-	r < 0 && (r += t.length), t[r]++;
+function addToAngularHistogram(point, histogram) {
+    const angle = Math.atan2(point.y, point.x);
+    let index = Math.floor(histogram.length * angle / (2 * Math.PI));
+    // Fold into range 0..length-1
+    if (index < 0) {
+        index += histogram.length;
+    }
+    histogram[index]++;
 }
-function y(e) {
-	let t = 0;
-	for (let n of e) t += n * n;
-	return t;
+function getSumSquared(values) {
+    let sumSquared = 0;
+    for (const value of values){
+        sumSquared += value * value;
+    }
+    return sumSquared;
 }
-function b() {
-	let e = [
-		new l(1, 0, 0),
-		new l(0, 1, 0),
-		new l(0, 0, 1),
-		new l(1, 1, 0),
-		new l(1, -1, 0),
-		new l(0, 1, 1),
-		new l(0, -1, 1),
-		new l(1, 0, 1),
-		new l(-1, 0, 1),
-		new l(1, 1, 1),
-		new l(-1, 1, 1),
-		new l(1, -1, 1),
-		new l(-1, -1, 1)
-	];
-	for (let t of e) t.normalize();
-	return e;
+function createMainAxes() {
+    // These are bi directional vectors, so we only need one direction
+    const axes = [
+        new Vector3(1, 0, 0),
+        new Vector3(0, 1, 0),
+        new Vector3(0, 0, 1),
+        new Vector3(1, 1, 0),
+        new Vector3(1, -1, 0),
+        new Vector3(0, 1, 1),
+        new Vector3(0, -1, 1),
+        new Vector3(1, 0, 1),
+        new Vector3(-1, 0, 1),
+        new Vector3(1, 1, 1),
+        new Vector3(-1, 1, 1),
+        new Vector3(1, -1, 1),
+        new Vector3(-1, -1, 1)
+    ];
+    for (const axis of axes){
+        axis.normalize();
+    }
+    return axes;
 }
-//#endregion
-export { u as MAIN_AXES, d as MEASUREMENT_ERROR, p as bestFitCylinder };
+
+//# sourceMappingURL=bestFitCylinder.js.map

package/dist/foundation/utilities/cylinderFit/bestFitCylinder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/foundation/utilities/cylinderFit/bestFitCylinder.ts"],"sourcesContent":["import { Matrix4, Vector3 } from 'three';\n\nimport { count } from '../extensions/arrayUtils';\nimport { horizontalLength } from '../extensions/vectorUtils';\nimport { Range1 } from '../geometry/Range1';\nimport { Vector3ArrayUtils } from '../primitives/Vector3ArrayUtils';\n\nimport { bestFitVerticalCylinder } from './bestFitVerticalCylinder';\nimport { getTransformedPoints } from './getTransformedPoints';\nimport { LeastSquare } from './LeastSquare';\nimport {\n  getTranslationRotationMatrix,\n  type LeastSquareCylinderResult,\n} from './LeastSquareCylinderResult';\n\nexport const MAIN_AXES: Vector3[] = createMainAxes();\n\nexport type AcceptCylinder = (cylinder: LeastSquareCylinderResult) => boolean;\n\nexport const MEASUREMENT_ERROR = 0.005;\n\nconst EPSILON = 1e-9;\n\n/**\n * Computes the best-fit cylinder for a given set of 3D points.\n *\n * Iterates through a set of main axes, attempting to fit a cylinder to the points\n * for each axis, and returns the cylinder with the lowest root mean square (RMS) error.\n * Optionally, an acceptance function can be provided to filter out cylinders that do not meet certain criteria.\n *\n * @param points - An array of `Vector3` points representing the 3D coordinates to fit the cylinder to.\n * @param accept - (Optional) A predicate function that takes a `Cylinder` and returns `true` if the cylinder is acceptable.\n * @returns The best-fit `Cylinder` object with the lowest RMS error, or `undefined` if no suitable cylinder is found.\n */\nexport function bestFitCylinder(\n  points: Vector3[],\n  accept?: AcceptCylinder\n): LeastSquareCylinderResult | undefined {\n  const massCenter = Vector3ArrayUtils.getCenterOfMass(points);\n  if (massCenter === undefined) {\n    return undefined;\n  }\n  let bestCylinder: LeastSquareCylinderResult | undefined;\n  const angularHistogram = new Array<number>(Math.ceil(points.length / 2)); // Just to avoid to many allocation\n\n  // Try with all available axis as a starting point, and keep the best one\n  for (const axis of MAIN_AXES) {\n    const cylinder = getCylinderByInitialAxis(points, axis, massCenter);\n    if (cylinder === undefined) {\n      continue;\n    }\n    // Calculate the Root mean square error\n    calculateFitness(cylinder, points, angularHistogram);\n    if (accept !== undefined && !accept(cylinder)) {\n      continue;\n    }\n    if (bestCylinder !== undefined && cylinder.rms >= bestCylinder.rms) {\n      continue;\n    }\n    bestCylinder = cylinder;\n  }\n  return bestCylinder;\n}\n\nfunction getCylinderByInitialAxis(\n  points: Vector3[],\n  axis: Vector3,\n  massCenter: Vector3\n): LeastSquareCylinderResult | undefined {\n  const matrix = getTranslationRotationMatrix(axis, massCenter);\n  const invMatrix = matrix.clone().invert();\n\n  const cylinder = bestFitVerticalCylinder(points, invMatrix);\n  if (cylinder === undefined) {\n    return undefined;\n  }\n  // Transform the cylinder back to original space\n  cylinder.axis.copy(axis);\n  cylinder.center.applyMatrix4(matrix);\n\n  // Find a better solution\n  if (!computeGaussNewton(points, cylinder)) {\n    return cylinder;\n  }\n  updateHeightAndCenter(cylinder, points);\n  return cylinder;\n}\n\nfunction updateHeightAndCenter(\n  cylinder: LeastSquareCylinderResult,\n  points: Vector3[]\n): void {\n  const matrix = cylinder.getTranslationRotationMatrix();\n  const zRange = new Range1();\n  for (const point of getTransformedPoints(points, matrix)) {\n    zRange.add(point.z);\n  }\n  cylinder.height = zRange.delta;\n  cylinder.center.set(0, 0, zRange.center);\n  cylinder.center.applyMatrix4(matrix);\n}\n\nfunction computeGaussNewton(\n  points: Vector3[],\n  cylinder: LeastSquareCylinderResult\n): boolean {\n  // Gauss-Newton algorithm:\n  //\n  // Min S(X) = Sum(Residual_i(X))\n  // Where J_ij = dResidual_i(X)/dX_j (jacobian)\n  //\n  // Update:\n  // X(i+1) = X(i) - (J*Jt)^(-1) * (Jt * Residual)\n  //\n  // Written in the form A*X = B\n  // -(J*Jt) * (X(i+1) - X(i)) = (Jt * Residual)\n  // -(J*Jt)*dX = (Jt * R)\n\n  // (A,B,C) axis vector\n  // (X0,Y0,Z0) point on axis\n  //\n  // The distance from a point to the cylinder is given by\n  // Di = Ri - R\n  //\n  // ObjectiveFunction = Sum(Di^2) ~ Sum(Ri*Ri-R*R)  Ri is distance from a point to the axis\n  // ObjectiveFunction = F(X0, Y0, Z0, A, B, C, R)\n\n  // Ri = Sqrt(Ui*Ui + Vi*Vi + WiWi)/Sqrt(A*A+B*B+C*C)    and Sqrt(A*A+B*B+C*C) = 1\n  // Ui = C*(Yi - Y0) - B*(Zi - Z0)\n  // Vi = A*(Zi - Z0) - C*(Xi - X0)\n  // Wi = B*(Xi - X0) - A*(Yi - Y0)\n\n  // When\n  // (A,B,C) = (0,0,1)\n  // (X0,Y0,Z0) = (0,0,0)\n  //\n  // Ri = Sqrt( (Xi)^2 + (Yi)^2)\n  // dDi/dX0 = dRi/dX0 = 1/(2*Ri) * (-2*Xi) = -Xi/Ri\n  // dDi/dY0 = dRi/dY0 = 1/(2*Ri) * (-2*Yi) = -Yi/Ri\n  //\n  // dDi/dA:\n  // Ui = Yi\n  // Vi = A*Zi - Xi\n  // Wi = -A*Yi\n\n  // dDi/dA = dRi/dA = 1/(2Ri)*d(Ui*Ui + Vi*Vi + WiWi)/dA =\n  // d(Ui*Ui + Vi*Vi + WiWi)/dA = 2Ui*dUi/dA + 2Vi*dVi/dA + 2Wi*dWi/dA =\n  // 2(0 + (A*Zi - Xi)*Zi + (- A*Yi)Yi) = -2Xi*Zi when A = 0\n  // dDi/dA = (-2Xi*Zi)/(2Ri) = -Xi*Zi\n\n  // dD/dX0 = -Xi/Ri\n  // dD/dY0 = -Yi/Ri\n  // dD/dZ0 = 0\n  // dD/dA = -Xi*Zi/Ri\n  // dD/dB = -Yi*Xi/Ri\n  // dD/dC = 0\n  // dD/dR = -1\n\n  // Jacobian:\n  //    dD/dX0    dD/dY0    dD/dA         dD/dB      dD/dR\n  // | -X_0/R_0  -Y_0/R_0  -X_0*Z_0/R_0  -Y_0*Z_0/R_0  -1 |   | X0 |    | D_0 |\n  // | -X_1/R_1  -Y_1/R_1  -X_1*Z_1/R_1  -Y_1*Z_1/R_1  -1 |   | Y0 |    | D_1 |\n  // | -X_2/R_2  -Y_2/R_2  -X_2*Z_2/R_2  -Y_2*Z_2/R_2  -1 |   | A  |    | D_2 |\n  // | -X_3/R_3  -Y_3/R_3  -X_3*Z_3/R_3  -Y_3*Z_3/R_3  -1 |   | B  | =  | D_3 |\n  // | -X_4/R_4  -Y_4/R_4  -X_4*Z_4/R_4  -Y_4*Z_4/R_4  -1 |   | R  |    | D_4 |\n\n  // Z0 = -P1*P3 - P2*P4\n\n  const minSumSquare = 0.0001;\n  const relativeRmsThresholdForDiverging = 20;\n  const maxIterationCount = points.length < 100 ? 30 : 10;\n  const minIterationCount = points.length < 100 ? 5 : 3;\n\n  const axis = cylinder.axis.clone();\n  const center = cylinder.center.clone();\n  let radius = cylinder.radius;\n\n  const normalEquation = new LeastSquare(5);\n  const leftHandSide = new Array<number>(5); // Uses as temp array to avoid creating many arrays\n  let firstRms = 0;\n\n  for (let iterationCount = 0; ; iterationCount++) {\n    const matrix = getTranslationRotationMatrix(axis, center);\n    matrix.multiply(new Matrix4().makeScale(radius, radius, radius));\n\n    if (Math.abs(matrix.determinant()) < EPSILON) {\n      return false;\n    }\n    normalEquation.clear();\n    let sumErrorSquared = 0;\n\n    try {\n      for (const point of getTransformedPoints(points, matrix)) {\n        const distanceToCenter = horizontalLength(point);\n        if (distanceToCenter < EPSILON) {\n          continue; // Skip this in the calculation to avoid instability\n        }\n        const error = 1 - distanceToCenter;\n\n        leftHandSide[0] = -point.x / distanceToCenter; // dD/dX0\n        leftHandSide[1] = -point.y / distanceToCenter; // dD/dY0\n        leftHandSide[2] = (-point.x * point.z) / distanceToCenter; // dD/dA\n        leftHandSide[3] = (-point.y * point.z) / distanceToCenter; // dD/dB\n        leftHandSide[4] = -1; // dD/dR\n\n        normalEquation.addEquation(leftHandSide, error);\n        sumErrorSquared += error * error;\n      }\n    } catch {\n      return false;\n    }\n\n    const rms = Math.sqrt(sumErrorSquared / points.length);\n    if (iterationCount === 0) {\n      firstRms = rms;\n    } else if (rms > relativeRmsThresholdForDiverging * firstRms) {\n      return false; // Diverging, give up\n    }\n    const x = normalEquation.compute();\n    if (x === undefined) {\n      if (iterationCount === 0) {\n        return false; // No solution found at the first attempt\n      }\n      if (rms > firstRms) {\n        return false; // No solution found and worse than the first attempt\n      }\n      break; // Use the solution in previous iteration\n    }\n    axis.set(x[2], x[3], 1);\n    axis.normalize();\n    axis.transformDirection(matrix);\n    if (axis.z < 0) {\n      axis.negate();\n    }\n    // Line given by A*x + B*y + C*z = 0;\n    // When we set C = 1, z = -A*x - B*y\n    const deltaCenter = new Vector3(x[0], x[1], -x[0] * x[2] - x[1] * x[3]);\n\n    // transformDirection is actually also scaling with the length of the vector, so we must\n    // compensate for that here\n    const length = deltaCenter.length();\n    deltaCenter.transformDirection(matrix);\n    center.addScaledVector(deltaCenter, length);\n\n    radius += radius * x[4];\n    if (radius <= 0) {\n      return false; // Should be impossible, but you never know...\n    }\n    // Check for convergence, the sum of squared changes is small, then we are done\n    const sumSquared = getSumSquared(x);\n    if (sumSquared < minSumSquare && iterationCount >= minIterationCount) {\n      break; // Better solution is found\n    }\n    if (iterationCount >= maxIterationCount) {\n      if (rms > firstRms) {\n        return false; // No solution found and worse than the first attempt\n      }\n      break; // Solution is found\n    }\n  }\n  cylinder.axis.copy(axis);\n  cylinder.center.copy(center);\n  cylinder.radius = radius;\n  return true;\n}\n\nfunction calculateFitness(\n  cylinder: LeastSquareCylinderResult,\n  points: Vector3[],\n  angularHistogram: number[]\n): void {\n  const matrix = cylinder.getTranslationRotationMatrix();\n  let sumError = 0;\n  angularHistogram.fill(0);\n  const useHistogram = angularHistogram.length > 1;\n\n  for (const point of getTransformedPoints(points, matrix)) {\n    // Find relative radius error\n    let actualRadius = horizontalLength(point);\n\n    // Assume a small measurement error on the points, let say 5 mm.\n    // So remove this error from the actualRadius, by adjusting it towards the radius found in the cylinder detection.\n    // This will improve the detection of small cylinders, with radius less that about 10 * MEASUREMENT_ERROR. where\n    // the measurement error is a significant part of the radius\n    // This gave better detection on small cylinders when testing with real data\n    if (actualRadius > cylinder.radius) {\n      actualRadius = Math.max(\n        cylinder.radius,\n        actualRadius - MEASUREMENT_ERROR\n      );\n    } else if (actualRadius < cylinder.radius) {\n      actualRadius = Math.min(\n        cylinder.radius,\n        actualRadius + MEASUREMENT_ERROR\n      );\n    }\n    const error =\n      cylinder.radius > EPSILON\n        ? 1 - actualRadius / cylinder.radius\n        : actualRadius;\n    if (useHistogram) {\n      addToAngularHistogram(point, angularHistogram);\n    }\n    sumError += error * error;\n  }\n  cylinder.rms = Math.sqrt(sumError / points.length);\n  if (!useHistogram) {\n    cylinder.angularCoverage = 1;\n  } else {\n    const nonZeroCount = count(angularHistogram, (value: number) => value > 0);\n    cylinder.angularCoverage = nonZeroCount / angularHistogram.length;\n  }\n}\n\nfunction addToAngularHistogram(point: Vector3, histogram: number[]): void {\n  const angle = Math.atan2(point.y, point.x);\n  let index = Math.floor((histogram.length * angle) / (2 * Math.PI));\n  // Fold into range 0..length-1\n  if (index < 0) {\n    index += histogram.length;\n  }\n  histogram[index]++;\n}\n\nfunction getSumSquared(values: number[]): number {\n  let sumSquared = 0;\n  for (const value of values) {\n    sumSquared += value * value;\n  }\n  return sumSquared;\n}\n\nfunction createMainAxes(): Vector3[] {\n  // These are bi directional vectors, so we only need one direction\n  const axes = [\n    new Vector3(1, 0, 0),\n    new Vector3(0, 1, 0),\n    new Vector3(0, 0, 1),\n    new Vector3(1, 1, 0),\n    new Vector3(1, -1, 0),\n    new Vector3(0, 1, 1),\n    new Vector3(0, -1, 1),\n    new Vector3(1, 0, 1),\n    new Vector3(-1, 0, 1),\n    new Vector3(1, 1, 1),\n    new Vector3(-1, 1, 1),\n    new Vector3(1, -1, 1),\n    new Vector3(-1, -1, 1),\n  ];\n  for (const axis of axes) {\n    axis.normalize();\n  }\n  return axes;\n}\n"],"names":["Matrix4","Vector3","count","horizontalLength","Range1","Vector3ArrayUtils","bestFitVerticalCylinder","getTransformedPoints","LeastSquare","getTranslationRotationMatrix","MAIN_AXES","createMainAxes","MEASUREMENT_ERROR","EPSILON","bestFitCylinder","points","accept","massCenter","getCenterOfMass","undefined","bestCylinder","angularHistogram","Array","Math","ceil","length","axis","cylinder","getCylinderByInitialAxis","calculateFitness","rms","matrix","invMatrix","clone","invert","copy","center","applyMatrix4","computeGaussNewton","updateHeightAndCenter","zRange","point","add","z","height","delta","set","minSumSquare","relativeRmsThresholdForDiverging","maxIterationCount","minIterationCount","radius","normalEquation","leftHandSide","firstRms","iterationCount","multiply","makeScale","abs","determinant","clear","sumErrorSquared","distanceToCenter","error","x","y","addEquation","sqrt","compute","normalize","transformDirection","negate","deltaCenter","addScaledVector","sumSquared","getSumSquared","sumError","fill","useHistogram","actualRadius","max","min","addToAngularHistogram","angularCoverage","nonZeroCount","value","histogram","angle","atan2","index","floor","PI","values","axes"],"mappings":"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"}

package/dist/foundation/utilities/cylinderFit/bestFitVerticalCylinder.d.ts

@@ -1,14 +1,14 @@
-import { Matrix4, Vector3 } from 'three';
-import { LeastSquareCylinderResult } from './LeastSquareCylinderResult';
+import { type Matrix4, Vector3 } from "three";
+import { LeastSquareCylinderResult } from "./LeastSquareCylinderResult";
 /**
- * Computes the best-fit vertical cylinder for a set of 3D points.
- *
- * The function transforms each point using the provided matrix, then fits a vertical cylinder
- * (aligned with the Z-axis) to the transformed points using a least squares approach.
- * Returns the cylinder if a valid fit is found, or `undefined` otherwise.
- *
- * @param points - An array of 3D points (`Vector3`) to fit the cylinder to.
- * @param matrix - A transformation matrix (`Matrix4`) applied to each point before fitting.
- * @returns The fitted `Cylinder` object if successful, or `undefined` if the fit fails.
- */
+* Computes the best-fit vertical cylinder for a set of 3D points.
+*
+* The function transforms each point using the provided matrix, then fits a vertical cylinder
+* (aligned with the Z-axis) to the transformed points using a least squares approach.
+* Returns the cylinder if a valid fit is found, or `undefined` otherwise.
+*
+* @param points - An array of 3D points (`Vector3`) to fit the cylinder to.
+* @param matrix - A transformation matrix (`Matrix4`) applied to each point before fitting.
+* @returns The fitted `Cylinder` object if successful, or `undefined` if the fit fails.
+*/
 export declare function bestFitVerticalCylinder(points: Vector3[], matrix: Matrix4): LeastSquareCylinderResult | undefined;

package/dist/foundation/utilities/cylinderFit/bestFitVerticalCylinder.js

@@ -1,23 +1,41 @@
-import { horizontalLengthSq as e } from "../extensions/vectorUtils.js";
-import { Range1 as t } from "../geometry/Range1.js";
-import { getTransformedPoints as n } from "./getTransformedPoints.js";
-import { LeastSquare as r } from "./LeastSquare.js";
-import { LeastSquareCylinderResult as i, UP_VECTOR as a } from "./LeastSquareCylinderResult.js";
-import { Vector3 as o } from "three";
-//#region libs/shared/reveal-components/src/foundation/utilities/cylinderFit/bestFitVerticalCylinder.ts
-function s(s, c) {
-	let l = new r(3), u = new t();
-	for (let t of n(s, c, !1)) u.add(t.z), l.addEquation([
-		2 * t.x,
-		2 * t.y,
-		-1
-	], e(t));
-	let d = l.compute();
-	if (d === void 0) return;
-	let f = new o(d[0], d[1], u.center), p = Math.sqrt(e(f) - d[2]);
-	if (p <= 0 || !isFinite(p)) return;
-	let m = Math.max(u.delta, p / 100);
-	return new i(f, a, p, m);
+import { Vector3 } from "three";
+import { horizontalLengthSq } from "../extensions/vectorUtils.js";
+import { Range1 } from "../geometry/Range1.js";
+import { getTransformedPoints } from "./getTransformedPoints.js";
+import { LeastSquare } from "./LeastSquare.js";
+import { LeastSquareCylinderResult, UP_VECTOR } from "./LeastSquareCylinderResult.js";
+/**
+ * Computes the best-fit vertical cylinder for a set of 3D points.
+ *
+ * The function transforms each point using the provided matrix, then fits a vertical cylinder
+ * (aligned with the Z-axis) to the transformed points using a least squares approach.
+ * Returns the cylinder if a valid fit is found, or `undefined` otherwise.
+ *
+ * @param points - An array of 3D points (`Vector3`) to fit the cylinder to.
+ * @param matrix - A transformation matrix (`Matrix4`) applied to each point before fitting.
+ * @returns The fitted `Cylinder` object if successful, or `undefined` if the fit fails.
+ */ export function bestFitVerticalCylinder(points, matrix) {
+    const leastSquare = new LeastSquare(3);
+    const zRange = new Range1();
+    for (const point of getTransformedPoints(points, matrix, false)){
+        zRange.add(point.z);
+        leastSquare.addEquation([
+            2 * point.x,
+            2 * point.y,
+            -1
+        ], horizontalLengthSq(point));
+    }
+    const solution = leastSquare.compute();
+    if (solution === undefined) {
+        return undefined;
+    }
+    const center = new Vector3(solution[0], solution[1], zRange.center);
+    const radius = Math.sqrt(horizontalLengthSq(center) - solution[2]);
+    if (radius <= 0 || !isFinite(radius)) {
+        return undefined; // Should be impossible, but you never know...
+    }
+    const height = Math.max(zRange.delta, radius / 100); // Just give a small height if all points are in a plane
+    return new LeastSquareCylinderResult(center, UP_VECTOR, radius, height);
 }
-//#endregion
-export { s as bestFitVerticalCylinder };
+
+//# sourceMappingURL=bestFitVerticalCylinder.js.map

package/dist/foundation/utilities/cylinderFit/bestFitVerticalCylinder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/foundation/utilities/cylinderFit/bestFitVerticalCylinder.ts"],"sourcesContent":["import { type Matrix4, Vector3 } from 'three';\n\nimport { horizontalLengthSq } from '../extensions/vectorUtils';\nimport { Range1 } from '../geometry/Range1';\n\nimport { getTransformedPoints } from './getTransformedPoints';\nimport { LeastSquare } from './LeastSquare';\nimport {\n  LeastSquareCylinderResult,\n  UP_VECTOR,\n} from './LeastSquareCylinderResult';\n\n/**\n * Computes the best-fit vertical cylinder for a set of 3D points.\n *\n * The function transforms each point using the provided matrix, then fits a vertical cylinder\n * (aligned with the Z-axis) to the transformed points using a least squares approach.\n * Returns the cylinder if a valid fit is found, or `undefined` otherwise.\n *\n * @param points - An array of 3D points (`Vector3`) to fit the cylinder to.\n * @param matrix - A transformation matrix (`Matrix4`) applied to each point before fitting.\n * @returns The fitted `Cylinder` object if successful, or `undefined` if the fit fails.\n */\nexport function bestFitVerticalCylinder(\n  points: Vector3[],\n  matrix: Matrix4\n): LeastSquareCylinderResult | undefined {\n  const leastSquare = new LeastSquare(3);\n  const zRange = new Range1();\n\n  for (const point of getTransformedPoints(points, matrix, false)) {\n    zRange.add(point.z);\n    leastSquare.addEquation(\n      [2 * point.x, 2 * point.y, -1],\n      horizontalLengthSq(point)\n    );\n  }\n  const solution = leastSquare.compute();\n  if (solution === undefined) {\n    return undefined;\n  }\n  const center = new Vector3(solution[0], solution[1], zRange.center);\n  const radius = Math.sqrt(horizontalLengthSq(center) - solution[2]);\n  if (radius <= 0 || !isFinite(radius)) {\n    return undefined; // Should be impossible, but you never know...\n  }\n  const height = Math.max(zRange.delta, radius / 100); // Just give a small height if all points are in a plane\n  return new LeastSquareCylinderResult(center, UP_VECTOR, radius, height);\n}\n"],"names":["Vector3","horizontalLengthSq","Range1","getTransformedPoints","LeastSquare","LeastSquareCylinderResult","UP_VECTOR","bestFitVerticalCylinder","points","matrix","leastSquare","zRange","point","add","z","addEquation","x","y","solution","compute","undefined","center","radius","Math","sqrt","isFinite","height","max","delta"],"mappings":"AAAA,SAAuBA,OAAO,QAAQ,QAAQ;AAE9C,SAASC,kBAAkB,QAAQ,+BAA4B;AAC/D,SAASC,MAAM,QAAQ,wBAAqB;AAE5C,SAASC,oBAAoB,QAAQ,4BAAyB;AAC9D,SAASC,WAAW,QAAQ,mBAAgB;AAC5C,SACEC,yBAAyB,EACzBC,SAAS,QACJ,iCAA8B;AAErC;;;;;;;;;;CAUC,GACD,OAAO,SAASC,wBACdC,MAAiB,EACjBC,MAAe;IAEf,MAAMC,cAAc,IAAIN,YAAY;IACpC,MAAMO,SAAS,IAAIT;IAEnB,KAAK,MAAMU,SAAST,qBAAqBK,QAAQC,QAAQ,OAAQ;QAC/DE,OAAOE,GAAG,CAACD,MAAME,CAAC;QAClBJ,YAAYK,WAAW,CACrB;YAAC,IAAIH,MAAMI,CAAC;YAAE,IAAIJ,MAAMK,CAAC;YAAE,CAAC;SAAE,EAC9BhB,mBAAmBW;IAEvB;IACA,MAAMM,WAAWR,YAAYS,OAAO;IACpC,IAAID,aAAaE,WAAW;QAC1B,OAAOA;IACT;IACA,MAAMC,SAAS,IAAIrB,QAAQkB,QAAQ,CAAC,EAAE,EAAEA,QAAQ,CAAC,EAAE,EAAEP,OAAOU,MAAM;IAClE,MAAMC,SAASC,KAAKC,IAAI,CAACvB,mBAAmBoB,UAAUH,QAAQ,CAAC,EAAE;IACjE,IAAII,UAAU,KAAK,CAACG,SAASH,SAAS;QACpC,OAAOF,WAAW,8CAA8C;IAClE;IACA,MAAMM,SAASH,KAAKI,GAAG,CAAChB,OAAOiB,KAAK,EAAEN,SAAS,MAAM,wDAAwD;IAC7G,OAAO,IAAIjB,0BAA0BgB,QAAQf,WAAWgB,QAAQI;AAClE"}

package/dist/foundation/utilities/cylinderFit/getTransformedPoints.d.ts

@@ -1,14 +1,14 @@
-import { Matrix4, Vector3 } from 'three';
+import { type Matrix4, Vector3 } from "three";
 /**
- * Generates transformed 3D points by applying a transformation matrix to each point in the input array.
- *
- * @param points - An array of `Vector3` points to be transformed.
- * @param matrix - The `Matrix4` transformation matrix to apply to each point.
- * @param useInverse - If `true` (default), the inverse of the matrix is used for transformation; otherwise, the matrix is used as-is.
- * @returns A generator that yields each transformed `Vector3` point.
- *
- * @remarks
- * The generator reuses a single `Vector3` instance for yielding transformed points,
- * so consumers should copy the yielded value if they need to retain it.
- */
+* Generates transformed 3D points by applying a transformation matrix to each point in the input array.
+*
+* @param points - An array of `Vector3` points to be transformed.
+* @param matrix - The `Matrix4` transformation matrix to apply to each point.
+* @param useInverse - If `true` (default), the inverse of the matrix is used for transformation; otherwise, the matrix is used as-is.
+* @returns A generator that yields each transformed `Vector3` point.
+*
+* @remarks
+* The generator reuses a single `Vector3` instance for yielding transformed points,
+* so consumers should copy the yielded value if they need to retain it.
+*/
 export declare function getTransformedPoints(points: Vector3[], matrix: Matrix4, useInverse?: boolean): Generator<Vector3>;