@cognite/reveal-components 1.0.2 → 1.48552.0

package/dist/foundation/utilities/primitives/Cylinder.js

@@ -1,123 +1,223 @@
-import { isEqual as e, square as t } from "../extensions/mathUtils.js";
-import { PrimitiveType as n } from "./PrimitiveType.js";
-import { Primitive as r } from "./Primitive.js";
-import { Range3 as i } from "../geometry/Range3.js";
-import { Line3 as a, Matrix4 as o, Quaternion as s, Vector3 as c } from "three";
-//#region libs/shared/reveal-components/src/foundation/utilities/primitives/Cylinder.ts
-var l = new c(0, 0, 1), u = class u extends r {
-	static MinSize = .01;
-	static HalfMinSize = u.MinSize * .5;
-	radius = u.MinSize;
-	centerA = new c(0, 0, -u.HalfMinSize);
-	centerB = new c(0, 0, +u.HalfMinSize);
-	_center = new c();
-	_axis = new c();
-	_size = new c();
-	get endCapArea() {
-		return Math.PI * this.radius * this.radius;
-	}
-	get primitiveType() {
-		return n.Cylinder;
-	}
-	get area() {
-		return 2 * Math.PI * this.radius * this.height + 2 * this.endCapArea;
-	}
-	get volume() {
-		return Math.PI * t(this.radius) * this.height;
-	}
-	get diagonal() {
-		return Math.sqrt(t(this.radius) + t(this.height));
-	}
-	getMatrix() {
-		return new o().compose(this.center, this.getQuaternion(), this.size);
-	}
-	setMatrix(e) {
-		let t = new c(0, 0, -.5).applyMatrix4(e), n = new c(0, 0, .5).applyMatrix4(e), r = new c().setFromMatrixScale(e);
-		this.centerA.copy(t), this.centerB.copy(n), this.radius = r.x / 2;
-	}
-	expandBoundingBox(e) {
-		let t = new i(this.centerA, this.centerB);
-		t.expandByMargin3(i.getCircleRangeMargin(this.axis, this.radius)), e.union(t.getBox());
-	}
-	isPointInside(e, t) {
-		let { centerA: n, centerB: r } = this.getCenters(t), i = new c().addVectors(n, r).divideScalar(2), a = n.sub(r), o = a.length();
-		a.normalize();
-		let s = i.sub(e), l = a.dot(s);
-		return a.multiplyScalar(l), a.sub(s), !(a.length() > this.radius || Math.abs(l) > o / 2);
-	}
-	getPointsInside(e) {
-		let t = new a(this.centerA, this.centerB), n = new c();
-		return e.filter((e) => {
-			let r = t.closestPointToPointParameter(e, !1);
-			return !(r < 0 || r > 1 || t.at(r, n).distanceTo(e) > this.radius);
-		});
-	}
-	intersectRay(e, t) {
-		let { centerA: n, centerB: r } = this.getCenters(t), { radius: i } = this, a = e.origin, o = e.direction, s = new c().subVectors(r, n), l = s.dot(o);
-		if (l > 0) {
-			let t = (s.dot(n) - s.dot(a)) / l, r = e.at(t, new c());
-			if (r.distanceTo(n) <= i) return r;
-		}
-		if (l < 0) {
-			let t = (s.dot(r) - s.dot(a)) / l, n = e.at(t, new c());
-			if (n.distanceTo(r) <= i) return n;
-		}
-		let u = new c().subVectors(a, n), d = s.dot(s), f = s.dot(u), p = d - l * l, m = d * u.dot(o) - f * l, h = d * u.dot(u) - f * f - i * i * d, g = m * m - p * h;
-		if (g < 0) return;
-		let _ = Math.sqrt(g), v = (-m - _) / p, y = f + v * l;
-		if (y > 0 && y < d) return e.at(v, new c());
-	}
-	get height() {
-		return this.centerA.distanceTo(this.centerB);
-	}
-	set height(e) {
-		let t = this.center, n = e * .5, r = this.axis;
-		this.centerA.copy(t).addScaledVector(r, -n), this.centerB.copy(t).addScaledVector(r, +n);
-	}
-	get center() {
-		return this._center.addVectors(this.centerB, this.centerA).divideScalar(2);
-	}
-	get size() {
-		return this._size.set(this.diameter, this.diameter, this.height);
-	}
-	get axis() {
-		return this._axis.subVectors(this.centerB, this.centerA).normalize();
-	}
-	get diameter() {
-		return 2 * this.radius;
-	}
-	getRotationMatrix(e = new o()) {
-		return e.identity(), e.makeRotationFromQuaternion(this.getQuaternion());
-	}
-	getScaledMatrix(e, t = new o()) {
-		return t.compose(this.center, this.getQuaternion(), e);
-	}
-	getQuaternion() {
-		return new s().setFromUnitVectors(l, this.axis);
-	}
-	getCenters(e) {
-		let t = this.centerA.clone(), n = this.centerB.clone();
-		return t.applyMatrix4(e), n.applyMatrix4(e), {
-			centerA: t,
-			centerB: n
-		};
-	}
-	copy(e) {
-		return this.radius = e.radius, this.centerA.copy(e.centerA), this.centerB.copy(e.centerB), this;
-	}
-	applyMatrix4(t) {
-		let n = new c().setFromMatrixScale(t);
-		return (!e(n.x, n.y) || !e(n.x, n.z)) && console.warn("Cylinder.applyMatrix4: The matrix has non-uniform scale, result may be incorrect."), this.centerA.applyMatrix4(t), this.centerB.applyMatrix4(t), this.radius *= n.x, this;
-	}
-	clear() {
-		this.radius = u.MinSize, this.centerA.set(0, 0, -u.HalfMinSize), this.centerB.set(0, 0, +u.HalfMinSize);
-	}
-	forceMinSize() {
-		this.radius = Math.max(this.radius, u.MinSize);
-	}
-	static isValidSize(e) {
-		return e > u.MinSize;
-	}
-};
-//#endregion
-export { u as Cylinder };
+import { Line3, Matrix4, Quaternion, Vector3 } from "three";
+import { isEqual, square } from "../extensions/mathUtils.js";
+import { Range3 } from "../geometry/Range3.js";
+import { Primitive } from "./Primitive.js";
+import { PrimitiveType } from "./PrimitiveType.js";
+const UP_AXIS = new Vector3(0, 0, 1);
+export class Cylinder extends Primitive {
+    static{
+        this.MinSize = 0.01;
+    }
+    static{
+        this.HalfMinSize = Cylinder.MinSize * 0.5;
+    }
+    get endCapArea() {
+        return Math.PI * this.radius * this.radius;
+    }
+    // ==================================================
+    // OVERRIDES of Primitive
+    // ==================================================
+    get primitiveType() {
+        return PrimitiveType.Cylinder;
+    }
+    get area() {
+        return 2 * Math.PI * this.radius * this.height + 2 * this.endCapArea;
+    }
+    get volume() {
+        return Math.PI * square(this.radius) * this.height;
+    }
+    get diagonal() {
+        return Math.sqrt(square(this.radius) + square(this.height));
+    }
+    getMatrix() {
+        return new Matrix4().compose(this.center, this.getQuaternion(), this.size);
+    }
+    setMatrix(matrix) {
+        const centerA = new Vector3(0, 0, -0.5).applyMatrix4(matrix);
+        const centerB = new Vector3(0, 0, 0.5).applyMatrix4(matrix);
+        const scale = new Vector3().setFromMatrixScale(matrix);
+        this.centerA.copy(centerA);
+        this.centerB.copy(centerB);
+        this.radius = scale.x / 2;
+    }
+    expandBoundingBox(boundingBox) {
+        const range = new Range3(this.centerA, this.centerB);
+        range.expandByMargin3(Range3.getCircleRangeMargin(this.axis, this.radius));
+        boundingBox.union(range.getBox());
+    }
+    isPointInside(point, globalMatrix) {
+        const { centerA, centerB } = this.getCenters(globalMatrix);
+        const center = new Vector3().addVectors(centerA, centerB).divideScalar(2);
+        const vector = centerA.sub(centerB);
+        const height = vector.length();
+        vector.normalize();
+        const diff = center.sub(point);
+        const dot = vector.dot(diff);
+        vector.multiplyScalar(dot);
+        vector.sub(diff);
+        const distanceToAxis = vector.length();
+        // Check distance to axis
+        if (distanceToAxis > this.radius) {
+            return false;
+        }
+        // Check if it is inside along axis
+        if (Math.abs(dot) > height / 2) {
+            return false;
+        }
+        return true;
+    }
+    getPointsInside(points) {
+        // It could reused Cylinder.isPointInside, but this is a lot faster for many points
+        // as it avoids a extra memory allocations
+        const centerLine = new Line3(this.centerA, this.centerB);
+        const target = new Vector3();
+        return points.filter((point)=>{
+            const t = centerLine.closestPointToPointParameter(point, false);
+            if (t < 0 || t > 1) {
+                return false; // Not on line
+            }
+            const closestPoint = centerLine.at(t, target);
+            const distanceToAxis = closestPoint.distanceTo(point);
+            if (distanceToAxis > this.radius) {
+                return false; // Outside radius
+            }
+            return true;
+        });
+    }
+    intersectRay(ray, globalMatrix) {
+        const { centerA, centerB } = this.getCenters(globalMatrix);
+        const { radius } = this;
+        const rayOrigin = ray.origin;
+        const rayDirection = ray.direction;
+        const ba = new Vector3().subVectors(centerB, centerA);
+        const baRd = ba.dot(rayDirection);
+        // Inspired by : https://github.com/nhocki/Ray-Tracer/blob/master/objects/Cylinder.cpp
+        // Check the intersection with cap A
+        if (baRd > 0) {
+            const baCa = ba.dot(centerA);
+            const t = (baCa - ba.dot(rayOrigin)) / baRd;
+            const intersection = ray.at(t, new Vector3());
+            if (intersection.distanceTo(centerA) <= radius) {
+                return intersection;
+            }
+        }
+        // Check the intersection with cap B
+        if (baRd < 0) {
+            const baCb = ba.dot(centerB);
+            const t = (baCb - ba.dot(rayOrigin)) / baRd;
+            const intersection = ray.at(t, new Vector3());
+            if (intersection.distanceTo(centerB) <= radius) {
+                return intersection;
+            }
+        }
+        // Body
+        const oc = new Vector3().subVectors(rayOrigin, centerA);
+        const baBa = ba.dot(ba);
+        const baOc = ba.dot(oc);
+        const k2 = baBa - baRd * baRd;
+        const k1 = baBa * oc.dot(rayDirection) - baOc * baRd;
+        const k0 = baBa * oc.dot(oc) - baOc * baOc - radius * radius * baBa;
+        const discriminant = k1 * k1 - k2 * k0;
+        if (discriminant < 0.0) {
+            return undefined;
+        }
+        const sqrtH = Math.sqrt(discriminant);
+        const t = (-k1 - sqrtH) / k2;
+        const y = baOc + t * baRd;
+        if (y > 0.0 && y < baBa) {
+            return ray.at(t, new Vector3());
+        }
+        return undefined;
+    }
+    // ==================================================
+    // INSTANCE PROPERTIES
+    // ==================================================
+    get height() {
+        return this.centerA.distanceTo(this.centerB);
+    }
+    set height(value) {
+        const center = this.center;
+        const halfHeight = value * 0.5;
+        const axis = this.axis;
+        this.centerA.copy(center).addScaledVector(axis, -halfHeight);
+        this.centerB.copy(center).addScaledVector(axis, +halfHeight);
+    }
+    get center() {
+        return this._center.addVectors(this.centerB, this.centerA).divideScalar(2);
+    }
+    get size() {
+        return this._size.set(this.diameter, this.diameter, this.height);
+    }
+    get axis() {
+        return this._axis.subVectors(this.centerB, this.centerA).normalize();
+    }
+    get diameter() {
+        return 2 * this.radius;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Getters
+    // ==================================================
+    getRotationMatrix(matrix = new Matrix4()) {
+        matrix.identity();
+        return matrix.makeRotationFromQuaternion(this.getQuaternion());
+    }
+    getScaledMatrix(scale, matrix = new Matrix4()) {
+        return matrix.compose(this.center, this.getQuaternion(), scale);
+    }
+    getQuaternion() {
+        const quaternion = new Quaternion();
+        return quaternion.setFromUnitVectors(UP_AXIS, this.axis);
+    }
+    getCenters(globalMatrix) {
+        const centerA = this.centerA.clone();
+        const centerB = this.centerB.clone();
+        centerA.applyMatrix4(globalMatrix);
+        centerB.applyMatrix4(globalMatrix);
+        return {
+            centerA,
+            centerB
+        };
+    }
+    // ==================================================
+    // INSTANCE METHODS: Operations
+    // ==================================================
+    copy(cylinder) {
+        this.radius = cylinder.radius;
+        this.centerA.copy(cylinder.centerA);
+        this.centerB.copy(cylinder.centerB);
+        return this;
+    }
+    applyMatrix4(matrix) {
+        const scale = new Vector3().setFromMatrixScale(matrix);
+        if (!isEqual(scale.x, scale.y) || !isEqual(scale.x, scale.z)) {
+            console.warn('Cylinder.applyMatrix4: The matrix has non-uniform scale, result may be incorrect.');
+        }
+        this.centerA.applyMatrix4(matrix);
+        this.centerB.applyMatrix4(matrix);
+        this.radius *= scale.x;
+        return this;
+    }
+    clear() {
+        this.radius = Cylinder.MinSize;
+        this.centerA.set(0, 0, -Cylinder.HalfMinSize);
+        this.centerB.set(0, 0, +Cylinder.HalfMinSize);
+    }
+    forceMinSize() {
+        this.radius = Math.max(this.radius, Cylinder.MinSize);
+    }
+    // ==================================================
+    // STATIC METHODS:
+    // ==================================================
+    static isValidSize(value) {
+        return value > Cylinder.MinSize;
+    }
+    constructor(...args){
+        super(...args), // ==================================================
+        // INSTANCE FIELDS
+        // ==================================================
+        this.radius = Cylinder.MinSize, this.centerA = new Vector3(0, 0, -Cylinder.HalfMinSize), this.centerB = new Vector3(0, 0, +Cylinder.HalfMinSize), // Redundant variable, calculated when needed
+        this._center = new Vector3(), this._axis = new Vector3(), this._size = new Vector3();
+    }
+}
+
+//# sourceMappingURL=Cylinder.js.map

package/dist/foundation/utilities/primitives/Cylinder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/foundation/utilities/primitives/Cylinder.ts"],"sourcesContent":["import {\n  type Box3,\n  Line3,\n  Matrix4,\n  Quaternion,\n  type Ray,\n  Vector3,\n} from 'three';\n\nimport { isEqual, square } from '../extensions/mathUtils';\nimport { Range3 } from '../geometry/Range3';\n\nimport { Primitive } from './Primitive';\nimport { PrimitiveType } from './PrimitiveType';\n\nconst UP_AXIS = new Vector3(0, 0, 1);\n\nexport class Cylinder extends Primitive {\n  public static MinSize = 0.01;\n  public static HalfMinSize: number = Cylinder.MinSize * 0.5;\n\n  // ==================================================\n  // INSTANCE FIELDS\n  // ==================================================\n\n  public radius: number = Cylinder.MinSize;\n  public readonly centerA: Vector3 = new Vector3(0, 0, -Cylinder.HalfMinSize);\n  public readonly centerB: Vector3 = new Vector3(0, 0, +Cylinder.HalfMinSize);\n\n  // Redundant variable, calculated when needed\n  private readonly _center = new Vector3();\n  private readonly _axis = new Vector3();\n  private readonly _size = new Vector3();\n\n  public get endCapArea(): number {\n    return Math.PI * this.radius * this.radius;\n  }\n\n  // ==================================================\n  // OVERRIDES of Primitive\n  // ==================================================\n\n  public override get primitiveType(): PrimitiveType {\n    return PrimitiveType.Cylinder;\n  }\n\n  public override get area(): number {\n    return 2 * Math.PI * this.radius * this.height + 2 * this.endCapArea;\n  }\n\n  public override get volume(): number {\n    return Math.PI * square(this.radius) * this.height;\n  }\n\n  public override get diagonal(): number {\n    return Math.sqrt(square(this.radius) + square(this.height));\n  }\n\n  public override getMatrix(): Matrix4 {\n    return new Matrix4().compose(this.center, this.getQuaternion(), this.size);\n  }\n\n  public override setMatrix(matrix: Matrix4): void {\n    const centerA = new Vector3(0, 0, -0.5).applyMatrix4(matrix);\n    const centerB = new Vector3(0, 0, 0.5).applyMatrix4(matrix);\n    const scale = new Vector3().setFromMatrixScale(matrix);\n\n    this.centerA.copy(centerA);\n    this.centerB.copy(centerB);\n    this.radius = scale.x / 2;\n  }\n\n  public override expandBoundingBox(boundingBox: Box3): void {\n    const range = new Range3(this.centerA, this.centerB);\n    range.expandByMargin3(Range3.getCircleRangeMargin(this.axis, this.radius));\n    boundingBox.union(range.getBox());\n  }\n\n  public override isPointInside(\n    point: Vector3,\n    globalMatrix: Matrix4\n  ): boolean {\n    const { centerA, centerB } = this.getCenters(globalMatrix);\n    const center = new Vector3().addVectors(centerA, centerB).divideScalar(2);\n    const vector = centerA.sub(centerB);\n    const height = vector.length();\n    vector.normalize();\n\n    const diff = center.sub(point);\n    const dot = vector.dot(diff);\n    vector.multiplyScalar(dot);\n    vector.sub(diff);\n\n    const distanceToAxis = vector.length();\n    // Check distance to axis\n    if (distanceToAxis > this.radius) {\n      return false;\n    }\n    // Check if it is inside along axis\n    if (Math.abs(dot) > height / 2) {\n      return false;\n    }\n    return true;\n  }\n\n  public getPointsInside(points: Vector3[]): Vector3[] {\n    // It could reused Cylinder.isPointInside, but this is a lot faster for many points\n    // as it avoids a extra memory allocations\n    const centerLine = new Line3(this.centerA, this.centerB);\n    const target = new Vector3();\n    return points.filter((point) => {\n      const t = centerLine.closestPointToPointParameter(point, false);\n      if (t < 0 || t > 1) {\n        return false; // Not on line\n      }\n      const closestPoint = centerLine.at(t, target);\n      const distanceToAxis = closestPoint.distanceTo(point);\n      if (distanceToAxis > this.radius) {\n        return false; // Outside radius\n      }\n      return true;\n    });\n  }\n\n  public override intersectRay(\n    ray: Ray,\n    globalMatrix: Matrix4\n  ): Vector3 | undefined {\n    const { centerA, centerB } = this.getCenters(globalMatrix);\n    const { radius } = this;\n    const rayOrigin = ray.origin;\n    const rayDirection = ray.direction;\n    const ba = new Vector3().subVectors(centerB, centerA);\n    const baRd = ba.dot(rayDirection);\n\n    // Inspired by : https://github.com/nhocki/Ray-Tracer/blob/master/objects/Cylinder.cpp\n    // Check the intersection with cap A\n    if (baRd > 0) {\n      const baCa = ba.dot(centerA);\n      const t = (baCa - ba.dot(rayOrigin)) / baRd;\n      const intersection = ray.at(t, new Vector3());\n      if (intersection.distanceTo(centerA) <= radius) {\n        return intersection;\n      }\n    }\n    // Check the intersection with cap B\n    if (baRd < 0) {\n      const baCb = ba.dot(centerB);\n      const t = (baCb - ba.dot(rayOrigin)) / baRd;\n      const intersection = ray.at(t, new Vector3());\n      if (intersection.distanceTo(centerB) <= radius) {\n        return intersection;\n      }\n    }\n    // Body\n    const oc = new Vector3().subVectors(rayOrigin, centerA);\n    const baBa = ba.dot(ba);\n    const baOc = ba.dot(oc);\n    const k2 = baBa - baRd * baRd;\n    const k1 = baBa * oc.dot(rayDirection) - baOc * baRd;\n    const k0 = baBa * oc.dot(oc) - baOc * baOc - radius * radius * baBa;\n    const discriminant = k1 * k1 - k2 * k0;\n    if (discriminant < 0.0) {\n      return undefined;\n    }\n    const sqrtH = Math.sqrt(discriminant);\n    const t = (-k1 - sqrtH) / k2;\n    const y = baOc + t * baRd;\n    if (y > 0.0 && y < baBa) {\n      return ray.at(t, new Vector3());\n    }\n    return undefined;\n  }\n\n  // ==================================================\n  // INSTANCE PROPERTIES\n  // ==================================================\n\n  public get height(): number {\n    return this.centerA.distanceTo(this.centerB);\n  }\n\n  public set height(value: number) {\n    const center = this.center;\n    const halfHeight = value * 0.5;\n    const axis = this.axis;\n    this.centerA.copy(center).addScaledVector(axis, -halfHeight);\n    this.centerB.copy(center).addScaledVector(axis, +halfHeight);\n  }\n\n  public get center(): Vector3 {\n    return this._center.addVectors(this.centerB, this.centerA).divideScalar(2);\n  }\n\n  public get size(): Vector3 {\n    return this._size.set(this.diameter, this.diameter, this.height);\n  }\n\n  public get axis(): Vector3 {\n    return this._axis.subVectors(this.centerB, this.centerA).normalize();\n  }\n\n  public get diameter(): number {\n    return 2 * this.radius;\n  }\n\n  // ==================================================\n  // INSTANCE METHODS: Getters\n  // ==================================================\n\n  public getRotationMatrix(matrix: Matrix4 = new Matrix4()): Matrix4 {\n    matrix.identity();\n    return matrix.makeRotationFromQuaternion(this.getQuaternion());\n  }\n\n  public getScaledMatrix(\n    scale: Vector3,\n    matrix: Matrix4 = new Matrix4()\n  ): Matrix4 {\n    return matrix.compose(this.center, this.getQuaternion(), scale);\n  }\n\n  public getQuaternion(): Quaternion {\n    const quaternion = new Quaternion();\n    return quaternion.setFromUnitVectors(UP_AXIS, this.axis);\n  }\n\n  private getCenters(globalMatrix: Matrix4): {\n    centerA: Vector3;\n    centerB: Vector3;\n  } {\n    const centerA = this.centerA.clone();\n    const centerB = this.centerB.clone();\n    centerA.applyMatrix4(globalMatrix);\n    centerB.applyMatrix4(globalMatrix);\n    return { centerA, centerB };\n  }\n\n  // ==================================================\n  // INSTANCE METHODS: Operations\n  // ==================================================\n\n  public copy(cylinder: Cylinder): this {\n    this.radius = cylinder.radius;\n    this.centerA.copy(cylinder.centerA);\n    this.centerB.copy(cylinder.centerB);\n    return this;\n  }\n\n  public applyMatrix4(matrix: Matrix4): this {\n    const scale = new Vector3().setFromMatrixScale(matrix);\n    if (!isEqual(scale.x, scale.y) || !isEqual(scale.x, scale.z)) {\n      console.warn(\n        'Cylinder.applyMatrix4: The matrix has non-uniform scale, result may be incorrect.'\n      );\n    }\n    this.centerA.applyMatrix4(matrix);\n    this.centerB.applyMatrix4(matrix);\n    this.radius *= scale.x;\n    return this;\n  }\n\n  public clear(): void {\n    this.radius = Cylinder.MinSize;\n    this.centerA.set(0, 0, -Cylinder.HalfMinSize);\n    this.centerB.set(0, 0, +Cylinder.HalfMinSize);\n  }\n\n  public forceMinSize(): void {\n    this.radius = Math.max(this.radius, Cylinder.MinSize);\n  }\n\n  // ==================================================\n  // STATIC METHODS:\n  // ==================================================\n\n  public static isValidSize(value: number): boolean {\n    return value > Cylinder.MinSize;\n  }\n}\n"],"names":["Line3","Matrix4","Quaternion","Vector3","isEqual","square","Range3","Primitive","PrimitiveType","UP_AXIS","Cylinder","MinSize","HalfMinSize","endCapArea","Math","PI","radius","primitiveType","area","height","volume","diagonal","sqrt","getMatrix","compose","center","getQuaternion","size","setMatrix","matrix","centerA","applyMatrix4","centerB","scale","setFromMatrixScale","copy","x","expandBoundingBox","boundingBox","range","expandByMargin3","getCircleRangeMargin","axis","union","getBox","isPointInside","point","globalMatrix","getCenters","addVectors","divideScalar","vector","sub","length","normalize","diff","dot","multiplyScalar","distanceToAxis","abs","getPointsInside","points","centerLine","target","filter","t","closestPointToPointParameter","closestPoint","at","distanceTo","intersectRay","ray","rayOrigin","origin","rayDirection","direction","ba","subVectors","baRd","baCa","intersection","baCb","oc","baBa","baOc","k2","k1","k0","discriminant","undefined","sqrtH","y","value","halfHeight","addScaledVector","_center","_size","set","diameter","_axis","getRotationMatrix","identity","makeRotationFromQuaternion","getScaledMatrix","quaternion","setFromUnitVectors","clone","cylinder","z","console","warn","clear","forceMinSize","max","isValidSize"],"mappings":"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"}

package/dist/foundation/utilities/primitives/CylinderUtils.d.ts

@@ -1,8 +1,8 @@
-import { BufferGeometry, CylinderGeometry } from 'three';
-import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+import { type BufferGeometry, CylinderGeometry } from "three";
+import { type LineSegmentsGeometry } from "three/examples/jsm/lines/LineSegmentsGeometry.js";
 export declare class CylinderUtils {
-    static createUnitGeometry(): CylinderGeometry;
-    static createLineSegmentsGeometry(): LineSegmentsGeometry;
-    static createPositions(): number[];
-    static createLineSegmentsBufferGeometry(): BufferGeometry;
+	static createUnitGeometry(): CylinderGeometry;
+	static createLineSegmentsGeometry(): LineSegmentsGeometry;
+	static createPositions(): number[];
+	static createLineSegmentsBufferGeometry(): BufferGeometry;
 }

package/dist/foundation/utilities/primitives/CylinderUtils.js

@@ -1,34 +1,58 @@
-import { PrimitiveUtils as e } from "./PrimitiveUtils.js";
-import { CylinderGeometry as t } from "three";
-//#region libs/shared/reveal-components/src/foundation/utilities/primitives/CylinderUtils.ts
-var n = .5, r = 5, i = 30, a = class a {
-	static createUnitGeometry() {
-		return new t(n, n, 1, i);
-	}
-	static createLineSegmentsGeometry() {
-		let t = a.createPositions();
-		return e.createLineSegmentsGeometryByPosition(t);
-	}
-	static createPositions() {
-		let t = 2 * Math.PI / i, a = [];
-		for (let e = 0; e <= i; e++) {
-			let r = e * t;
-			a.push(n * Math.sin(r)), a.push(n * Math.cos(r)), a.push(-.5);
-		}
-		for (let e = 0; e <= i; e++) {
-			let r = e * t;
-			a.push(n * Math.sin(r)), a.push(n * Math.cos(r)), a.push(n);
-		}
-		let o = [];
-		for (let e = 0; e < i; e++) o.push(e, e + 1);
-		for (let e = 0; e < i; e++) o.push(e + 31, e + 1 + 31);
-		for (let e = 0; e < i; e += r) o.push(e, e + 31);
-		return e.createLineSegmentsAsPositions(a, o);
-	}
-	static createLineSegmentsBufferGeometry() {
-		let t = a.createPositions();
-		return e.createBufferGeometry(t);
-	}
-};
-//#endregion
-export { a as CylinderUtils };
+import { CylinderGeometry } from "three";
+import { PrimitiveUtils } from "./PrimitiveUtils.js";
+const RADIUS = 0.5;
+const SEGMENTS_BETWEEN_CIRCLES = 5;
+const TOTAL_SEGMENTS = SEGMENTS_BETWEEN_CIRCLES * 6;
+export class CylinderUtils {
+    static createUnitGeometry() {
+        return new CylinderGeometry(RADIUS, RADIUS, 1, TOTAL_SEGMENTS);
+    }
+    static createLineSegmentsGeometry() {
+        const positions = CylinderUtils.createPositions();
+        return PrimitiveUtils.createLineSegmentsGeometryByPosition(positions);
+    }
+    static createPositions() {
+        // Define cylinder properties
+        const angleIncrement = 2 * Math.PI / TOTAL_SEGMENTS;
+        // Define the positions for the top and bottom circles of the cylinder
+        const positions = [];
+        // Bottom circle positions
+        for(let i = 0; i <= TOTAL_SEGMENTS; i++){
+            const angle = i * angleIncrement;
+            positions.push(RADIUS * Math.sin(angle)); // x-coordinate
+            positions.push(RADIUS * Math.cos(angle)); // y-coordinate
+            positions.push(-RADIUS); // z-coordinate (fixed for bottom circle)
+        }
+        // Top circle positions
+        for(let i = 0; i <= TOTAL_SEGMENTS; i++){
+            const angle = i * angleIncrement;
+            positions.push(RADIUS * Math.sin(angle)); // x-coordinate
+            positions.push(RADIUS * Math.cos(angle)); // y-coordinate
+            positions.push(RADIUS); // z-coordinate (fixed for top circle)
+        }
+        // Define the indices to form line segments of the cylinder
+        const indices = [];
+        // Indices for the bottom circle
+        for(let i = 0; i < TOTAL_SEGMENTS; i++){
+            indices.push(i, i + 1);
+        }
+        // Indices for the top circle
+        const topCircleOffset = 1 + TOTAL_SEGMENTS;
+        for(let i = 0; i < TOTAL_SEGMENTS; i++){
+            indices.push(i + topCircleOffset, i + 1 + topCircleOffset);
+        }
+        // Indices connecting top and bottom circles
+        for(let i = 0; i < TOTAL_SEGMENTS; i += SEGMENTS_BETWEEN_CIRCLES){
+            indices.push(i, i + topCircleOffset);
+        }
+        // This is maybe a silly solution, but I will keep it like this because
+        // we may change to indexed BufferGeometry later on.
+        return PrimitiveUtils.createLineSegmentsAsPositions(positions, indices);
+    }
+    static createLineSegmentsBufferGeometry() {
+        const positions = CylinderUtils.createPositions();
+        return PrimitiveUtils.createBufferGeometry(positions);
+    }
+}
+
+//# sourceMappingURL=CylinderUtils.js.map

package/dist/foundation/utilities/primitives/CylinderUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/foundation/utilities/primitives/CylinderUtils.ts"],"sourcesContent":["import { type BufferGeometry, CylinderGeometry } from 'three';\nimport { type LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';\n\nimport { PrimitiveUtils } from './PrimitiveUtils';\n\nconst RADIUS = 0.5;\nconst SEGMENTS_BETWEEN_CIRCLES = 5;\nconst TOTAL_SEGMENTS = SEGMENTS_BETWEEN_CIRCLES * 6;\n\nexport class CylinderUtils {\n  public static createUnitGeometry(): CylinderGeometry {\n    return new CylinderGeometry(RADIUS, RADIUS, 1, TOTAL_SEGMENTS);\n  }\n\n  public static createLineSegmentsGeometry(): LineSegmentsGeometry {\n    const positions = CylinderUtils.createPositions();\n    return PrimitiveUtils.createLineSegmentsGeometryByPosition(positions);\n  }\n\n  public static createPositions(): number[] {\n    // Define cylinder properties\n    const angleIncrement = (2 * Math.PI) / TOTAL_SEGMENTS;\n\n    // Define the positions for the top and bottom circles of the cylinder\n    const positions: number[] = [];\n\n    // Bottom circle positions\n    for (let i = 0; i <= TOTAL_SEGMENTS; i++) {\n      const angle = i * angleIncrement;\n      positions.push(RADIUS * Math.sin(angle)); // x-coordinate\n      positions.push(RADIUS * Math.cos(angle)); // y-coordinate\n      positions.push(-RADIUS); // z-coordinate (fixed for bottom circle)\n    }\n\n    // Top circle positions\n    for (let i = 0; i <= TOTAL_SEGMENTS; i++) {\n      const angle = i * angleIncrement;\n      positions.push(RADIUS * Math.sin(angle)); // x-coordinate\n      positions.push(RADIUS * Math.cos(angle)); // y-coordinate\n      positions.push(RADIUS); // z-coordinate (fixed for top circle)\n    }\n\n    // Define the indices to form line segments of the cylinder\n    const indices: number[] = [];\n\n    // Indices for the bottom circle\n    for (let i = 0; i < TOTAL_SEGMENTS; i++) {\n      indices.push(i, i + 1);\n    }\n    // Indices for the top circle\n    const topCircleOffset = 1 + TOTAL_SEGMENTS;\n    for (let i = 0; i < TOTAL_SEGMENTS; i++) {\n      indices.push(i + topCircleOffset, i + 1 + topCircleOffset);\n    }\n\n    // Indices connecting top and bottom circles\n    for (let i = 0; i < TOTAL_SEGMENTS; i += SEGMENTS_BETWEEN_CIRCLES) {\n      indices.push(i, i + topCircleOffset);\n    }\n    // This is maybe a silly solution, but I will keep it like this because\n    // we may change to indexed BufferGeometry later on.\n    return PrimitiveUtils.createLineSegmentsAsPositions(positions, indices);\n  }\n\n  public static createLineSegmentsBufferGeometry(): BufferGeometry {\n    const positions = CylinderUtils.createPositions();\n    return PrimitiveUtils.createBufferGeometry(positions);\n  }\n}\n"],"names":["CylinderGeometry","PrimitiveUtils","RADIUS","SEGMENTS_BETWEEN_CIRCLES","TOTAL_SEGMENTS","CylinderUtils","createUnitGeometry","createLineSegmentsGeometry","positions","createPositions","createLineSegmentsGeometryByPosition","angleIncrement","Math","PI","i","angle","push","sin","cos","indices","topCircleOffset","createLineSegmentsAsPositions","createLineSegmentsBufferGeometry","createBufferGeometry"],"mappings":"AAAA,SAA8BA,gBAAgB,QAAQ,QAAQ;AAG9D,SAASC,cAAc,QAAQ,sBAAmB;AAElD,MAAMC,SAAS;AACf,MAAMC,2BAA2B;AACjC,MAAMC,iBAAiBD,2BAA2B;AAElD,OAAO,MAAME;IACX,OAAcC,qBAAuC;QACnD,OAAO,IAAIN,iBAAiBE,QAAQA,QAAQ,GAAGE;IACjD;IAEA,OAAcG,6BAAmD;QAC/D,MAAMC,YAAYH,cAAcI,eAAe;QAC/C,OAAOR,eAAeS,oCAAoC,CAACF;IAC7D;IAEA,OAAcC,kBAA4B;QACxC,6BAA6B;QAC7B,MAAME,iBAAiB,AAAC,IAAIC,KAAKC,EAAE,GAAIT;QAEvC,sEAAsE;QACtE,MAAMI,YAAsB,EAAE;QAE9B,0BAA0B;QAC1B,IAAK,IAAIM,IAAI,GAAGA,KAAKV,gBAAgBU,IAAK;YACxC,MAAMC,QAAQD,IAAIH;YAClBH,UAAUQ,IAAI,CAACd,SAASU,KAAKK,GAAG,CAACF,SAAS,eAAe;YACzDP,UAAUQ,IAAI,CAACd,SAASU,KAAKM,GAAG,CAACH,SAAS,eAAe;YACzDP,UAAUQ,IAAI,CAAC,CAACd,SAAS,yCAAyC;QACpE;QAEA,uBAAuB;QACvB,IAAK,IAAIY,IAAI,GAAGA,KAAKV,gBAAgBU,IAAK;YACxC,MAAMC,QAAQD,IAAIH;YAClBH,UAAUQ,IAAI,CAACd,SAASU,KAAKK,GAAG,CAACF,SAAS,eAAe;YACzDP,UAAUQ,IAAI,CAACd,SAASU,KAAKM,GAAG,CAACH,SAAS,eAAe;YACzDP,UAAUQ,IAAI,CAACd,SAAS,sCAAsC;QAChE;QAEA,2DAA2D;QAC3D,MAAMiB,UAAoB,EAAE;QAE5B,gCAAgC;QAChC,IAAK,IAAIL,IAAI,GAAGA,IAAIV,gBAAgBU,IAAK;YACvCK,QAAQH,IAAI,CAACF,GAAGA,IAAI;QACtB;QACA,6BAA6B;QAC7B,MAAMM,kBAAkB,IAAIhB;QAC5B,IAAK,IAAIU,IAAI,GAAGA,IAAIV,gBAAgBU,IAAK;YACvCK,QAAQH,IAAI,CAACF,IAAIM,iBAAiBN,IAAI,IAAIM;QAC5C;QAEA,4CAA4C;QAC5C,IAAK,IAAIN,IAAI,GAAGA,IAAIV,gBAAgBU,KAAKX,yBAA0B;YACjEgB,QAAQH,IAAI,CAACF,GAAGA,IAAIM;QACtB;QACA,uEAAuE;QACvE,oDAAoD;QACpD,OAAOnB,eAAeoB,6BAA6B,CAACb,WAAWW;IACjE;IAEA,OAAcG,mCAAmD;QAC/D,MAAMd,YAAYH,cAAcI,eAAe;QAC/C,OAAOR,eAAesB,oBAAoB,CAACf;IAC7C;AACF"}

package/dist/foundation/utilities/primitives/Primitive.d.ts

@@ -1,16 +1,16 @@
-import { Box3, Ray, Vector3, Matrix4 } from 'three';
-import { PrimitiveType } from './PrimitiveType';
+import { Box3, type Ray, type Vector3, type Matrix4 } from "three";
+import { type PrimitiveType } from "./PrimitiveType";
 export declare abstract class Primitive {
-    confidence: number | undefined;
-    label: string | undefined;
-    abstract get primitiveType(): PrimitiveType;
-    abstract get volume(): number;
-    abstract get area(): number;
-    abstract get diagonal(): number;
-    abstract getMatrix(): Matrix4;
-    abstract setMatrix(matrix: Matrix4): void;
-    abstract expandBoundingBox(boundingBox: Box3): void;
-    abstract isPointInside(point: Vector3, globalMatrix: Matrix4): boolean;
-    abstract intersectRay(ray: Ray, globalMatrix: Matrix4): Vector3 | undefined;
-    getBoundingBox(): Box3;
+	confidence: number | undefined;
+	label: string | undefined;
+	abstract get primitiveType(): PrimitiveType;
+	abstract get volume(): number;
+	abstract get area(): number;
+	abstract get diagonal(): number;
+	abstract getMatrix(): Matrix4;
+	abstract setMatrix(matrix: Matrix4): void;
+	abstract expandBoundingBox(boundingBox: Box3): void;
+	abstract isPointInside(point: Vector3, globalMatrix: Matrix4): boolean;
+	abstract intersectRay(ray: Ray, globalMatrix: Matrix4): Vector3 | undefined;
+	getBoundingBox(): Box3;
 }

package/dist/foundation/utilities/primitives/Primitive.js

@@ -1,12 +1,20 @@
-import { Box3 as e } from "three";
-//#region libs/shared/reveal-components/src/foundation/utilities/primitives/Primitive.ts
-var t = class {
-	confidence = void 0;
-	label = void 0;
-	getBoundingBox() {
-		let t = new e().makeEmpty();
-		return this.expandBoundingBox(t), t;
-	}
-};
-//#endregion
-export { t as Primitive };
+import { Box3 } from "three";
+export class Primitive {
+    // ==================================================
+    // INSTANCE METHODS
+    // ==================================================
+    getBoundingBox() {
+        const boundingBox = new Box3().makeEmpty();
+        this.expandBoundingBox(boundingBox);
+        return boundingBox;
+    }
+    constructor(){
+        // ==================================================
+        // INSTANCE FIELDS
+        // ==================================================
+        this.confidence = undefined;
+        this.label = undefined;
+    }
+}
+
+//# sourceMappingURL=Primitive.js.map

package/dist/foundation/utilities/primitives/Primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/foundation/utilities/primitives/Primitive.ts"],"sourcesContent":["import { Box3, type Ray, type Vector3, type Matrix4 } from 'three';\n\nimport { type PrimitiveType } from './PrimitiveType';\n\nexport abstract class Primitive {\n  // ==================================================\n  // INSTANCE FIELDS\n  // ==================================================\n\n  public confidence: number | undefined = undefined;\n  public label: string | undefined = undefined;\n\n  // ==================================================\n  // VIRTUAL METHODS\n  // ==================================================\n\n  public abstract get primitiveType(): PrimitiveType;\n  public abstract get volume(): number;\n  public abstract get area(): number;\n  public abstract get diagonal(): number;\n\n  public abstract getMatrix(): Matrix4;\n  public abstract setMatrix(matrix: Matrix4): void;\n  public abstract expandBoundingBox(boundingBox: Box3): void;\n\n  public abstract isPointInside(point: Vector3, globalMatrix: Matrix4): boolean;\n  public abstract intersectRay(\n    ray: Ray,\n    globalMatrix: Matrix4\n  ): Vector3 | undefined;\n\n  // ==================================================\n  // INSTANCE METHODS\n  // ==================================================\n\n  public getBoundingBox(): Box3 {\n    const boundingBox = new Box3().makeEmpty();\n    this.expandBoundingBox(boundingBox);\n    return boundingBox;\n  }\n}\n"],"names":["Box3","Primitive","getBoundingBox","boundingBox","makeEmpty","expandBoundingBox","confidence","undefined","label"],"mappings":"AAAA,SAASA,IAAI,QAA8C,QAAQ;AAInE,OAAO,MAAeC;IA2BpB,qDAAqD;IACrD,mBAAmB;IACnB,qDAAqD;IAE9CC,iBAAuB;QAC5B,MAAMC,cAAc,IAAIH,OAAOI,SAAS;QACxC,IAAI,CAACC,iBAAiB,CAACF;QACvB,OAAOA;IACT;;QAlCA,qDAAqD;QACrD,kBAAkB;QAClB,qDAAqD;aAE9CG,aAAiCC;aACjCC,QAA4BD;;AA8BrC"}

package/dist/foundation/utilities/primitives/PrimitiveType.d.ts

@@ -1,21 +1,21 @@
 export declare enum PrimitiveType {
-    None = 0,
-    Point = 1,
-    Line = 2,
-    Polyline = 3,
-    Polygon = 4,
-    HorizontalArea = 5,
-    VerticalArea = 6,
-    Box = 7,
-    Cylinder = 8,
-    HorizontalCircle = 9,
-    HorizontalCylinder = 10,
-    VerticalCylinder = 11,
-    Diameter = 12,
-    PlaneX = 13,
-    PlaneY = 14,
-    PlaneZ = 15,
-    PlaneXY = 16
+	None = 0,
+	Point = 1,
+	Line = 2,
+	Polyline = 3,
+	Polygon = 4,
+	HorizontalArea = 5,
+	VerticalArea = 6,
+	Box = 7,
+	Cylinder = 8,
+	HorizontalCircle = 9,
+	HorizontalCylinder = 10,
+	VerticalCylinder = 11,
+	Diameter = 12,
+	PlaneX = 13,
+	PlaneY = 14,
+	PlaneZ = 15,
+	PlaneXY = 16
 }
 export declare const AlongAxisPlanePrimitiveTypes: PrimitiveType[];
 export declare const PlanePrimitiveTypes: PrimitiveType[];