pcb-scene3d-viewer 1.0.1 → 1.1.1

package/src/PcbScene3dBufferAttributeFactory.mjs

@@ -0,0 +1,128 @@
+/**
+ * Creates Three.js buffer attributes from importer mesh arrays.
+ */
+export class PcbScene3dBufferAttributeFactory {
+    /**
+     * Creates a floating-point attribute.
+     * @param {any} THREE Three.js namespace.
+     * @param {ArrayLike<number>} values Source values.
+     * @param {number} itemSize Attribute item size.
+     * @returns {any}
+     */
+    static createFloat32(THREE, values, itemSize) {
+        return PcbScene3dBufferAttributeFactory.#create(
+            THREE,
+            values,
+            itemSize,
+            Float32Array,
+            'Float32BufferAttribute'
+        )
+    }
+
+    /**
+     * Creates an unsigned integer attribute.
+     * @param {any} THREE Three.js namespace.
+     * @param {ArrayLike<number>} values Source values.
+     * @param {number} itemSize Attribute item size.
+     * @returns {any}
+     */
+    static createUint32(THREE, values, itemSize) {
+        return PcbScene3dBufferAttributeFactory.#create(
+            THREE,
+            values,
+            itemSize,
+            Uint32Array,
+            'Uint32BufferAttribute'
+        )
+    }
+
+    /**
+     * Returns true when a value is an array-like numeric sequence.
+     * @param {unknown} values Candidate values.
+     * @returns {boolean}
+     */
+    static isNumberSequence(values) {
+        return (
+            Array.isArray(values) ||
+            PcbScene3dBufferAttributeFactory.#isTypedNumberArray(values)
+        )
+    }
+
+    /**
+     * Creates a buffer attribute with the most efficient constructor available.
+     * @param {any} THREE Three.js namespace.
+     * @param {ArrayLike<number>} values Source values.
+     * @param {number} itemSize Attribute item size.
+     * @param {Float32ArrayConstructor | Uint32ArrayConstructor} TypedArrayConstructor Fallback typed array constructor.
+     * @param {string} fallbackConstructorName Legacy Three attribute constructor name.
+     * @returns {any}
+     */
+    static #create(
+        THREE,
+        values,
+        itemSize,
+        TypedArrayConstructor,
+        fallbackConstructorName
+    ) {
+        const array = PcbScene3dBufferAttributeFactory.#normalizeValues(
+            values,
+            TypedArrayConstructor
+        )
+
+        if (typeof THREE?.BufferAttribute === 'function') {
+            return new THREE.BufferAttribute(array, itemSize)
+        }
+
+        if (typeof THREE?.[fallbackConstructorName] === 'function') {
+            return new THREE[fallbackConstructorName](array, itemSize)
+        }
+
+        return {
+            array,
+            itemSize,
+            count: Math.floor(Number(array.length || 0) / itemSize),
+            isBufferAttribute: true
+        }
+    }
+
+    /**
+     * Normalizes plain arrays while preserving importer-owned typed arrays.
+     * @param {ArrayLike<number> | undefined | null} values Source values.
+     * @param {Float32ArrayConstructor | Uint32ArrayConstructor} TypedArrayConstructor Fallback typed array constructor.
+     * @returns {ArrayLike<number>}
+     */
+    static #normalizeValues(values, TypedArrayConstructor) {
+        if (PcbScene3dBufferAttributeFactory.#isTypedNumberArray(values)) {
+            return values
+        }
+
+        return new TypedArrayConstructor(Array.from(values || []))
+    }
+
+    /**
+     * Returns true when a sequence is already backed by a typed numeric array.
+     * @param {unknown} values Candidate values.
+     * @returns {boolean}
+     */
+    static #isTypedNumberArray(values) {
+        return (
+            ArrayBuffer.isView(values) &&
+            !(values instanceof DataView) &&
+            !PcbScene3dBufferAttributeFactory.#isBigIntTypedArray(values)
+        )
+    }
+
+    /**
+     * Returns true when a typed-array view stores bigint values.
+     * @param {unknown} values Candidate values.
+     * @returns {boolean}
+     */
+    static #isBigIntTypedArray(values) {
+        const tag = Object.prototype.toString.call(values)
+
+        return (
+            tag === '[object BigInt64Array]' ||
+            tag === '[object BigUint64Array]'
+        )
+    }
+}

