circuit-json-to-lbrn 0.0.42 → 0.0.44

package/dist/index.d.ts

@@ -15,6 +15,17 @@ interface ConvertCircuitJsonToLbrnOptions {
     includeLayers?: Array<"top" | "bottom">;
     traceMargin?: number;
     laserSpotSize?: number;
+    /**
+     * Whether to generate copper cut fill layers.
+     * Creates a ring/band around traces and pads that will be laser cut
+     * to remove copper, without cutting into the traces or pads themselves.
+     */
+    includeCopperCutFill?: boolean;
+    /**
+     * Margin to expand the copper outline for the cut fill band (in mm).
+     * This determines how wide the band of copper removal will be around traces/pads.
+     */
+    copperCutFillMargin?: number;
     laserProfile?: {
         copper?: {
             speed?: number;
@@ -30,6 +41,6 @@ interface ConvertCircuitJsonToLbrnOptions {
         };
     };
 }
-declare const convertCircuitJsonToLbrn: (circuitJson: CircuitJson, options?: ConvertCircuitJsonToLbrnOptions) => LightBurnProject;
+declare const convertCircuitJsonToLbrn: (circuitJson: CircuitJson, options?: ConvertCircuitJsonToLbrnOptions) => Promise<LightBurnProject>;
 
 export { type ConvertCircuitJsonToLbrnOptions, convertCircuitJsonToLbrn };

package/dist/index.js

@@ -1728,6 +1728,9 @@ var createCirclePolygon = (center, radius, numPoints = 16) => {
   }
   return new Flatten4.Polygon(points);
 };
