@bitbybit-dev/base 0.20.1 → 0.20.3

package/lib/api/services/line.js

@@ -0,0 +1,320 @@
+/**
+ * Contains various methods for lines and segments. Line in bitbybit is a simple object that has start and end point properties.
+ * { start: [ x, y, z ], end: [ x, y, z ] }
+ */
+export class Line {
+    constructor(vector, point, geometryHelper) {
+        this.vector = vector;
+        this.point = point;
+        this.geometryHelper = geometryHelper;
+    }
+    /**
+     * Gets the start point of the line
+     * @param inputs a line
+     * @returns start point
+     * @group get
+     * @shortname line start point
+     * @drawable true
+     */
+    getStartPoint(inputs) {
+        return inputs.line.start;
+    }
+    /**
+     * Gets the end point of the line
+     * @param inputs a line
+     * @returns end point
+     * @group get
+     * @shortname line end point
+     * @drawable true
+     */
+    getEndPoint(inputs) {
+        return inputs.line.end;
+    }
+    /**
+     * Gets the length of the line
+     * @param inputs a line
+     * @returns line length
+     * @group get
+     * @shortname line length
+     * @drawable false
+     */
+    length(inputs) {
+        return this.point.distance({ startPoint: inputs.line.start, endPoint: inputs.line.end });
+    }
+    /**
+     * Reverse the endpoints of the line
+     * @param inputs a line
+     * @returns reversed line
+     * @group operations
+     * @shortname reversed line
+     * @drawable true
+     */
+    reverse(inputs) {
+        return { start: inputs.line.end, end: inputs.line.start };
+    }
+    /**
+     * Transform the line
+     * @param inputs a line
+     * @returns transformed line
+     * @group transforms
+     * @shortname transform line
+     * @drawable true
+     */
+    transformLine(inputs) {
+        const transformation = inputs.transformation;
+        let transformedControlPoints = [inputs.line.start, inputs.line.end];
+        transformedControlPoints = this.geometryHelper.transformControlPoints(transformation, transformedControlPoints);
+        return {
+            start: transformedControlPoints[0],
+            end: transformedControlPoints[1]
+        };
+    }
+    /**
+     * Transforms the lines with multiple transform for each line
+     * @param inputs lines
+     * @returns transformed lines
+     * @group transforms
+     * @shortname transform lines
+     * @drawable true
+     */
+    transformsForLines(inputs) {
+        return inputs.lines.map((line, index) => {
+            const transformation = inputs.transformation[index];
+            let transformedControlPoints = [line.start, line.end];
+            transformedControlPoints = this.geometryHelper.transformControlPoints(transformation, transformedControlPoints);
+            return {
+                start: transformedControlPoints[0],
+                end: transformedControlPoints[1]
+            };
+        });
+    }
+    /**
+     * Create the line
+     * @param inputs start and end points of the line
+     * @returns line
+     * @group create
+     * @shortname line
+     * @drawable true
+     */
+    create(inputs) {
+        return {
+            start: inputs.start,
+            end: inputs.end,
+        };
+    }
+    /**
+     * Gets the point on the line segment at a given param
+     * @param inputs line
+     * @returns point on line
+     * @group get
+     * @shortname point on line
+     * @drawable true
+     */
+    getPointOnLine(inputs) {
+        // Calculate direction vector of line segment
+        const point1 = inputs.line.start;
+        const point2 = inputs.line.end;
+        const parameter = inputs.param;
+        const direction = [point2[0] - point1[0], point2[1] - point1[1], point2[2] - point1[2]];
+        // Calculate point on line segment corresponding to parameter value
+        const point = [point1[0] + parameter * direction[0], point1[1] + parameter * direction[1], point1[2] + parameter * direction[2]];
+        return point;
+    }
+    /**
+     * Create the lines segments between all of the points in a list
+     * @param inputs points
+     * @returns lines
+     * @group create
+     * @shortname lines between points
+     * @drawable true
+     */
+    linesBetweenPoints(inputs) {
+        const lines = [];
+        for (let i = 1; i < inputs.points.length; i++) {
+            const previousPoint = inputs.points[i - 1];
+            const currentPoint = inputs.points[i];
+            lines.push({ start: previousPoint, end: currentPoint });
+        }
+        return lines;
+    }
+    /**
+     * Create the lines between start and end points
+     * @param inputs start points and end points
+     * @returns lines
+     * @group create
+     * @shortname start and end points to lines
+     * @drawable true
+     */
+    linesBetweenStartAndEndPoints(inputs) {
+        return inputs.startPoints
+            .map((s, index) => ({ start: s, end: inputs.endPoints[index] }))
+            .filter(line => this.point.distance({ startPoint: line.start, endPoint: line.end }) !== 0);
+    }
+    /**
+     * Convert the line to segment
+     * @param inputs line
+     * @returns segment
+     * @group convert
+     * @shortname line to segment
+     * @drawable false
+     */
+    lineToSegment(inputs) {
+        return [inputs.line.start, inputs.line.end];
+    }
+    /**
+     * Converts the lines to segments
+     * @param inputs lines
+     * @returns segments
+     * @group convert
+     * @shortname lines to segments
+     * @drawable false
+     */
+    linesToSegments(inputs) {
+        return inputs.lines.map(line => [line.start, line.end]);
+    }
+    /**
+     * Converts the segment to line
+     * @param inputs segment
+     * @returns line
+     * @group convert
+     * @shortname segment to line
+     * @drawable true
+     */
+    segmentToLine(inputs) {
+        return { start: inputs.segment[0], end: inputs.segment[1] };
+    }
+    /**
+     * Converts the segments to lines
+     * @param inputs segments
+     * @returns lines
+     * @group convert
+     * @shortname segments to lines
+     * @drawable true
+     */
+    segmentsToLines(inputs) {
+        return inputs.segments.map(segment => ({ start: segment[0], end: segment[1] }));
+    }
+    /**
+     * If two lines intersect return the intersection point
+     * @param inputs line1 and line2
+     * @returns intersection point or undefined if no intersection
+     * @group intersection
+     * @shortname line-line int
+     * @drawable true
+     */
+    lineLineIntersection(inputs) {
+        const epsilon = inputs.tolerance || 1e-6; // Default tolerance
+        const checkSegments = inputs.checkSegmentsOnly;
+        const line1 = inputs.line1;
+        const line2 = inputs.line2;
+        // Input validation
+        if (!(line1 === null || line1 === void 0 ? void 0 : line1.start) || !line1.end || !(line2 === null || line2 === void 0 ? void 0 : line2.start) || !line2.end ||
+            line1.start.length !== 3 || line1.end.length !== 3 ||
+            line2.start.length !== 3 || line2.end.length !== 3) {
+            console.error("Invalid line input to lineLineIntersection");
+            return undefined;
+        }
+        const p1 = line1.start;
+        const d1 = this.vector.sub({ first: line1.end, second: line1.start }); // Direction vector line 1
+        const p2 = line2.start;
+        const d2 = this.vector.sub({ first: line2.end, second: line2.start }); // Direction vector line 2
+        const p21 = this.vector.sub({ first: p2, second: p1 }); // Vector between start points
+        // --- Check for Zero-Length Segments ---
+        const lenSq1 = this.vector.lengthSq({ vector: d1 });
+        const lenSq2 = this.vector.lengthSq({ vector: d2 });
+        // Compare squared length against squared epsilon
+        if (lenSq1 < epsilon * epsilon || lenSq2 < epsilon * epsilon) {
+            return undefined;
+        }
+        // --- Check for Parallelism ---
+        const d1_cross_d2 = this.vector.cross({ first: d1, second: d2 });
+        const crossMagSq = this.vector.lengthSq({ vector: d1_cross_d2 });
+        // Check if squared magnitude of cross product is near zero (relative to segment lengths)
+        // Use epsilon squared as a base tolerance, potentially scale by magnitudes
+        const parallel_tolerance_sq = epsilon * epsilon; // May need adjustment: * lenSq1 * lenSq2;
+        if (crossMagSq < parallel_tolerance_sq) {
+            // Potentially Parallel or Collinear
+            // Check if collinear: p21 must be parallel to d1
+            const p21_cross_d1 = this.vector.cross({ first: p21, second: d1 });
+            // Use similar tolerance logic for collinear check
+            const collinear_tolerance_sq = epsilon * epsilon * lenSq1; // Scale by line1 length
+            if (this.vector.lengthSq({ vector: p21_cross_d1 }) < collinear_tolerance_sq) {
+                // Collinear
+                if (!checkSegments) {
+                    return p1; // Infinite lines intersect everywhere, return p1 arbitrarily
+                }
+                else {
+                    // --- Check for Segment Overlap (Collinear case) ---
+                    const d1d1 = lenSq1; // Reuse calculated squared length
+                    // Avoid division by zero if lenSq1 is extremely small (should be caught earlier)
+                    const safe_d1d1 = (d1d1 < epsilon * epsilon) ? 1.0 : d1d1;
+                    const d1p21 = this.vector.dot({ first: d1, second: p21 }); // Dot product d1·(p2-p1)
+                    const t_p2 = d1p21 / safe_d1d1; // Parameter for p2 projected onto line1's frame
+                    const vec_e2_p1 = this.vector.sub({ first: line2.end, second: p1 });
+                    const t_e2 = this.vector.dot({ first: d1, second: vec_e2_p1 }) / safe_d1d1; // Param for e2
+                    const interval2_t = [Math.min(t_p2, t_e2), Math.max(t_p2, t_e2)];
+                    const interval1_t = [0, 1]; // Line1 segment parameter range
+                    const overlap_start = Math.max(interval1_t[0], interval2_t[0]);
+                    const overlap_end = Math.min(interval1_t[1], interval2_t[1]);
+                    // Check for overlap including tolerance
+                    if (overlap_start <= overlap_end + epsilon) {
+                        // Overlap exists, but intersection is a segment, not a single point
+                        return undefined;
+                    }
+                    else {
+                        // Collinear but segments do not overlap
+                        return undefined;
+                    }
+                }
+            }
+            else {
+                // Parallel but not collinear
+                return undefined;
+            }
+        }
+        // --- Lines are NOT Parallel - Check for Skewness using Scalar Triple Product ---
+        const scalarTripleProduct = this.vector.dot({ first: p21, second: d1_cross_d2 });
+        // If the scalar triple product is significantly non-zero, the lines are skew.
+        // Tolerance needs consideration - relates to the "volume" formed by the vectors.
+        // A simple absolute check against epsilon^3 or similar might work for typical scales.
+        // Consider scaling tolerance if coordinates can be very large/small.
+        const skew_tolerance = epsilon * epsilon * epsilon;
+        if (Math.abs(scalarTripleProduct) > skew_tolerance) {
+            // Lines are Skew
+            return undefined;
+        }
+        // --- Lines are Intersecting (Coplanar and Non-Parallel) ---
+        // Calculate intersection parameters t (for line1) and u (for line2)
+        // We can use the formulas derived earlier, which are valid for intersecting lines.
+        const d1d1 = lenSq1;
+        const d2d2 = lenSq2;
+        const d1d2 = this.vector.dot({ first: d1, second: d2 });
+        const d1p21 = this.vector.dot({ first: d1, second: p21 });
+        const d2p21 = this.vector.dot({ first: d2, second: p21 });
+        // Denominator for parameter calculation (same as crossMagSq, essentially)
+        const denominator = d1d1 * d2d2 - d1d2 * d1d2;
+        // Denominator *should* be non-zero based on the parallelism check above,
+        // but add a defensive check.
+        if (Math.abs(denominator) < epsilon * epsilon) {
+            console.error("Internal error: Denominator near zero after non-parallel check.");
+            return undefined; // Should not happen
+        }
+        const t = (d2d2 * d1p21 - d1d2 * d2p21) / denominator;
+        const u = (d1d2 * d1p21 - d1d1 * d2p21) / denominator;
+        // --- Optional check: Is intersection within segment bounds? ---
+        if (checkSegments) {
+            // Check if t and u are within the range [0, 1] (using tolerance)
+            if (t < -epsilon || t > 1.0 + epsilon || u < -epsilon || u > 1.0 + epsilon) {
+                return undefined; // Intersection point is outside one or both segments
+            }
+        }
+        // --- Calculate Intersection Point ---
+        const intersectionPoint = this.getPointOnLine({ param: t, line: line1 });
+        // Clip near-zero results based on the input epsilon
+        return [
+            Math.abs(intersectionPoint[0]) < epsilon ? 0 : intersectionPoint[0],
+            Math.abs(intersectionPoint[1]) < epsilon ? 0 : intersectionPoint[1],
+            Math.abs(intersectionPoint[2]) < epsilon ? 0 : intersectionPoint[2],
+        ];
+    }
+}