package/src/PcbScene3dCircularCutoutOverlap.mjs

@@ -0,0 +1,167 @@
+import { PcbScene3dCutoutCircleDetector } from './PcbScene3dCutoutCircleDetector.mjs'
+
+/**
+ * Resolves analytic overlap checks for sampled circular drill cutouts.
+ */
+export class PcbScene3dCircularCutoutOverlap {
+    /**
+     * Returns true when one triangle overlaps a circular cutout.
+     * @param {{ x: number, y: number }[]} triangle
+     * @param {{ points?: { x: number, y: number }[], centerX?: number, centerY?: number, radius?: number }} cutout
+     * @param {number} [epsilon]
+     * @returns {boolean}
+     */
+    static overlapsTriangle(triangle, cutout, epsilon = 0.001) {
+        const radius = Number(cutout?.radius || 0) + Number(epsilon || 0)
+        if (!Number.isFinite(radius) || radius <= 0) {
+            return false
+        }
+
+        const center = {
+            x: Number(cutout?.centerX || 0),
+            y: Number(cutout?.centerY || 0)
+        }
+        const radiusSquared = radius * radius
+
+        for (const point of triangle) {
+            if (
+                PcbScene3dCutoutCircleDetector.distanceSquared(point, cutout) <=
+                radiusSquared
+            ) {
+                return true
+            }
+        }
+
+        if (
+            PcbScene3dCircularCutoutOverlap.#isPointInsideOrOnTriangle(
+                center,
+                triangle,
+                epsilon
+            )
+        ) {
+            return true
+        }
+
+        for (let index = 0; index < triangle.length; index += 1) {
+            const current = triangle[index]
+            const next = triangle[(index + 1) % triangle.length]
+
+            if (
+                PcbScene3dCircularCutoutOverlap.#distanceToSegmentSquared(
+                    center,
+                    current,
+                    next,
+                    epsilon
+                ) <= radiusSquared
+            ) {
+                return true
+            }
+        }
+
+        return PcbScene3dCircularCutoutOverlap.#hasSampledBoundaryOverlap(
+            triangle,
+            cutout,
+            epsilon
+        )
+    }
+
+    /**
+     * Returns true when a sampled cutout boundary point lies in the triangle.
+     * @param {{ x: number, y: number }[]} triangle
+     * @param {{ points?: { x: number, y: number }[] }} cutout
+     * @param {number} epsilon
+     * @returns {boolean}
+     */
+    static #hasSampledBoundaryOverlap(triangle, cutout, epsilon) {
+        const boundaryPoints = Array.isArray(cutout?.points)
+            ? cutout.points
+            : []
+        const step = Math.max(1, Math.floor(boundaryPoints.length / 8))
+
+        for (let index = 0; index < boundaryPoints.length; index += step) {
+            if (
+                PcbScene3dCircularCutoutOverlap.#isPointInsideOrOnTriangle(
+                    boundaryPoints[index],
+                    triangle,
+                    epsilon
+                )
+            ) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    /**
+     * Returns true when a point is inside or on one triangle.
+     * @param {{ x: number, y: number }} point
+     * @param {{ x: number, y: number }[]} triangle
+     * @param {number} epsilon
+     * @returns {boolean}
+     */
+    static #isPointInsideOrOnTriangle(point, triangle, epsilon) {
+        let hasNegative = false
+        let hasPositive = false
+
+        for (let index = 0; index < triangle.length; index += 1) {
+            const current = triangle[index]
+            const next = triangle[(index + 1) % triangle.length]
+            const sign = PcbScene3dCircularCutoutOverlap.#cross(
+                point,
+                current,
+                next
+            )
+
+            hasNegative = hasNegative || sign < -epsilon
+            hasPositive = hasPositive || sign > epsilon
+        }
+
+        return !(hasNegative && hasPositive)
+    }
+
+    /**
+     * Resolves the squared distance from one point to a finite segment.
+     * @param {{ x: number, y: number }} point
+     * @param {{ x: number, y: number }} start
+     * @param {{ x: number, y: number }} end
+     * @param {number} epsilon
+     * @returns {number}
+     */
+    static #distanceToSegmentSquared(point, start, end, epsilon) {
+        const dx = end.x - start.x
+        const dy = end.y - start.y
+        const lengthSquared = dx * dx + dy * dy
+
+        if (lengthSquared <= epsilon) {
+            return (point.x - start.x) ** 2 + (point.y - start.y) ** 2
+        }
+
+        const ratio = Math.max(
+            0,
+            Math.min(
+                1,
+                ((point.x - start.x) * dx + (point.y - start.y) * dy) /
+                    lengthSquared
+            )
+        )
+        const projectedX = start.x + ratio * dx
+        const projectedY = start.y + ratio * dy
+
+        return (point.x - projectedX) ** 2 + (point.y - projectedY) ** 2
+    }
+
+    /**
+     * Resolves the signed area for three points.
+     * @param {{ x: number, y: number }} first
+     * @param {{ x: number, y: number }} second
+     * @param {{ x: number, y: number }} third
+     * @returns {number}
+     */
+    static #cross(first, second, third) {
+        return (
+            (second.x - first.x) * (third.y - first.y) -
+            (second.y - first.y) * (third.x - first.x)
+        )
+    }
+}

