pcb-scene3d-viewer 1.1.48 → 1.1.49

package/src/PcbScene3dCopperFillPolygonBoolean.mjs

@@ -0,0 +1,235 @@
+import polygonClipping from 'polygon-clipping'
+
+/**
+ * Normalizes and subtracts copper fill loop sets with polygon booleans.
+ */
+export class PcbScene3dCopperFillPolygonBoolean {
+    static #AREA_EPSILON = 0.001
+
+    /**
+     * Resolves the remaining loop sets after subtracting already emitted
+     * copper areas.
+     * @param {{ outer: number[][], holes: number[][][], bounds: object }} loopSet Candidate loop set.
+     * @param {number[][][][]} emittedPolygons Already emitted polygon-clipping polygons.
+     * @returns {{ outer: number[][], holes: number[][][], bounds: object }[] | null}
+     */
+    static resolveRemainingLoopSets(loopSet, emittedPolygons) {
+        const subjectPolygons =
+            PcbScene3dCopperFillPolygonBoolean.resolveNormalizedPolygons(
+                loopSet
+            )
+        if (!subjectPolygons.length) {
+            return []
+        }
+
+        if (!emittedPolygons.length) {
+            return PcbScene3dCopperFillPolygonBoolean.#multiPolygonToLoopSets(
+                subjectPolygons
+            )
+        }
+
+        try {
+            return PcbScene3dCopperFillPolygonBoolean.#multiPolygonToLoopSets(
+                polygonClipping.difference(subjectPolygons, ...emittedPolygons)
+            )
+        } catch {
+            return null
+        }
+    }
+
+    /**
+     * Normalizes one loop set with polygon boolean semantics.
+     * @param {{ outer: number[][], holes: number[][][] }} loopSet Normalized loop set.
+     * @returns {number[][][][]}
+     */
+    static resolveNormalizedPolygons(loopSet) {
+        const subject =
+            PcbScene3dCopperFillPolygonBoolean.#loopSetToPolygon(loopSet)
+        if (!subject) {
+            return []
+        }
+
+        try {
+            return polygonClipping.union(subject)
+        } catch {
+            return [subject]
+        }
+    }
+
+    /**
+     * Converts one normalized loop set to a polygon-clipping polygon.
+     * @param {{ outer: number[][], holes: number[][][] }} loopSet Normalized loop set.
+     * @returns {number[][][] | null}
+     */
+    static #loopSetToPolygon(loopSet) {
+        const outer = PcbScene3dCopperFillPolygonBoolean.#closedRing(
+            loopSet?.outer
+        )
+        if (!outer.length) {
+            return null
+        }
+
+        return [
+            outer,
+            ...(loopSet?.holes || [])
+                .map((hole) =>
+                    PcbScene3dCopperFillPolygonBoolean.#closedRing(hole)
+                )
+                .filter((hole) => hole.length)
+        ]
+    }
+
+    /**
+     * Converts polygon-clipping output into normalized loop sets.
+     * @param {number[][][][]} multiPolygon Clipped multipolygon.
+     * @returns {{ outer: number[][], holes: number[][][], bounds: object }[]}
+     */
+    static #multiPolygonToLoopSets(multiPolygon) {
+        return (multiPolygon || [])
+            .map((polygon) => {
+                const outer = PcbScene3dCopperFillPolygonBoolean.#cleanLoop(
+                    polygon?.[0] || []
+                )
+                if (!PcbScene3dCopperFillPolygonBoolean.#isValidLoop(outer)) {
+                    return null
+                }
+
+                const holes = (polygon || [])
+                    .slice(1)
+                    .map((ring) =>
+                        PcbScene3dCopperFillPolygonBoolean.#cleanLoop(ring)
+                    )
+                    .filter((ring) =>
+                        PcbScene3dCopperFillPolygonBoolean.#isValidLoop(ring)
+                    )
+
+                return {
+                    outer,
+                    holes,
+                    bounds: PcbScene3dCopperFillPolygonBoolean.#loopBounds(
+                        outer
+                    )
+                }
+            })
+            .filter(Boolean)
+    }
+
+    /**
+     * Closes one loop for polygon boolean operations.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {number[][]}
+     */
+    static #closedRing(loop) {
+        const cleanLoop = PcbScene3dCopperFillPolygonBoolean.#cleanLoop(loop)
+        if (!PcbScene3dCopperFillPolygonBoolean.#isValidLoop(cleanLoop)) {
+            return []
+        }
+
+        const first = cleanLoop[0]
+        const last = cleanLoop[cleanLoop.length - 1]
+        const closed = cleanLoop.map((point) => [point[0], point[1]])
+        if (
+            Math.abs(first[0] - last[0]) >=
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON ||
+            Math.abs(first[1] - last[1]) >=
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+        ) {
+            closed.push([first[0], first[1]])
+        }
+        return closed
+    }
+
+    /**
+     * Removes invalid and duplicate loop points.
+     * @param {number[][]} points Candidate points.
+     * @returns {number[][]}
+     */
+    static #cleanLoop(points) {
+        const loop = []
+        for (const point of points || []) {
+            const x = Number(point?.[0])
+            const y = Number(point?.[1])
+            if (!Number.isFinite(x) || !Number.isFinite(y)) {
+                continue
+            }
+
+            const previous = loop[loop.length - 1]
+            if (
+                previous &&
+                Math.abs(previous[0] - x) <
+                    PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON &&
+                Math.abs(previous[1] - y) <
+                    PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+            ) {
+                continue
+            }
+            loop.push([x, y])
+        }
+
+        const first = loop[0]
+        const last = loop[loop.length - 1]
+        if (
+            first &&
+            last &&
+            Math.abs(first[0] - last[0]) <
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON &&
+            Math.abs(first[1] - last[1]) <
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+        ) {
+            loop.pop()
+        }
+
+        return loop
+    }
+
+    /**
+     * Checks whether one loop has enough non-collinear area.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {boolean}
+     */
+    static #isValidLoop(loop) {
+        return (
+            Array.isArray(loop) &&
+            loop.length >= 3 &&
+            Math.abs(PcbScene3dCopperFillPolygonBoolean.#signedArea(loop)) >
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+        )
+    }
+
+    /**
+     * Computes axis-aligned bounds for one loop.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number }}
+     */
+    static #loopBounds(loop) {
+        return (loop || []).reduce(
+            (bounds, point) => ({
+                minX: Math.min(bounds.minX, Number(point?.[0])),
+                minY: Math.min(bounds.minY, Number(point?.[1])),
+                maxX: Math.max(bounds.maxX, Number(point?.[0])),
+                maxY: Math.max(bounds.maxY, Number(point?.[1]))
+            }),
+            {
+                minX: Infinity,
+                minY: Infinity,
+                maxX: -Infinity,
+                maxY: -Infinity
+            }
+        )
+    }
+
+    /**
+     * Computes signed loop 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
+    }
+}

package/src/PcbScene3dCopperPrismBuilder.mjs

@@ -0,0 +1,92 @@
+/**
+ * Appends shallow copper-prism triangles to packed position buffers.
+ */
+export class PcbScene3dCopperPrismBuilder {
+    static #COPPER_THICKNESS_MIL = 2.2
+
+    /**
+     * Returns the visual copper extrusion thickness.
+     * @returns {number}
+     */
+    static thicknessMil() {
+        return PcbScene3dCopperPrismBuilder.#COPPER_THICKNESS_MIL
+    }
+
+    /**
+     * Returns half the visual copper extrusion thickness.
+     * @returns {number}
+     */
+    static halfThicknessMil() {
+        return PcbScene3dCopperPrismBuilder.#COPPER_THICKNESS_MIL / 2
+    }
+
+    /**
+     * Appends one shallow triangular prism into the position buffer.
+     * @param {number[]} positions Position buffer.
+     * @param {{ x: number, y: number }} a First point.
+     * @param {{ x: number, y: number }} b Second point.
+     * @param {{ x: number, y: number }} c Third point.
+     * @param {number} z Center Z position.
+     * @returns {void}
+     */
+    static appendTriangle(positions, a, b, c, z) {
+        const halfThickness = PcbScene3dCopperPrismBuilder.halfThicknessMil()
+        const topZ = z + halfThickness
+        const bottomZ = z - halfThickness
+        positions.push(
+            a.x,
+            a.y,
+            topZ,
+            b.x,
+            b.y,
+            topZ,
+            c.x,
+            c.y,
+            topZ,
+            c.x,
+            c.y,
+            bottomZ,
+            b.x,
+            b.y,
+            bottomZ,
+            a.x,
+            a.y,
+            bottomZ
+        )
+    }
+
+    /**
+     * Appends a side wall for one actual copper boundary edge.
+     * @param {number[]} positions Position buffer.
+     * @param {{ x: number, y: number }} start Wall start point.
+     * @param {{ x: number, y: number }} end Wall end point.
+     * @param {number} z Center Z position.
+     * @returns {void}
+     */
+    static appendBoundarySideTriangles(positions, start, end, z) {
+        const halfThickness = PcbScene3dCopperPrismBuilder.halfThicknessMil()
+        const topZ = z + halfThickness
+        const bottomZ = z - halfThickness
+
+        positions.push(
+            start.x,
+            start.y,
+            topZ,
+            end.x,
+            end.y,
+            topZ,
+            end.x,
+            end.y,
+            bottomZ,
+            start.x,
+            start.y,
+            topZ,
+            end.x,
+            end.y,
+            bottomZ,
+            start.x,
+            start.y,
+            bottomZ
+        )
+    }
+}