+var positionKey = (x, y) => {
+  return `${x.toFixed(6)},${y.toFixed(6)}`;
+};
 var addPcbTrace = (trace, ctx) => {
   const {
     topCutNetGeoms,
@@ -1738,7 +1741,9 @@ var addPcbTrace = (trace, ctx) => {
     origin,
     includeCopper,
     includeLayers,
-    traceMargin
+    traceMargin,
+    topTraceEndpoints,
+    bottomTraceEndpoints
   } = ctx;
   if (!includeCopper) {
     return;
@@ -1779,22 +1784,32 @@ var addPcbTrace = (trace, ctx) => {
       cutNetGeoms.get(netId)?.push(result);
     }
     const segments = layerSegments.get(layer);
+    const endpointSet = layer === "top" ? topTraceEndpoints : bottomTraceEndpoints;
     if (segments) {
       for (const segment of segments) {
         if (segment.length >= 2) {
           const firstPoint = segment[0];
           const lastPoint = segment[segment.length - 1];
           const radius = traceWidth / 2 * 1.1;
-          const startCircle = createCirclePolygon(
-            { x: firstPoint.x + origin.x, y: firstPoint.y + origin.y },
-            radius
-          );
-          cutNetGeoms.get(netId)?.push(startCircle);
-          const endCircle = createCirclePolygon(
-            { x: lastPoint.x + origin.x, y: lastPoint.y + origin.y },
-            radius
-          );
-          cutNetGeoms.get(netId)?.push(endCircle);
+          const startX = firstPoint.x + origin.x;
+          const startY = firstPoint.y + origin.y;
+          const startKey = positionKey(startX, startY);
+          if (!endpointSet.has(startKey)) {
+            endpointSet.add(startKey);
+            const startCircle = createCirclePolygon(
+              { x: startX, y: startY },
+              radius
+            );
+            cutNetGeoms.get(netId)?.push(startCircle);
+          }
+          const endX = lastPoint.x + origin.x;
+          const endY = lastPoint.y + origin.y;
+          const endKey = positionKey(endX, endY);
+          if (!endpointSet.has(endKey)) {
+            endpointSet.add(endKey);
+            const endCircle = createCirclePolygon({ x: endX, y: endY }, radius);
+            cutNetGeoms.get(netId)?.push(endCircle);
+          }
         }
       }
     }
@@ -2481,8 +2496,168 @@ var createTraceClearanceAreasForLayer = ({
   }
 };
 
+// lib/createCopperCutFillForLayer.ts
+import { Polygon as Polygon5, Box as Box4, Point as Point2 } from "@flatten-js/core";
+import { ShapePath as ShapePath28, ShapeGroup } from "lbrnts";
+
+// lib/getManifold.ts
+var manifoldInstance = null;
+var getManifold = async () => {
+  if (!manifoldInstance) {
+    let ManifoldModule;
+    try {
+      const moduleName = "manifold-3d";
+      ManifoldModule = (await import(
+        /* @vite-ignore */
+        moduleName
+      )).default;
+    } catch {
+      try {
+        const cdnUrl = "https://cdn.jsdelivr.net/npm/manifold-3d@3.0.0/manifold.js";
+        ManifoldModule = (await import(
+          /* @vite-ignore */
+          cdnUrl
+        )).default;
+      } catch (cdnError) {
+        throw new Error(
+          `Failed to load manifold-3d: not available in Node.js or via CDN. ${cdnError}`
+        );
+      }
+    }
+    manifoldInstance = await ManifoldModule();
+    manifoldInstance.setup();
+  }
+  return manifoldInstance;
+};
+
+// lib/createCopperCutFillForLayer.ts
+var polygonToContours = (polygon) => {
+  const contours = [];
+  if (polygon instanceof Box4) {
+    const { xmin, ymin, xmax, ymax } = polygon;
+    contours.push([
+      [xmin, ymin],
+      [xmax, ymin],
+      [xmax, ymax],
+      [xmin, ymax]
+    ]);
+  } else {
+    for (const face of polygon.faces) {
+      const contour = [];
+      for (const edge of face) {
+        contour.push([edge.start.x, edge.start.y]);
+      }
+      if (contour.length >= 3) {
+        contours.push(contour);
+      }
+    }
+  }
+  return contours;
+};
+var contourToPolygon = (contour) => {
+  if (contour.length < 3) return null;
+  const points = contour.map(([x, y]) => new Point2(x, y));
+  try {
+    const polygon = new Polygon5(points);
+    if (polygon.faces.size > 0) {
+      return polygon;
+    }
+  } catch {
+  }
+  return null;
+};
+var createCopperCutFillForLayer = async ({
+  layer,
+  ctx
+}) => {
+  const {
+    project,
+    connMap,
+    topCutNetGeoms,
+    bottomCutNetGeoms,
+    topCopperCutFillCutSetting,
+    bottomCopperCutFillCutSetting,
+    copperCutFillMargin
+  } = ctx;
+  const cutSetting = layer === "top" ? topCopperCutFillCutSetting : bottomCopperCutFillCutSetting;
+  if (!cutSetting) {
+    return;
+  }
+  const netGeomMap = layer === "top" ? topCutNetGeoms : bottomCutNetGeoms;
+  const allGeoms = [];
+  for (const net of Object.keys(connMap.netMap)) {
+    const netGeoms = netGeomMap.get(net);
+    if (netGeoms && netGeoms.length > 0) {
+      allGeoms.push(...netGeoms);
+    }
+  }
+  if (allGeoms.length === 0) {
+    return;
+  }
+  try {
+    const manifold = await getManifold();
+    const { CrossSection } = manifold;
+    const allContours = [];
+    for (const geom of allGeoms) {
+      const contours = polygonToContours(geom);
+      allContours.push(...contours);
+    }
+    if (allContours.length === 0) {
+      return;
+    }
+    const copperInside = new CrossSection(allContours, "Positive");
+    const outerBoundary = copperInside.offset(
+      copperCutFillMargin,
+      "Round",
+      // joinType for smooth corners
+      2,
+      // miterLimit
+      32
+      // circularSegments for round corners
+    );
+    const cutFillArea = outerBoundary.subtract(copperInside);
+    const simplifiedArea = cutFillArea.simplify(1e-3);
+    const resultContours = simplifiedArea.toPolygons();
+    if (resultContours.length === 0) {
+      copperInside.delete();
+      outerBoundary.delete();
+      cutFillArea.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 ShapePath28({
+              cutIndex: cutSetting.index,
+              verts,
+              prims,
+              isClosed: true
+              // Filled shapes should be closed
+            })
+          );
+        }
+      }
+    }
+    if (shapeGroup.children.length > 0) {
+      project.children.push(shapeGroup);
+    }
+    copperInside.delete();
+    outerBoundary.delete();
+    cutFillArea.delete();
+    simplifiedArea.delete();
+  } catch (error) {
+    console.warn(`Failed to create copper cut fill for ${layer} layer:`, error);
+  }
+};
+
 // lib/index.ts
