pcb-scene3d-viewer 1.1.49 → 1.2.0

package/src/PcbScene3dCopperFillCoverageContext.mjs

@@ -0,0 +1,204 @@
+import { PcbScene3dAabbIndex } from './PcbScene3dAabbIndex.mjs'
+import { PcbScene3dPreparedPolygon } from './PcbScene3dPreparedPolygon.mjs'
+
+/**
+ * Immutable request-scoped acceleration for normalized copper fill loop sets.
+ */
+export class PcbScene3dCopperFillCoverageContext {
+    static #GEOMETRY_EPSILON = 0.001
+
+    /** @type {{ outer: PcbScene3dPreparedPolygon, holes: PcbScene3dPreparedPolygon[], bounds: object, sourceIndex: number }[]} */
+    #areas
+
+    /** @type {PcbScene3dAabbIndex} */
+    #index
+
+    /** @type {object[]} */
+    #loopSets
+
+    /** @type {object[] | null} */
+    #sourceLoopSets
+
+    /**
+     * Creates one context from already-normalized ordered loop sets.
+     * @param {{ outer?: number[][], holes?: number[][][] }[]} loopSets Ordered fill islands.
+     * @returns {PcbScene3dCopperFillCoverageContext}
+     */
+    static fromLoopSets(loopSets) {
+        return new PcbScene3dCopperFillCoverageContext(loopSets)
+    }
+
+    /**
+     * Prepares every loop coordinate once and builds one top-level area index.
+     * @param {{ outer?: number[][], holes?: number[][][] }[]} loopSets Ordered fill islands.
+     */
+    constructor(loopSets) {
+        this.#sourceLoopSets = Array.isArray(loopSets) ? loopSets : null
+        this.#loopSets = Object.freeze(Array.from(loopSets || []))
+        this.#areas = Object.freeze(
+            Array.from(this.#loopSets, (loopSet, sourceIndex) =>
+                PcbScene3dCopperFillCoverageContext.#prepareArea(
+                    loopSet,
+                    sourceIndex
+                )
+            )
+        )
+        this.#index = new PcbScene3dAabbIndex(this.#areas, {
+            resolveBounds: PcbScene3dCopperFillCoverageContext.#resolveBounds,
+            resolveSourceIndex:
+                PcbScene3dCopperFillCoverageContext.#resolveSourceIndex
+        })
+    }
+
+    /**
+     * Returns the immutable number of prepared fill areas.
+     * @returns {number}
+     */
+    get areaCount() {
+        return this.#areas.length
+    }
+
+    /**
+     * Returns whether the request array and loop-set order match preparation.
+     * @param {object[]} loopSets Active normalized fill islands.
+     * @returns {boolean}
+     */
+    matchesLoopSets(loopSets) {
+        if (
+            !Array.isArray(loopSets) ||
+            loopSets !== this.#sourceLoopSets ||
+            loopSets.length !== this.#loopSets.length
+        ) {
+            return false
+        }
+
+        for (let index = 0; index < loopSets.length; index += 1) {
+            if (loopSets[index] !== this.#loopSets[index]) {
+                return false
+            }
+        }
+
+        return true
+    }
+
+    /**
+     * Appends stable broad-phase area candidates into a caller-owned target.
+     * @param {{ minX: number, maxX: number, minY: number, maxY: number }} triangleBounds Triangle bounds.
+     * @param {object[]} [target] Candidate accumulator.
+     * @param {{ beforeSourceIndex?: number, allowedSourceIndexes?: Set<number> | number[] | null }} [options] Source-order filters.
+     * @returns {object[]}
+     */
+    queryAreas(triangleBounds, target = [], options = {}) {
+        const candidates = this.#index.query(triangleBounds, {
+            epsilon: PcbScene3dCopperFillCoverageContext.#GEOMETRY_EPSILON,
+            stable: true
+        })
+        const beforeSourceIndex = options.beforeSourceIndex ?? Infinity
+        const allowedSourceIndexes = options.allowedSourceIndexes ?? null
+
+        for (const area of candidates) {
+            if (
+                area.sourceIndex < beforeSourceIndex &&
+                PcbScene3dCopperFillCoverageContext.#isAllowedSourceIndex(
+                    area.sourceIndex,
+                    allowedSourceIndexes
+                )
+            ) {
+                target.push(area)
+            }
+        }
+
+        return target
+    }
+
+    /**
+     * Prepares one outer loop and its authored holes.
+     * @param {{ outer?: number[][], holes?: number[][][] }} loopSet Source loop set.
+     * @param {number} sourceIndex Flattened source position.
+     * @returns {{ outer: PcbScene3dPreparedPolygon, holes: PcbScene3dPreparedPolygon[], bounds: object, sourceIndex: number }}
+     */
+    static #prepareArea(loopSet, sourceIndex) {
+        const outer = PcbScene3dCopperFillCoverageContext.#prepareLoop(
+            loopSet?.outer,
+            sourceIndex
+        )
+        const holes = Object.freeze(
+            Array.from(loopSet?.holes || [], (hole) =>
+                PcbScene3dCopperFillCoverageContext.#prepareLoop(
+                    hole,
+                    sourceIndex
+                )
+            )
+        )
+
+        return Object.freeze({
+            outer,
+            holes,
+            bounds: outer.bounds,
+            sourceIndex
+        })
+    }
+
+    /**
+     * Converts one normalized pair loop to numeric point objects once.
+     * @param {number[][] | undefined} loop Source loop.
+     * @param {number} sourceIndex Flattened source position.
+     * @returns {PcbScene3dPreparedPolygon}
+     */
+    static #prepareLoop(loop, sourceIndex) {
+        const source = Array.isArray(loop) ? loop : []
+        const points = Object.freeze(
+            source.map((point) => {
+                const x = Number(point?.[0])
+                const y = Number(point?.[1])
+                return Object.freeze({ x, y })
+            })
+        )
+
+        return new PcbScene3dPreparedPolygon(points, {
+            source,
+            sourceIndex,
+            epsilon: PcbScene3dCopperFillCoverageContext.#GEOMETRY_EPSILON,
+            pointRepresentation: 'numeric'
+        })
+    }
+
+    /**
+     * Returns whether an optional source-index collection permits one area.
+     * @param {number} sourceIndex Candidate source position.
+     * @param {Set<number> | number[] | null} allowedSourceIndexes Optional allow set.
+     * @returns {boolean}
+     */
+    static #isAllowedSourceIndex(sourceIndex, allowedSourceIndexes) {
+        if (allowedSourceIndexes === null) {
+            return true
+        }
+
+        if (typeof allowedSourceIndexes?.has === 'function') {
+            return allowedSourceIndexes.has(sourceIndex)
+        }
+
+        return (
+            Array.isArray(allowedSourceIndexes) &&
+            allowedSourceIndexes.includes(sourceIndex)
+        )
+    }
+
+    /**
+     * Resolves area bounds for the AABB index.
+     * @param {{ bounds: object }} area Prepared area.
+     * @returns {object}
+     */
+    static #resolveBounds(area) {
+        return area.bounds
+    }
+
+    /**
+     * Resolves stable flattened fill-island order for the AABB index.
+     * @param {{ sourceIndex: number }} area Prepared area.
+     * @returns {number}
+     */
+    static #resolveSourceIndex(area) {
+        return area.sourceIndex
+    }
+}

