circuit-json-to-lbrn 0.0.54 → 0.0.55

package/dist/index.d.ts

@@ -10,6 +10,7 @@ interface ConvertCircuitJsonToLbrnOptions {
     margin?: number;
     includeCopper?: boolean;
     includeSoldermask?: boolean;
+    includeSoldermaskCure?: boolean;
     globalCopperSoldermaskMarginAdjustment?: number;
     solderMaskMarginPercent?: number;
     includeLayers?: Array<"top" | "bottom">;

package/dist/index.js

@@ -2749,7 +2749,132 @@ var LAYER_INDEXES = {
   topCopperCutFill: 6,
   bottomCopperCutFill: 7,
   topOxidationCleaning: 8,
-  bottomOxidationCleaning: 9
+  bottomOxidationCleaning: 9,
+  soldermaskCure: 10
+};
+
+// lib/createSoldermaskCureLayer.ts
+import { Point as Point4, Polygon as Polygon7 } from "@flatten-js/core";
+import { ShapeGroup as ShapeGroup3, ShapePath as ShapePath30 } from "lbrnts";
+var contourToPolygon3 = (contour) => {
+  if (contour.length < 3) return null;
+  const points = contour.map(([x, y]) => new Point4(x, y));
+  try {
+    const polygon = new Polygon7(points);
+    if (polygon.faces.size > 0) {
+      return polygon;
+    }
+  } catch {
+  }
+  return null;
+};
+var shapePathToContour = (shapePath) => {
+  if (!shapePath.verts || shapePath.verts.length < 3) return null;
+  const contour = shapePath.verts.map(
+    (vert) => [vert.x, vert.y]
+  );
+  if (contour.length > 3) {
+    const first = contour[0];
+    const last = contour[contour.length - 1];
+    if (first && last && first[0] === last[0] && first[1] === last[1]) {
+      contour.pop();
+    }
+  }
+  return contour.length >= 3 ? contour : null;
+};
+var collectSoldermaskContours = (project, soldermaskCutIndex) => {
+  const contours = [];
+  for (const child of project.children) {
+    if (child instanceof ShapePath30) {
+      if (child.cutIndex !== soldermaskCutIndex) {
+        continue;
+      }
+      const contour = shapePathToContour(child);
+      if (contour) {
+        contours.push(contour);
+      }
+      continue;
+    }
+    if (child instanceof ShapeGroup3) {
+      for (const groupChild of child.children) {
+        if (groupChild instanceof ShapePath30) {
+          if (groupChild.cutIndex !== soldermaskCutIndex) {
+            continue;
+          }
+          const contour = shapePathToContour(groupChild);
+          if (contour) {
+            contours.push(contour);
+          }
+        }
+      }
+    }
+  }
+  return contours;
+};
+var createSoldermaskCureLayer = async ({
+  ctx
+}) => {
+  const { project, boardOutlineContour, soldermaskCureCutSetting } = ctx;
+  if (!soldermaskCureCutSetting) {
+    return;
+  }
+  if (ctx.soldermaskCutSetting.index === void 0) {
+    return;
+  }
+  const soldermaskCutIndex = ctx.soldermaskCutSetting.index;
+  if (!boardOutlineContour || boardOutlineContour.length < 3) {
+    console.warn(
+      "Cannot create soldermask cure layer: no board outline available"
+    );
+    return;
+  }
+  try {
+    const manifold = await getManifold();
+    const { CrossSection } = manifold;
+    const allContours = collectSoldermaskContours(project, soldermaskCutIndex);
+    if (allContours.length === 0) {
+      return;
+    }
+    const boardOutline = new CrossSection([boardOutlineContour], "Positive");
+    const soldermaskOpenings = new CrossSection(allContours, "Positive");
+    const cureArea = boardOutline.subtract(soldermaskOpenings);
+    const simplifiedArea = cureArea.simplify(1e-3);
+    const resultContours = simplifiedArea.toPolygons();
+    if (resultContours.length === 0) {
+      boardOutline.delete();
+      soldermaskOpenings.delete();
+      cureArea.delete();
+      simplifiedArea.delete();
+      return;
+    }
+    const shapeGroup = new ShapeGroup3();
+    for (const contour of resultContours) {
+      const polygon = contourToPolygon3(contour);
+      if (!polygon) continue;
+      for (const island of polygon.splitToIslands()) {
+        const { verts, prims } = polygonToShapePathData(island);
+        if (verts.length > 0) {
+          shapeGroup.children.push(
+            new ShapePath30({
+              cutIndex: soldermaskCureCutSetting.index,
+              verts,
+              prims,
+              isClosed: true
+            })
+          );
+        }
+      }
+    }
+    if (shapeGroup.children.length > 0) {
+      project.children.push(shapeGroup);
+    }
+    boardOutline.delete();
+    soldermaskOpenings.delete();
+    cureArea.delete();
+    simplifiedArea.delete();
+  } catch (error) {
+    console.warn("Failed to create soldermask cure layer:", error);
+  }
 };
 
 // lib/index.ts
@@ -2764,6 +2889,8 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
   const laserSpotSize = options.laserSpotSize ?? 5e-3;
   const includeCopper = options.includeCopper ?? true;
   const includeSoldermask = options.includeSoldermask ?? false;
+  const includeSoldermaskCure = options.includeSoldermaskCure ?? false;
+  const shouldIncludeSoldermaskCure = includeSoldermask && includeSoldermaskCure;
   const globalCopperSoldermaskMarginAdjustment = options.globalCopperSoldermaskMarginAdjustment ?? 0;
   const solderMaskMarginPercent = options.solderMaskMarginPercent ?? 0;
   const laserProfile = options.laserProfile;
@@ -2827,6 +2954,21 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
     crossHatch: true
   });
   project.children.push(soldermaskCutSetting);