-var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
+var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
   const db = cju2(circuitJson);
   const project = new LightBurnProject({
     appVersion: "1.7.03",
@@ -2496,6 +2671,8 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
   const globalCopperSoldermaskMarginAdjustment = options.globalCopperSoldermaskMarginAdjustment ?? 0;
   const solderMaskMarginPercent = options.solderMaskMarginPercent ?? 0;
   const laserProfile = options.laserProfile;
+  const includeCopperCutFill = options.includeCopperCutFill ?? false;
+  const copperCutFillMargin = options.copperCutFillMargin ?? 0.5;
   const defaultCopperSettings = {
     speed: 300,
     numPasses: 100,
@@ -2553,13 +2730,14 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     crossHatch: true
   });
   project.children.push(soldermaskCutSetting);
+  let nextCutIndex = 4;
   let topTraceClearanceAreaCutSetting;
   let bottomTraceClearanceAreaCutSetting;
   if (shouldGenerateTraceClearanceZones) {
     if (includeLayers.includes("top")) {
       topTraceClearanceAreaCutSetting = new CutSetting({
         type: "Scan",
-        index: 4,
+        index: nextCutIndex++,
         name: "Clear Top Trace Clearance Areas",
         numPasses: 12,
         speed: 100,
@@ -2573,7 +2751,7 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     if (includeLayers.includes("bottom")) {
       bottomTraceClearanceAreaCutSetting = new CutSetting({
         type: "Scan",
-        index: 5,
+        index: nextCutIndex++,
         name: "Clear Bottom Trace Clearance Areas",
         numPasses: 12,
         speed: 100,
@@ -2585,6 +2763,38 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
       project.children.push(bottomTraceClearanceAreaCutSetting);
     }
   }
+  let topCopperCutFillCutSetting;
+  let bottomCopperCutFillCutSetting;
+  if (includeCopperCutFill && includeCopper) {
+    if (includeLayers.includes("top")) {
+      topCopperCutFillCutSetting = new CutSetting({
+        type: "Scan",
+        index: nextCutIndex++,
+        name: "Top Copper Cut Fill",
+        numPasses: copperSettings.numPasses,
+        speed: copperSettings.speed,
+        scanOpt: "individual",
+        interval: laserSpotSize,
+        angle: 45,
+        crossHatch: true
+      });
+      project.children.push(topCopperCutFillCutSetting);
+    }
+    if (includeLayers.includes("bottom")) {
+      bottomCopperCutFillCutSetting = new CutSetting({
+        type: "Scan",
+        index: nextCutIndex++,
+        name: "Bottom Copper Cut Fill",
+        numPasses: copperSettings.numPasses,
+        speed: copperSettings.speed,
+        scanOpt: "individual",
+        interval: laserSpotSize,
+        angle: 45,
+        crossHatch: true
+      });
+      project.children.push(bottomCopperCutFillCutSetting);
+    }
+  }
   const connMap = getFullConnectivityMapFromCircuitJson(circuitJson);
   let origin = options.origin;
   if (!origin) {
@@ -2612,7 +2822,12 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     laserSpotSize,
     topTraceClearanceAreaCutSetting,
     bottomTraceClearanceAreaCutSetting,
-    solderMaskMarginPercent
+    solderMaskMarginPercent,
+    topCopperCutFillCutSetting,
+    bottomCopperCutFillCutSetting,
+    copperCutFillMargin,
+    topTraceEndpoints: /* @__PURE__ */ new Set(),
+    bottomTraceEndpoints: /* @__PURE__ */ new Set()
   };
   for (const net of Object.keys(connMap.netMap)) {
     ctx.topCutNetGeoms.set(net, []);
@@ -2657,6 +2872,14 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
       createTraceClearanceAreasForLayer({ layer: "bottom", ctx });
     }
   }
+  if (includeCopperCutFill && includeCopper) {
+    if (includeLayers.includes("top")) {
+      await createCopperCutFillForLayer({ layer: "top", ctx });
+    }
+    if (includeLayers.includes("bottom")) {
+      await createCopperCutFillForLayer({ layer: "bottom", ctx });
+    }
+  }
   return project;
 };
 export {

package/lib/ConvertContext.ts

@@ -44,6 +44,18 @@ export interface ConvertContext {
   topTraceClearanceAreaCutSetting?: CutSetting
   bottomTraceClearanceAreaCutSetting?: CutSetting
 
+  // Cut settings for copper cut fill layers
+  topCopperCutFillCutSetting?: CutSetting
+  bottomCopperCutFillCutSetting?: CutSetting
+
   // Percent-based solder mask margin (scales with element size)
   solderMaskMarginPercent: number
+
+  // Copper cut fill margin (how far to expand the copper outline for the cut fill band)
+  copperCutFillMargin: number
+
+  // Track trace endpoint positions to avoid duplicate circles
+  // Key is "x,y" rounded to 6 decimal places
+  topTraceEndpoints: Set<string>
+  bottomTraceEndpoints: Set<string>
 }

package/lib/createCopperCutFillForLayer.ts

@@ -0,0 +1,217 @@
+import { Polygon, Box, Point } from "@flatten-js/core"
+import type { ConvertContext } from "./ConvertContext"
+import { polygonToShapePathData } from "./polygon-to-shape-path"
+import { ShapePath, ShapeGroup } from "lbrnts"
+import { getManifold } from "./getManifold"
+
+type Contour = Array<[number, number]>
+
+/**
+ * Calculates the signed area of a contour.
+ * Positive area = counter-clockwise winding (outer boundary)
+ * Negative area = clockwise winding (hole)
+ */
+const getSignedArea = (contour: Contour): number => {
+  let area = 0
+  const n = contour.length
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n
+    area += contour[i]![0] * contour[j]![1]
+    area -= contour[j]![0] * contour[i]![1]
+  }
+  return area / 2
+}
+
+/**
+ * Converts a flatten-js Polygon to an array of contours for manifold CrossSection
+ * Each contour is an array of [x, y] coordinates
+ */
+const polygonToContours = (polygon: Polygon | Box): Contour[] => {
+  const contours: Contour[] = []
+
+  if (polygon instanceof Box) {
+    // Convert Box to contour
+    const { xmin, ymin, xmax, ymax } = polygon
+    contours.push([
+      [xmin, ymin],
+      [xmax, ymin],
+      [xmax, ymax],
+      [xmin, ymax],
+    ])
+  } else {
+    // Handle Polygon faces
+    for (const face of polygon.faces) {
+      const contour: Contour = []
+      for (const edge of face) {
+        contour.push([edge.start.x, edge.start.y])
+      }
+      if (contour.length >= 3) {
+        contours.push(contour)
+      }
+    }
+  }
+
+  return contours
+}
+
+/**
+ * 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
+}
+
+/**
+ * Creates copper cut fill for a given layer using manifold3d CrossSection for offset operations.
+ *
+ * The algorithm:
+ * 1. Collect all copper geometries for the layer (traces, pads, vias, plated holes)
+ * 2. Union all copper geometries into a single CrossSection (the "inside")
+ * 3. Offset (expand) the unified copper outward by copperCutFillMargin (the "outer boundary")
+ * 4. Subtract the inside (original copper) from the outer boundary (expanded copper)
+ * 5. The result is the ring/band area around copper that needs to be lasered to remove more copper
+ *
+ * This creates a laser cut path that removes copper around traces and pads but never
+ * cuts into the traces or pads themselves.
+ */
+export const createCopperCutFillForLayer = async ({
+  layer,
+  ctx,
+}: {
+  layer: "top" | "bottom"
+  ctx: ConvertContext
+}): Promise<void> => {
+  const {
+    project,
+    connMap,
+    topCutNetGeoms,
+    bottomCutNetGeoms,
+    topCopperCutFillCutSetting,
+    bottomCopperCutFillCutSetting,
+    copperCutFillMargin,
+  } = ctx
+
+  // Get the appropriate cut setting for this layer
+  const cutSetting =
+    layer === "top" ? topCopperCutFillCutSetting : bottomCopperCutFillCutSetting
+
+  if (!cutSetting) {
+    return
+  }
+
+  // Get the appropriate geometry map
+  const netGeomMap = layer === "top" ? topCutNetGeoms : bottomCutNetGeoms
+
+  // Collect all geometries for this layer across all nets
+  const allGeoms: Array<Polygon | Box> = []
+  for (const net of Object.keys(connMap.netMap)) {
+    const netGeoms = netGeomMap.get(net)
+    if (netGeoms && netGeoms.length > 0) {
+      allGeoms.push(...netGeoms)
+    }
+  }
+
+  if (allGeoms.length === 0) {
+    return
+  }
+
+  try {
+    // Initialize manifold
+    const manifold = await getManifold()
+    const { CrossSection } = manifold
+
+    // Collect all contours from all geometries
+    const allContours: Contour[] = []
+    for (const geom of allGeoms) {
+      const contours = polygonToContours(geom)
+      allContours.push(...contours)
+    }
+
+    if (allContours.length === 0) {
+      return
+    }
+
+    // Create a unified CrossSection from all copper contours (the "inside")
+    // The constructor performs a boolean union with Positive fill rule
+    const copperInside = new CrossSection(allContours, "Positive")
+
+    // Offset (expand) the copper outward by the margin to get the "outer boundary"
+    // Positive delta expands outward
+    const outerBoundary = copperInside.offset(
+      copperCutFillMargin,
+      "Round", // joinType for smooth corners
+      2.0, // miterLimit
+      32, // circularSegments for round corners
+    )
+
+    // Subtract the inside (original copper) from the outer boundary (expanded copper)
+    // This gives us the ring/band area to laser cut
+    const cutFillArea = outerBoundary.subtract(copperInside)
+
+    // Simplify to clean up any spurious tiny segments
+    const simplifiedArea = cutFillArea.simplify(0.001)
+
+    // Get the resulting contours
+    const resultContours: Contour[] = simplifiedArea.toPolygons()
+
+    if (resultContours.length === 0) {
+      // Clean up WASM memory
+      copperInside.delete()
+      outerBoundary.delete()
+      cutFillArea.delete()
+      simplifiedArea.delete()
+      return
+    }
+
+    // Create a ShapeGroup to hold all contours
+    // LightBurn uses nonzero winding rule: CCW (positive area) = outer boundary, CW (negative area) = hole
+    // By grouping all contours together, LightBurn should properly fill only the ring area
+    const shapeGroup = new ShapeGroup()
+
+    // Convert all contours to ShapePaths and add to the group
+    // Preserve winding order: positive area (CCW) = outer boundary, negative area (CW) = hole
+    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: cutSetting.index,
+              verts,
+              prims,
+              isClosed: true, // Filled shapes should be closed
+            }),
+          )
+        }
+      }
+    }
+
+    // Add the group to the project if it has shapes
+    if (shapeGroup.children.length > 0) {
+      project.children.push(shapeGroup)
+    }
+
+    // Clean up WASM memory
+    copperInside.delete()
+    outerBoundary.delete()
+    cutFillArea.delete()
+    simplifiedArea.delete()
+  } catch (error) {
+    console.warn(`Failed to create copper cut fill for ${layer} layer:`, error)
+  }
+}