package/src/PcbScene3dMaskCoveredCopperSideGroupBuilder.mjs

@@ -1,4 +1,5 @@
 import { PcbScene3dGeometryZCompressor } from './PcbScene3dGeometryZCompressor.mjs'
+import { PcbScene3dMaskCoveredCopperSurfaceFilter } from './PcbScene3dMaskCoveredCopperSurfaceFilter.mjs'
 
 /**
  * Builds side-specific copper relief groups that sit below solder mask.
@@ -98,10 +99,10 @@ export class PcbScene3dMaskCoveredCopperSideGroupBuilder {
         if (!mesh) {
             return
         }
-
         PcbScene3dGeometryZCompressor.compressMaskCoveredCopperMesh(mesh, z, {
             centerOffsetMil: options.centerOffsetMil
         })
+        PcbScene3dMaskCoveredCopperSurfaceFilter.keepOuterSurface(mesh)
         mesh.name = name
         mesh.renderOrder = Number(options.renderOrder || 0)
         PcbScene3dMaskCoveredCopperSideGroupBuilder.#applyCopperTint(

package/src/PcbScene3dMaskCoveredCopperSurfaceFilter.mjs

@@ -0,0 +1,64 @@
+/**
+ * Keeps only the outward-facing surface of solder-mask-covered copper relief.
+ */
+export class PcbScene3dMaskCoveredCopperSurfaceFilter {
+    static #Z_EPSILON = 0.001
+
+    /**
+     * Removes hidden underside and side-wall triangles from one mesh.
+     * @param {any | null} mesh Copper relief mesh.
+     * @returns {void}
+     */
+    static keepOuterSurface(mesh) {
+        const geometry = mesh?.geometry
+        const position = geometry?.getAttribute?.('position')
+        const source = position?.array
+        if (!source || position.itemSize !== 3) {
+            return
+        }
+
+        const maxZ = PcbScene3dMaskCoveredCopperSurfaceFilter.#maxZ(source)
+        const filtered = []
+        for (let index = 0; index + 8 < source.length; index += 9) {
+            if (
+                [2, 5, 8].every(
+                    (offset) =>
+                        Math.abs(source[index + offset] - maxZ) <=
+                        PcbScene3dMaskCoveredCopperSurfaceFilter.#Z_EPSILON
+                )
+            ) {
+                filtered.push(...source.slice(index, index + 9))
+            }
+        }
+
+        if (!filtered.length || filtered.length === source.length) {
+            return
+        }
+
+        geometry.setAttribute(
+            'position',
+            new position.constructor(
+                filtered,
+                position.itemSize,
+                position.normalized
+            )
+        )
+        geometry.deleteAttribute?.('normal')
+        geometry.computeVertexNormals?.()
+        geometry.computeBoundingBox?.()
+        geometry.computeBoundingSphere?.()
+    }
+
+    /**
+     * Resolves the highest Z plane in one packed XYZ buffer.
+     * @param {ArrayLike<number>} source Position buffer.
+     * @returns {number}
+     */
+    static #maxZ(source) {
+        let maxZ = -Infinity
+        for (let index = 2; index < source.length; index += 3) {
+            maxZ = Math.max(maxZ, Number(source[index]))
+        }
+        return maxZ
+    }
+}