package/lib/api/services/lists.d.ts

@@ -95,7 +95,7 @@ export declare class Lists {
      * @shortname group elements
      * @drawable false
      */
-    groupNth<T>(inputs: Inputs.Lists.GroupListDto<T>): T[];
+    groupNth<T>(inputs: Inputs.Lists.GroupListDto<T>): T[][];
     /**
      * Get the depth of the list
      * @param inputs a list

package/lib/api/services/lists.js

@@ -267,13 +267,12 @@ export class Lists {
                     result.push(currentGroup);
                     currentGroup = [];
                 }
-                if (keepRemainder && index === list.length - 1) {
+                if (currentGroup.length > 0 && keepRemainder && index === list.length - 1) {
                     result.push(currentGroup);
                 }
             });
             return result;
         };
-        // TODO make this work on any level
         return groupElements(inputs);
     }
     /**

package/lib/api/services/mesh.d.ts

@@ -0,0 +1,66 @@
+import * as Inputs from "../inputs";
+import { Polyline } from "./polyline";
+import { Vector } from "./vector";
+/**
+ * Contains various mesh helper methods that are not necessarily present in higher level CAD kernels that bitbybit is using.
+ */
+export declare class MeshBitByBit {
+    private readonly vector;
+    private readonly polyline;
+    constructor(vector: Vector, polyline: Polyline);
+    /**
+     * Computes the signed distance from a point to a plane.
+     * @param inputs a point and a plane
+     * @returns signed distance
+     * @group base
+     * @shortname signed dist to plane
+     * @drawable false
+     */
+    signedDistanceToPlane(inputs: Inputs.Mesh.SignedDistanceFromPlaneToPointDto): number;
+    /**
+     * Calculates the triangle plane from triangle.
+     * @param inputs triangle and tolerance
+     * @returns triangle plane
+     * @group traingle
+     * @shortname triangle plane
+     * @drawable false
+     */
+    calculateTrianglePlane(inputs: Inputs.Mesh.TriangleToleranceDto): Inputs.Base.TrianglePlane3 | undefined;
+    /**
+     * Calculates the intersection of two triangles.
+     * @param inputs first triangle, second triangle, and tolerance
+     * @returns intersection segment or undefined if no intersection
+     * @group traingle
+     * @shortname triangle-triangle int
+     * @drawable false
+     */
+    triangleTriangleIntersection(inputs: Inputs.Mesh.TriangleTriangleToleranceDto): Inputs.Base.Segment3 | undefined;
+    /**
+     * Computes the intersection segments of two meshes.
+     * @param inputs first mesh, second mesh, and tolerance
+     * @returns array of intersection segments
+     * @group mesh
+     * @shortname mesh-mesh int segments
+     * @drawable false
+     */
+    meshMeshIntersectionSegments(inputs: Inputs.Mesh.MeshMeshToleranceDto): Inputs.Base.Segment3[];
+    /**
+     * Computes the intersection polylines of two meshes.
+     * @param inputs first mesh, second mesh, and tolerance
+     * @returns array of intersection polylines
+     * @group mesh
+     * @shortname mesh-mesh int polylines
+     * @drawable true
+     */
+    meshMeshIntersectionPolylines(inputs: Inputs.Mesh.MeshMeshToleranceDto): Inputs.Base.Polyline3[];
+    /**
+     * Computes the intersection points of two meshes.
+     * @param inputs first mesh, second mesh, and tolerance
+     * @returns array of intersection points
+     * @group mesh
+     * @shortname mesh-mesh int points
+     * @drawable false
+     */
+    meshMeshIntersectionPoints(inputs: Inputs.Mesh.MeshMeshToleranceDto): Inputs.Base.Point3[][];
+    private computeIntersectionPoint;
+}

package/lib/api/services/mesh.js

@@ -0,0 +1,235 @@
+/**
+ * Contains various mesh helper methods that are not necessarily present in higher level CAD kernels that bitbybit is using.
+ */
+export class MeshBitByBit {
+    constructor(vector, polyline) {
+        this.vector = vector;
+        this.polyline = polyline;
+    }
+    /**
+     * Computes the signed distance from a point to a plane.
+     * @param inputs a point and a plane
+     * @returns signed distance
+     * @group base
+     * @shortname signed dist to plane
+     * @drawable false
+     */
+    signedDistanceToPlane(inputs) {
+        return this.vector.dot({ first: inputs.plane.normal, second: inputs.point }) - inputs.plane.d;
+    }
+    /**
+     * Calculates the triangle plane from triangle.
+     * @param inputs triangle and tolerance
+     * @returns triangle plane
+     * @group traingle
+     * @shortname triangle plane
+     * @drawable false
+     */
+    calculateTrianglePlane(inputs) {
+        const EPSILON_SQ = Math.pow((inputs.tolerance || 1e-7), 2);
+        const edge1 = this.vector.sub({ first: inputs.triangle[1], second: inputs.triangle[0] });
+        const edge2 = this.vector.sub({ first: inputs.triangle[2], second: inputs.triangle[0] });
+        const normal = this.vector.cross({ first: edge1, second: edge2 });
+        if (this.vector.lengthSq({ vector: normal }) < EPSILON_SQ) {
+            return undefined; // Degenerate triangle
+        }
+        // Defensive copy if normalize modifies in-place
+        const normalizedNormal = this.vector.normalized({ vector: normal });
+        const d = this.vector.dot({ first: normalizedNormal, second: inputs.triangle[0] });
+        return { normal: normalizedNormal, d: d };
+    }
+    /**
+     * Calculates the intersection of two triangles.
+     * @param inputs first triangle, second triangle, and tolerance
+     * @returns intersection segment or undefined if no intersection
+     * @group traingle
+     * @shortname triangle-triangle int
+     * @drawable false
+     */
+    triangleTriangleIntersection(inputs) {
+        const t1 = inputs.triangle1;
+        const t2 = inputs.triangle2;
+        const EPSILON = inputs.tolerance || 1e-7;
+        const p1 = t1[0], p2 = t1[1], p3 = t1[2];
+        const q1 = t2[0], q2 = t2[1], q3 = t2[2];
+        const plane1 = this.calculateTrianglePlane({ triangle: t1, tolerance: EPSILON });
+        const plane2 = this.calculateTrianglePlane({ triangle: t2, tolerance: EPSILON });
+        if (!plane1 || !plane2)
+            return undefined;
+        const distQ_Plane1 = [
+            this.signedDistanceToPlane({ point: q1, plane: plane1 }),
+            this.signedDistanceToPlane({ point: q2, plane: plane1 }),
+            this.signedDistanceToPlane({ point: q3, plane: plane1 }),
+        ];
+        if ((distQ_Plane1[0] > EPSILON && distQ_Plane1[1] > EPSILON && distQ_Plane1[2] > EPSILON) ||
+            (distQ_Plane1[0] < -EPSILON && distQ_Plane1[1] < -EPSILON && distQ_Plane1[2] < -EPSILON)) {
+            return undefined;
+        }
+        const distP_Plane2 = [
+            this.signedDistanceToPlane({ point: p1, plane: plane2 }),
+            this.signedDistanceToPlane({ point: p2, plane: plane2 }),
+            this.signedDistanceToPlane({ point: p3, plane: plane2 }),
+        ];
+        if ((distP_Plane2[0] > EPSILON && distP_Plane2[1] > EPSILON && distP_Plane2[2] > EPSILON) ||
+            (distP_Plane2[0] < -EPSILON && distP_Plane2[1] < -EPSILON && distP_Plane2[2] < -EPSILON)) {
+            return undefined;
+        }
+        const allDistPZero = distP_Plane2.every(d => Math.abs(d) < EPSILON);
+        const allDistQZero = distQ_Plane1.every(d => Math.abs(d) < EPSILON);
+        if (allDistPZero && allDistQZero) {
+            return undefined; // Explicitly not handling coplanar intersection areas
+        }
+        const lineDir = this.vector.cross({ first: plane1.normal, second: plane2.normal });
+        const det = this.vector.dot({ first: lineDir, second: lineDir }); // det = |lineDir|^2
+        if (det < EPSILON * EPSILON) {
+            return undefined; // Planes parallel, no line intersection (coplanar case handled above)
+        }
+        // --- Calculate Interval Projections ---
+        // Store the 3D points that define the intervals on the line
+        const t1_intersection_points_3d = [];
+        const t2_intersection_points_3d = [];
+        const edges1 = [[p1, p2], [p2, p3], [p3, p1]];
+        const dists1 = distP_Plane2;
+        for (let i = 0; i < 3; ++i) {
+            const u = edges1[i][0];
+            const v = edges1[i][1];
+            const du = dists1[i];
+            const dv = dists1[(i + 1) % 3];
+            if (Math.abs(du) < EPSILON)
+                t1_intersection_points_3d.push(u); // Start vertex is on plane2
+            // Removed the redundant check for dv here, handled by next edge start
+            if ((du * dv) < 0 && Math.abs(du - dv) > EPSILON) { // Edge crosses plane2
+                const t = du / (du - dv);
+                t1_intersection_points_3d.push(this.computeIntersectionPoint(u, v, t));
+            }
+        }
+        const edges2 = [[q1, q2], [q2, q3], [q3, q1]];
+        const dists2 = distQ_Plane1;
+        for (let i = 0; i < 3; ++i) {
+            const u = edges2[i][0];
+            const v = edges2[i][1];
+            const du = dists2[i];
+            const dv = dists2[(i + 1) % 3];
+            if (Math.abs(du) < EPSILON)
+                t2_intersection_points_3d.push(u); // Start vertex is on plane1
+            // Removed redundant check for dv
+            if ((du * dv) < 0 && Math.abs(du - dv) > EPSILON) { // Edge crosses plane1
+                const t = du / (du - dv);
+                t2_intersection_points_3d.push(this.computeIntersectionPoint(u, v, t));
+            }
+        }
+        // We expect exactly two points for each triangle in the standard piercing case.
+        // Handle potential duplicates or edge cases if more points are generated (e.g., edge lies on plane)
+        // A simple check for the common case:
+        if (t1_intersection_points_3d.length < 2 || t2_intersection_points_3d.length < 2) {
+            // This can happen if triangles touch at a vertex or edge without crossing planes,
+            // or due to numerical precision near edges/vertices.
+            return undefined; // Treat touch as no intersection segment
+        }
+        // Calculate a robust origin ON the intersection line
+        const n1 = plane1.normal;
+        const n2 = plane2.normal;
+        const d1 = plane1.d;
+        const d2 = plane2.d;
+        // Point P = ( (d1 * N2 - d2 * N1) x D ) / (D dot D)
+        const term1 = this.vector.mul({ vector: n2, scalar: d1 });
+        const term2 = this.vector.mul({ vector: n1, scalar: d2 });
+        const termSub = this.vector.sub({ first: term1, second: term2 });
+        const crossTerm = this.vector.cross({ first: termSub, second: lineDir });
+        const lineOrigin = this.vector.mul({ vector: crossTerm, scalar: 1.0 / det });
+        // Project the 3D intersection points onto the lineDir, relative to lineOrigin
+        const t1_params = t1_intersection_points_3d.map(p => this.vector.dot({ first: this.vector.sub({ first: p, second: lineOrigin }), second: lineDir }));
+        const t2_params = t2_intersection_points_3d.map(p => this.vector.dot({ first: this.vector.sub({ first: p, second: lineOrigin }), second: lineDir }));
+        // Find the intervals
+        const t1Interval = [Math.min(...t1_params), Math.max(...t1_params)];
+        const t2Interval = [Math.min(...t2_params), Math.max(...t2_params)];
+        // Find the overlap of the two intervals
+        const intersectionMinParam = Math.max(t1Interval[0], t2Interval[0]);
+        const intersectionMaxParam = Math.min(t1Interval[1], t2Interval[1]);
+        // Check if the overlap is valid
+        if (intersectionMinParam < intersectionMaxParam - (EPSILON * det)) { // Let's use scaled epsilon for robustness against small det values.
+            // Convert the final parameters back to 3D points using the lineOrigin
+            // P = lineOrigin + dir * (param / det)
+            const point1 = this.vector.add({ first: lineOrigin, second: this.vector.mul({ vector: lineDir, scalar: intersectionMinParam / det }) });
+            const point2 = this.vector.add({ first: lineOrigin, second: this.vector.mul({ vector: lineDir, scalar: intersectionMaxParam / det }) });
+            // Check if the resulting segment has non-zero length
+            const segVec = this.vector.sub({ first: point1, second: point2 });
+            if (this.vector.lengthSq({ vector: segVec }) > EPSILON * EPSILON) {
+                return [point1, point2];
+            }
+            else {
+                return undefined; // Degenerate segment
+            }
+        }
+        else {
+            return undefined; // Intervals do not overlap
+        }
+    }
+    /**
+     * Computes the intersection segments of two meshes.
+     * @param inputs first mesh, second mesh, and tolerance
+     * @returns array of intersection segments
+     * @group mesh
+     * @shortname mesh-mesh int segments
+     * @drawable false
+     */
+    meshMeshIntersectionSegments(inputs) {
+        const mesh1 = inputs.mesh1;
+        const mesh2 = inputs.mesh2;
+        const intersectionSegments = [];
+        for (let i = 0; i < mesh1.length; ++i) {
+            for (let j = 0; j < mesh2.length; ++j) {
+                const triangle1 = mesh1[i];
+                const triangle2 = mesh2[j];
+                const segment = this.triangleTriangleIntersection({ triangle1, triangle2, tolerance: inputs.tolerance });
+                if (segment) {
+                    intersectionSegments.push(segment);
+                }
+            }
+        }
+        return intersectionSegments;
+    }
+    /**
+     * Computes the intersection polylines of two meshes.
+     * @param inputs first mesh, second mesh, and tolerance
+     * @returns array of intersection polylines
+     * @group mesh
+     * @shortname mesh-mesh int polylines
+     * @drawable true
+     */
+    meshMeshIntersectionPolylines(inputs) {
+        const segments = this.meshMeshIntersectionSegments(inputs);
+        return this.polyline.sortSegmentsIntoPolylines({ segments, tolerance: inputs.tolerance });
+    }
+    /**
+     * Computes the intersection points of two meshes.
+     * @param inputs first mesh, second mesh, and tolerance
+     * @returns array of intersection points
+     * @group mesh
+     * @shortname mesh-mesh int points
+     * @drawable false
+     */
+    meshMeshIntersectionPoints(inputs) {
+        const polylines = this.meshMeshIntersectionPolylines(inputs);
+        return polylines.map(polyline => {
+            if (polyline.isClosed) {
+                return [...polyline.points, polyline.points[0]];
+            }
+            else {
+                return polyline.points;
+            }
+        });
+    }
+    computeIntersectionPoint(u, v, t) {
+        return this.vector.add({
+            first: u,
+            second: this.vector.mul({
+                vector: this.vector.sub({
+                    first: v,
+                    second: u
+                }),
+                scalar: t
+            })
+        });
+    }
+}