package/lib/element-handlers/addPcbTrace/index.ts

@@ -27,6 +27,14 @@ const createCirclePolygon = (
   return new Flatten.Polygon(points)
 }
 
+/**
+ * Creates a position key for deduplication.
+ * Rounds to 6 decimal places to handle floating point precision.
+ */
+const positionKey = (x: number, y: number): string => {
+  return `${x.toFixed(6)},${y.toFixed(6)}`
+}
+
 export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
   const {
     topCutNetGeoms,
@@ -38,6 +46,8 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
     includeCopper,
     includeLayers,
     traceMargin,
+    topTraceEndpoints,
+    bottomTraceEndpoints,
   } = ctx
 
   // Only include traces when including copper
@@ -95,7 +105,10 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
     // Add circular pads at trace endpoints to ensure overlap at junctions
     // This is crucial for boolean union to properly merge traces that share endpoints
     // Use a slightly larger radius (1.1x) to ensure proper overlap despite floating point issues
+    // Deduplicate endpoints to avoid identical polygons that cause boolean operation failures
     const segments = layerSegments.get(layer)
+    const endpointSet =
+      layer === "top" ? topTraceEndpoints : bottomTraceEndpoints
     if (segments) {
       for (const segment of segments) {
         if (segment.length >= 2) {
@@ -103,19 +116,28 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
           const lastPoint = segment[segment.length - 1]!
           const radius = (traceWidth / 2) * 1.1 // Slightly larger for reliable overlap
 
-          // Add circle at start point (translated by origin)
-          const startCircle = createCirclePolygon(
-            { x: firstPoint.x + origin.x, y: firstPoint.y + origin.y },
-            radius,
-          )
-          cutNetGeoms.get(netId)?.push(startCircle)
-
-          // Add circle at end point (translated by origin)
-          const endCircle = createCirclePolygon(
-            { x: lastPoint.x + origin.x, y: lastPoint.y + origin.y },
-            radius,
-          )
-          cutNetGeoms.get(netId)?.push(endCircle)
+          // Add circle at start point (translated by origin) if not already added
+          const startX = firstPoint.x + origin.x
+          const startY = firstPoint.y + origin.y
+          const startKey = positionKey(startX, startY)
+          if (!endpointSet.has(startKey)) {
+            endpointSet.add(startKey)
+            const startCircle = createCirclePolygon(
+              { x: startX, y: startY },
+              radius,
+            )
+            cutNetGeoms.get(netId)?.push(startCircle)
+          }
+
+          // Add circle at end point (translated by origin) if not already added
+          const endX = lastPoint.x + origin.x
+          const endY = lastPoint.y + origin.y
+          const endKey = positionKey(endX, endY)
+          if (!endpointSet.has(endKey)) {
+            endpointSet.add(endKey)
+            const endCircle = createCirclePolygon({ x: endX, y: endY }, radius)
+            cutNetGeoms.get(netId)?.push(endCircle)
+          }
         }
       }
     }