package/src/PcbScene3dCopperFillLoopSetResolver.mjs

@@ -0,0 +1,192 @@
+import { PcbAssemblyFillGeometryResolver } from './PcbAssemblyFillGeometryResolver.mjs'
+
+/**
+ * Resolves copper fills into canonical side-local polygon loop sets.
+ */
+export class PcbScene3dCopperFillLoopSetResolver {
+    static #AREA_EPSILON = 0.001
+    static #GEOMETRY_EPSILON = 0.001
+
+    /**
+     * Resolves every valid fill island in source order.
+     * @param {object[]} fills Filled copper primitives.
+     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
+     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
+     * @returns {{ outer: number[][], holes: number[][][], bounds: { minX: number, minY: number, maxX: number, maxY: number } }[]}
+     */
+    static resolve(fills, normalizeBoardPoint, mirrorY) {
+        const loopSets = []
+
+        for (const fill of fills || []) {
+            for (const loops of PcbAssemblyFillGeometryResolver.resolveAll(
+                fill
+            )) {
+                const loopSet =
+                    PcbScene3dCopperFillLoopSetResolver.#normalizeLoopSet(
+                        loops,
+                        normalizeBoardPoint,
+                        mirrorY
+                    )
+                if (loopSet) {
+                    loopSets.push(loopSet)
+                }
+            }
+        }
+
+        return loopSets
+    }
+
+    /**
+     * Normalizes one fill island and discards degenerate outer geometry.
+     * @param {{ outer?: any[], holes?: any[][] }} loops Source loops.
+     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
+     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
+     * @returns {{ outer: number[][], holes: number[][][], bounds: { minX: number, minY: number, maxX: number, maxY: number } } | null}
+     */
+    static #normalizeLoopSet(loops, normalizeBoardPoint, mirrorY) {
+        const outer = PcbScene3dCopperFillLoopSetResolver.#normalizeLoop(
+            loops?.outer,
+            normalizeBoardPoint,
+            mirrorY
+        )
+        if (!PcbScene3dCopperFillLoopSetResolver.#isValidLoop(outer)) {
+            return null
+        }
+
+        const holes = []
+        for (const sourceHole of loops?.holes || []) {
+            const hole = PcbScene3dCopperFillLoopSetResolver.#normalizeLoop(
+                sourceHole,
+                normalizeBoardPoint,
+                mirrorY
+            )
+            if (PcbScene3dCopperFillLoopSetResolver.#isValidLoop(hole)) {
+                holes.push(hole)
+            }
+        }
+
+        return {
+            outer,
+            holes,
+            bounds: PcbScene3dCopperFillLoopSetResolver.#resolveBounds(outer)
+        }
+    }
+
+    /**
+     * Converts one loop into clean finite side-local coordinate pairs.
+     * @param {any[]} loop Source points.
+     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
+     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
+     * @returns {number[][]}
+     */
+    static #normalizeLoop(loop, normalizeBoardPoint, mirrorY) {
+        const points = []
+
+        for (const point of loop || []) {
+            const normalized = normalizeBoardPoint(
+                Number(point?.x ?? point?.[0]),
+                Number(point?.y ?? point?.[1])
+            )
+            const x = Number(normalized?.x)
+            const y = mirrorY ? -Number(normalized?.y) : Number(normalized?.y)
+
+            if (Number.isFinite(x) && Number.isFinite(y)) {
+                points.push([x, y])
+            }
+        }
+
+        return PcbScene3dCopperFillLoopSetResolver.#cleanLoop(points)
+    }
+
+    /**
+     * Removes consecutive duplicate and explicit closing points.
+     * @param {number[][]} points Candidate points.
+     * @returns {number[][]}
+     */
+    static #cleanLoop(points) {
+        const loop = []
+
+        for (const point of points || []) {
+            const previous = loop[loop.length - 1]
+            if (
+                previous &&
+                Math.abs(previous[0] - point[0]) <
+                    PcbScene3dCopperFillLoopSetResolver.#GEOMETRY_EPSILON &&
+                Math.abs(previous[1] - point[1]) <
+                    PcbScene3dCopperFillLoopSetResolver.#GEOMETRY_EPSILON
+            ) {
+                continue
+            }
+            loop.push(point)
+        }
+
+        const first = loop[0]
+        const last = loop[loop.length - 1]
+        if (
+            first &&
+            last &&
+            Math.abs(first[0] - last[0]) <
+                PcbScene3dCopperFillLoopSetResolver.#GEOMETRY_EPSILON &&
+            Math.abs(first[1] - last[1]) <
+                PcbScene3dCopperFillLoopSetResolver.#GEOMETRY_EPSILON
+        ) {
+            loop.pop()
+        }
+
+        return loop
+    }
+
+    /**
+     * Returns true when one loop has sufficient non-collinear area.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {boolean}
+     */
+    static #isValidLoop(loop) {
+        return (
+            Array.isArray(loop) &&
+            loop.length >= 3 &&
+            Math.abs(PcbScene3dCopperFillLoopSetResolver.#signedArea(loop)) >
+                PcbScene3dCopperFillLoopSetResolver.#AREA_EPSILON
+        )
+    }
+
+    /**
+     * Computes one loop's signed shoelace area.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {number}
+     */
+    static #signedArea(loop) {
+        let area = 0
+
+        for (let index = 0; index < loop.length; index += 1) {
+            const current = loop[index]
+            const next = loop[(index + 1) % loop.length]
+            area += current[0] * next[1] - next[0] * current[1]
+        }
+
+        return area / 2
+    }
+
+    /**
+     * Resolves finite axis-aligned bounds for a valid loop.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number }}
+     */
+    static #resolveBounds(loop) {
+        const bounds = {
+            minX: Infinity,
+            minY: Infinity,
+            maxX: -Infinity,
+            maxY: -Infinity
+        }
+
+        for (const point of loop) {
+            bounds.minX = Math.min(bounds.minX, point[0])
+            bounds.minY = Math.min(bounds.minY, point[1])
+            bounds.maxX = Math.max(bounds.maxX, point[0])
+            bounds.maxY = Math.max(bounds.maxY, point[1])
+        }
+
+        return bounds
+    }
+}