package/src/PcbScene3dCutoutCircleDetector.mjs

@@ -0,0 +1,84 @@
+/**
+ * Detects sampled circular drill cutouts for faster geometry clipping.
+ */
+export class PcbScene3dCutoutCircleDetector {
+    static #DEFAULT_EPSILON = 0.001
+    static #MAX_RELATIVE_ERROR = 0.025
+    static #MIN_POINT_COUNT = 8
+
+    /**
+     * Resolves circle metadata for sampled circular drill cutouts.
+     * @param {{ x: number, y: number }[]} points
+     * @param {number} [epsilon]
+     * @returns {{ isCircular: true, centerX: number, centerY: number, radius: number } | null}
+     */
+    static resolve(points, epsilon = this.#DEFAULT_EPSILON) {
+        if (
+            !Array.isArray(points) ||
+            points.length < PcbScene3dCutoutCircleDetector.#MIN_POINT_COUNT
+        ) {
+            return null
+        }
+
+        const center = PcbScene3dCutoutCircleDetector.#resolveCentroid(points)
+        const radii = points.map((point) =>
+            Math.hypot(point.x - center.x, point.y - center.y)
+        )
+        const radius =
+            radii.reduce((sum, value) => sum + value, 0) / radii.length
+        const maxError = Math.max(
+            ...radii.map((value) => Math.abs(value - radius))
+        )
+        const tolerance = Math.max(
+            Number(epsilon || 0),
+            radius * PcbScene3dCutoutCircleDetector.#MAX_RELATIVE_ERROR
+        )
+
+        if (
+            !Number.isFinite(radius) ||
+            radius <= Number(epsilon || 0) ||
+            maxError > tolerance
+        ) {
+            return null
+        }
+
+        return {
+            isCircular: true,
+            centerX: center.x,
+            centerY: center.y,
+            radius
+        }
+    }
+
+    /**
+     * Resolves squared distance from a point to circular cutout center.
+     * @param {{ x: number, y: number }} point
+     * @param {{ centerX?: number, centerY?: number }} cutout
+     * @returns {number}
+     */
+    static distanceSquared(point, cutout) {
+        const dx = point.x - Number(cutout.centerX || 0)
+        const dy = point.y - Number(cutout.centerY || 0)
+        return dx * dx + dy * dy
+    }
+
+    /**
+     * Resolves the centroid of one point list.
+     * @param {{ x: number, y: number }[]} points
+     * @returns {{ x: number, y: number }}
+     */
+    static #resolveCentroid(points) {
+        const sum = points.reduce(
+            (accumulator, point) => ({
+                x: accumulator.x + Number(point.x || 0),
+                y: accumulator.y + Number(point.y || 0)
+            }),
+            { x: 0, y: 0 }
+        )
+
+        return {
+            x: sum.x / points.length,
+            y: sum.y / points.length
+        }
+    }
+}