+  let soldermaskCureCutSetting;
+  if (shouldIncludeSoldermaskCure) {
+    soldermaskCureCutSetting = new CutSetting({
+      type: "Scan",
+      index: LAYER_INDEXES.soldermaskCure,
+      name: "Cut Soldermask Cure",
+      numPasses: 1,
+      speed: 150,
+      scanOpt: "individual",
+      interval: 0.18,
+      angle: 45,
+      crossHatch: true
+    });
+    project.children.push(soldermaskCureCutSetting);
+  }
   let topTraceClearanceAreaCutSetting;
   let bottomTraceClearanceAreaCutSetting;
   if (shouldGenerateTraceClearanceZones) {
@@ -2936,6 +3078,7 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
     bottomCopperCutSetting,
     throughBoardCutSetting,
     soldermaskCutSetting,
+    soldermaskCureCutSetting,
     connMap,
     topCutNetGeoms: /* @__PURE__ */ new Map(),
     bottomCutNetGeoms: /* @__PURE__ */ new Map(),
@@ -2944,6 +3087,7 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
     origin,
     includeCopper,
     includeSoldermask,
+    includeSoldermaskCure,
     globalCopperSoldermaskMarginAdjustment,
     includeLayers,
     traceMargin,
@@ -3040,6 +3184,9 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
       await createOxidationCleaningLayerForLayer({ layer: "bottom", ctx });
     }
   }