package/src/PcbScene3dCutoutGeometryFilter.mjs

@@ -1,3 +1,6 @@
+import { PcbScene3dCircularCutoutOverlap } from './PcbScene3dCircularCutoutOverlap.mjs'
+import { PcbScene3dCutoutCircleDetector } from './PcbScene3dCutoutCircleDetector.mjs'
+
 /**
  * Clips filled 2D geometry against drill-cutout polygons.
  */
@@ -79,7 +82,7 @@ export class PcbScene3dCutoutGeometryFilter {
     /**
      * Resolves clipping settings.
      * @param {{ maxDepth?: number, maxEdgeLength?: number }} options
-     * @returns {{ maxDepth: number, maxEdgeLength: number }}
+     * @returns {{ maxDepth: number, maxEdgeLength: number, maxEdgeLengthSquared: number }}
      */
     static #resolveSettings(options) {
         const maxEdgeLength = Math.max(
@@ -94,24 +97,35 @@ export class PcbScene3dCutoutGeometryFilter {
                     PcbScene3dCutoutGeometryFilter.#DEFAULT_MAX_DEPTH,
                 0
             ),
-            maxEdgeLength
+            maxEdgeLength,
+            maxEdgeLengthSquared: maxEdgeLength * maxEdgeLength
         }
     }
 
     /**
      * Prepares cutout polygons with bounds for fast overlap checks.
      * @param {{ x: number, y: number }[][]} cutouts
-     * @returns {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number } }[]}
+     * @returns {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number }, isCircular?: boolean, centerX?: number, centerY?: number, radius?: number }[]}
      */
     static #prepareCutouts(cutouts) {
         return cutouts
             .filter((cutout) => Array.isArray(cutout) && cutout.length >= 3)
-            .map((cutout) => ({
-                points: cutout,
-                segments:
-                    PcbScene3dCutoutGeometryFilter.#buildCutoutSegments(cutout),
-                bounds: PcbScene3dCutoutGeometryFilter.#resolveBounds(cutout)
-            }))
+            .map((cutout) => {
+                const circularCutout =
+                    PcbScene3dCutoutCircleDetector.resolve(cutout)
+
+                return {
+                    points: cutout,
+                    segments:
+                        PcbScene3dCutoutGeometryFilter.#buildCutoutSegments(
+                            cutout
+                        ),
+                    bounds: PcbScene3dCutoutGeometryFilter.#resolveBounds(
+                        cutout
+                    ),
+                    ...circularCutout
+                }
+            })
     }
 
     /**
@@ -151,7 +165,7 @@ export class PcbScene3dCutoutGeometryFilter {
      * @param {number[]} positions
      * @param {{ x: number, y: number, z: number }[]} triangle
      * @param {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number } }[]} cutouts
-     * @param {{ maxDepth: number, maxEdgeLength: number }} settings
+     * @param {{ maxDepth: number, maxEdgeLength: number, maxEdgeLengthSquared: number }} settings
      * @param {number} depth
      * @param {{ changed: boolean }} state
      * @param {object | null} [cutoutIndex]
@@ -199,8 +213,8 @@ export class PcbScene3dCutoutGeometryFilter {
 
         if (
             depth >= settings.maxDepth ||
-            PcbScene3dCutoutGeometryFilter.#maxEdgeLength(triangle) <=
-                settings.maxEdgeLength
+            PcbScene3dCutoutGeometryFilter.#maxEdgeLengthSquared(triangle) <=
+                settings.maxEdgeLengthSquared
         ) {
             return
         }
@@ -443,23 +457,22 @@ export class PcbScene3dCutoutGeometryFilter {
     }
 
     /**
-     * Resolves the longest edge in one triangle.
+     * Resolves the longest squared edge length in one triangle.
      * @param {{ x: number, y: number }[]} triangle
      * @returns {number}
      */