+  if (shouldIncludeSoldermaskCure) {
+    await createSoldermaskCureLayer({ ctx });
+  }
   return project;
 };
 export {

package/lib/ConvertContext.ts

@@ -15,6 +15,7 @@ export interface ConvertContext {
   bottomCopperCutSetting: CutSetting
   throughBoardCutSetting: CutSetting
   soldermaskCutSetting: CutSetting
+  soldermaskCureCutSetting?: CutSetting
 
   connMap: ConnectivityMap
 
@@ -33,6 +34,7 @@ export interface ConvertContext {
   // Include flags
   includeCopper: boolean
   includeSoldermask: boolean
+  includeSoldermaskCure: boolean
   includeLayers: Array<"top" | "bottom">
 
   // Global copper soldermask margin adjustment (can be negative)

package/lib/createSoldermaskCureLayer.ts

@@ -0,0 +1,160 @@
+import { Point, Polygon } from "@flatten-js/core"
+import { ShapeGroup, ShapePath } from "lbrnts"
+import type { ConvertContext } from "./ConvertContext"
+import { getManifold } from "./getManifold"
+import { polygonToShapePathData } from "./polygon-to-shape-path"
+
+type Contour = Array<[number, number]>
+
+/**
+ * Converts a single contour to a flatten-js Polygon
+ */
+const contourToPolygon = (contour: Contour): Polygon | null => {
+  if (contour.length < 3) return null
+
+  const points = contour.map(([x, y]) => new Point(x, y))
+  try {
+    const polygon = new Polygon(points)
+    if (polygon.faces.size > 0) {
+      return polygon
+    }
+  } catch {
+    // Skip invalid polygons
+  }
+  return null
+}
+
+const shapePathToContour = (shapePath: ShapePath): Contour | null => {
+  if (!shapePath.verts || shapePath.verts.length < 3) return null
+  const contour = shapePath.verts.map(
+    (vert) => [vert.x, vert.y] as [number, number],
+  )
+  if (contour.length > 3) {
+    const first = contour[0]
+    const last = contour[contour.length - 1]
+    if (first && last && first[0] === last[0] && first[1] === last[1]) {
+      contour.pop()
+    }
+  }
+  return contour.length >= 3 ? contour : null
+}
+
+const collectSoldermaskContours = (
+  project: ConvertContext["project"],
+  soldermaskCutIndex: number,
+) => {
+  const contours: Contour[] = []
+
+  for (const child of project.children) {
+    if (child instanceof ShapePath) {
+      if (child.cutIndex !== soldermaskCutIndex) {
+        continue
+      }
+      const contour = shapePathToContour(child)
+      if (contour) {
+        contours.push(contour)
+      }
+      continue
+    }
+
+    if (child instanceof ShapeGroup) {
+      for (const groupChild of child.children) {
+        if (groupChild instanceof ShapePath) {
+          if (groupChild.cutIndex !== soldermaskCutIndex) {
+            continue
+          }
+          const contour = shapePathToContour(groupChild)
+          if (contour) {
+            contours.push(contour)
+          }
+        }
+      }
+    }
+  }
+
+  return contours
+}
+
+/**
+ * Creates a soldermask cure layer by subtracting soldermask openings from the board outline.
+ */
+export const createSoldermaskCureLayer = async ({
+  ctx,
+}: {
+  ctx: ConvertContext
+}): Promise<void> => {
+  const { project, boardOutlineContour, soldermaskCureCutSetting } = ctx
+
+  if (!soldermaskCureCutSetting) {
+    return
+  }
+
+  if (ctx.soldermaskCutSetting.index === undefined) {
+    return
+  }
+  const soldermaskCutIndex = ctx.soldermaskCutSetting.index
+
+  if (!boardOutlineContour || boardOutlineContour.length < 3) {
+    console.warn(
+      "Cannot create soldermask cure layer: no board outline available",
+    )
+    return
+  }
+
+  try {
+    const manifold = await getManifold()
+    const { CrossSection } = manifold
+
+    const allContours = collectSoldermaskContours(project, soldermaskCutIndex)
+    if (allContours.length === 0) {
+      return
+    }
+
+    const boardOutline = new CrossSection([boardOutlineContour], "Positive")
+    const soldermaskOpenings = new CrossSection(allContours, "Positive")
+    const cureArea = boardOutline.subtract(soldermaskOpenings)
+    const simplifiedArea = cureArea.simplify(0.001)
+    const resultContours: Contour[] = simplifiedArea.toPolygons()
+
+    if (resultContours.length === 0) {
+      boardOutline.delete()
+      soldermaskOpenings.delete()
+      cureArea.delete()
+      simplifiedArea.delete()
+      return
+    }
+
+    const shapeGroup = new ShapeGroup()
+
+    for (const contour of resultContours) {
+      const polygon = contourToPolygon(contour)
+      if (!polygon) continue
+
+      for (const island of polygon.splitToIslands()) {
+        const { verts, prims } = polygonToShapePathData(island)
+
+        if (verts.length > 0) {
+          shapeGroup.children.push(
+            new ShapePath({
+              cutIndex: soldermaskCureCutSetting.index,
+              verts,
+              prims,
+              isClosed: true,
+            }),
+          )
+        }
+      }
+    }
+
+    if (shapeGroup.children.length > 0) {
+      project.children.push(shapeGroup)
+    }
+
+    boardOutline.delete()
+    soldermaskOpenings.delete()
+    cureArea.delete()
+    simplifiedArea.delete()
+  } catch (error) {
+    console.warn("Failed to create soldermask cure layer:", error)
+  }
+}

package/lib/index.ts

@@ -19,6 +19,7 @@ import { createTraceClearanceAreasForLayer } from "./createTraceClearanceAreasFo
 import { createCopperCutFillForLayer } from "./createCopperCutFillForLayer"
 import { createOxidationCleaningLayerForLayer } from "./createOxidationCleaningLayerForLayer"
 import { LAYER_INDEXES } from "./layer-indexes"
+import { createSoldermaskCureLayer } from "./createSoldermaskCureLayer"
 
 export interface ConvertCircuitJsonToLbrnOptions {
   includeSilkscreen?: boolean
@@ -26,6 +27,7 @@ export interface ConvertCircuitJsonToLbrnOptions {
   margin?: number
   includeCopper?: boolean
   includeSoldermask?: boolean
+  includeSoldermaskCure?: boolean
   globalCopperSoldermaskMarginAdjustment?: number
   solderMaskMarginPercent?: number
   includeLayers?: Array<"top" | "bottom">
@@ -79,6 +81,8 @@ export const convertCircuitJsonToLbrn = async (
   const laserSpotSize = options.laserSpotSize ?? 0.005
   const includeCopper = options.includeCopper ?? true
   const includeSoldermask = options.includeSoldermask ?? false
+  const includeSoldermaskCure = options.includeSoldermaskCure ?? false
+  const shouldIncludeSoldermaskCure = includeSoldermask && includeSoldermaskCure
   const globalCopperSoldermaskMarginAdjustment =
     options.globalCopperSoldermaskMarginAdjustment ?? 0
   const solderMaskMarginPercent = options.solderMaskMarginPercent ?? 0
@@ -158,6 +162,22 @@ export const convertCircuitJsonToLbrn = async (
   })
   project.children.push(soldermaskCutSetting)
 
+  let soldermaskCureCutSetting: CutSetting | undefined
+  if (shouldIncludeSoldermaskCure) {
+    soldermaskCureCutSetting = new CutSetting({
+      type: "Scan",
+      index: LAYER_INDEXES.soldermaskCure,
+      name: "Cut Soldermask Cure",
+      numPasses: 1,
+      speed: 150,
+      scanOpt: "individual",
+      interval: 0.18,
+      angle: 45,
+      crossHatch: true,
+    })
+    project.children.push(soldermaskCureCutSetting)
+  }
+
   // Create trace clearance cut settings if needed
   let topTraceClearanceAreaCutSetting: CutSetting | undefined
   let bottomTraceClearanceAreaCutSetting: CutSetting | undefined
@@ -282,6 +302,7 @@ export const convertCircuitJsonToLbrn = async (
     bottomCopperCutSetting,
     throughBoardCutSetting,
     soldermaskCutSetting,
+    soldermaskCureCutSetting,
     connMap,
     topCutNetGeoms: new Map(),
     bottomCutNetGeoms: new Map(),
@@ -290,6 +311,7 @@ export const convertCircuitJsonToLbrn = async (
     origin,
     includeCopper,
     includeSoldermask,
+    includeSoldermaskCure,
     globalCopperSoldermaskMarginAdjustment,
     includeLayers,
     traceMargin,
@@ -411,5 +433,9 @@ export const convertCircuitJsonToLbrn = async (
     }
   }
 
+  if (shouldIncludeSoldermaskCure) {
+    await createSoldermaskCureLayer({ ctx })
+  }
+
   return project
 }

package/lib/layer-indexes.ts

@@ -17,6 +17,7 @@ export const LAYER_INDEXES = {
   bottomCopperCutFill: 7,
   topOxidationCleaning: 8,
   bottomOxidationCleaning: 9,
+  soldermaskCure: 10,
 } as const
 
 export type LayerIndex = (typeof LAYER_INDEXES)[keyof typeof LAYER_INDEXES]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-json-to-lbrn",
   "main": "dist/index.js",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "type": "module",
   "scripts": {
     "start": "bun run site/index.html",