-    static #maxEdgeLength(triangle) {
-        let maxLength = 0
+    static #maxEdgeLengthSquared(triangle) {
+        let maxLengthSquared = 0
 
         for (let index = 0; index < triangle.length; index += 1) {
             const point = triangle[index]
             const next = triangle[(index + 1) % triangle.length]
-            maxLength = Math.max(
-                maxLength,
-                Math.hypot(point.x - next.x, point.y - next.y)
-            )
+            const dx = point.x - next.x
+            const dy = point.y - next.y
+            maxLengthSquared = Math.max(maxLengthSquared, dx * dx + dy * dy)
         }
 
-        return maxLength
+        return maxLengthSquared
     }
 
     /**
@@ -496,10 +509,17 @@ export class PcbScene3dCutoutGeometryFilter {
      */
     static #boundsOverlap(first, second) {
         return (
-            first.minX <= second.maxX &&
-            first.maxX >= second.minX &&
-            first.minY <= second.maxY &&
-            first.maxY >= second.minY
+            first.minX <=
+                second.maxX +
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON &&
+            first.maxX >=
+                second.minX -
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON &&
+            first.minY <=
+                second.maxY +
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON &&
+            first.maxY >=
+                second.minY - PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON
         )
     }
 
@@ -543,7 +563,7 @@ export class PcbScene3dCutoutGeometryFilter {
     /**
      * Returns true when one triangle intersects or covers a cutout.
      * @param {{ x: number, y: number }[]} triangle
-     * @param {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number } }} cutout
+     * @param {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number }, isCircular?: boolean, centerX?: number, centerY?: number, radius?: number }} cutout
      * @returns {boolean}
      */
     static #doesTriangleOverlapCutout(triangle, cutout) {
@@ -556,6 +576,14 @@ export class PcbScene3dCutoutGeometryFilter {
             return false
         }
 
+        if (cutout.isCircular) {
+            return PcbScene3dCircularCutoutOverlap.overlapsTriangle(
+                triangle,
+                cutout,
+                PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON
+            )
+        }
+
         for (const point of triangle) {
             if (
                 PcbScene3dCutoutGeometryFilter.#isPointInsideOrOnCutout(
@@ -587,10 +615,28 @@ export class PcbScene3dCutoutGeometryFilter {
     /**
      * Returns true when a point is inside or on a cutout.
      * @param {{ x: number, y: number }} point
-     * @param {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number } }} cutout
+     * @param {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number }, isCircular?: boolean, centerX?: number, centerY?: number, radius?: number }} cutout
      * @returns {boolean}
      */
     static #isPointInsideOrOnCutout(point, cutout) {
+        if (
+            !PcbScene3dCutoutGeometryFilter.#pointOverlapsBounds(
+                point,
+                cutout.bounds
+            )
+        ) {
+            return false
+        }
+
+        if (cutout.isCircular) {
+            return (
+                PcbScene3dCutoutCircleDetector.distanceSquared(point, cutout) <=
+                (Number(cutout.radius || 0) +
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON) **
+                    2
+            )
+        }
+
         return (
             PcbScene3dCutoutGeometryFilter.#isPointOnCutoutBoundary(
                 point,
@@ -603,13 +649,47 @@ export class PcbScene3dCutoutGeometryFilter {
         )
     }
 
+    /**
+     * Returns true when a point lies within a bounding box tolerance.
+     * @param {{ x: number, y: number }} point
+     * @param {{ minX: number, maxX: number, minY: number, maxY: number }} bounds
+     * @returns {boolean}
+     */
+    static #pointOverlapsBounds(point, bounds) {
+        return (
+            point.x >=
+                bounds.minX -
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON &&
+            point.x <=
+                bounds.maxX +
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON &&
+            point.y >=
+                bounds.minY -
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON &&
+            point.y <=
+                bounds.maxY + PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON
+        )
+    }
+
     /**
      * Returns true when a point lies inside a cutout and away from its border.
      * @param {{ x: number, y: number }} point
-     * @param {{ points: { x: number, y: number }[], bounds: { minX: number, maxX: number, minY: number, maxY: number } }} cutout
+     * @param {{ points: { x: number, y: number }[], bounds: { minX: number, maxX: number, minY: number, maxY: number }, isCircular?: boolean, centerX?: number, centerY?: number, radius?: number }} cutout
      * @returns {boolean}
      */
     static #isPointStrictlyInsideCutout(point, cutout) {
+        if (cutout.isCircular) {
+            const radius = Math.max(
+                0,
+                Number(cutout.radius || 0) -
+                    PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON
+            )
+            return (
+                PcbScene3dCutoutCircleDetector.distanceSquared(point, cutout) <
+                radius * radius
+            )
+        }
+
         const polygon = cutout.points
 
         let inside = false
@@ -638,18 +718,33 @@ export class PcbScene3dCutoutGeometryFilter {
     /**
      * Returns true when a point lies on a cutout edge.
      * @param {{ x: number, y: number }} point
-     * @param {{ points: { x: number, y: number }[] }} cutout
+     * @param {{ segments: { start: { x: number, y: number }, end: { x: number, y: number }, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], isCircular?: boolean, centerX?: number, centerY?: number, radius?: number }} cutout
      * @returns {boolean}
      */
     static #isPointOnCutoutBoundary(point, cutout) {
-        const polygon = cutout.points
+        if (cutout.isCircular) {
+            return (
+                Math.abs(
+                    Math.sqrt(
+                        PcbScene3dCutoutCircleDetector.distanceSquared(
+                            point,
+                            cutout
+                        )
+                    ) - Number(cutout.radius || 0)
+                ) <= PcbScene3dCutoutGeometryFilter.#GEOMETRY_EPSILON
+            )
+        }
 
-        for (let index = 0; index < polygon.length; index += 1) {
+        for (const segment of cutout.segments) {
             if (
+                PcbScene3dCutoutGeometryFilter.#pointOverlapsBounds(
+                    point,
+                    segment.bounds
+                ) &&
                 PcbScene3dCutoutGeometryFilter.#isPointOnSegment(
                     point,
-                    polygon[index],
-                    polygon[(index + 1) % polygon.length]
+                    segment.start,
+                    segment.end
                 )
             ) {
                 return true
@@ -703,9 +798,18 @@ export class PcbScene3dCutoutGeometryFilter {
         ) {
             const triangleStart = triangle[triangleIndex]
             const triangleEnd = triangle[(triangleIndex + 1) % triangle.length]
+            const triangleSegmentBounds =
+                PcbScene3dCutoutGeometryFilter.#resolveSegmentBounds(
+                    triangleStart,
+                    triangleEnd
+                )
 
             for (const segment of cutout.segments) {
                 if (
+                    PcbScene3dCutoutGeometryFilter.#boundsOverlap(
+                        triangleSegmentBounds,
+                        segment.bounds
+                    ) &&
                     PcbScene3dCutoutGeometryFilter.#segmentsIntersect(
                         triangleStart,
                         triangleEnd,
@@ -721,6 +825,21 @@ export class PcbScene3dCutoutGeometryFilter {
         return false
     }
 
+    /**
+     * Resolves one finite segment bounding box.
+     * @param {{ x: number, y: number }} firstStart
+     * @param {{ x: number, y: number }} firstEnd
+     * @returns {{ minX: number, maxX: number, minY: number, maxY: number }}
+     */
+    static #resolveSegmentBounds(firstStart, firstEnd) {
+        return {
+            minX: Math.min(firstStart.x, firstEnd.x),
+            maxX: Math.max(firstStart.x, firstEnd.x),
+            minY: Math.min(firstStart.y, firstEnd.y),
+            maxY: Math.max(firstStart.y, firstEnd.y)
+        }
+    }
+
     /**
      * Returns true when two finite line segments intersect.
      * @param {{ x: number, y: number }} firstStart