circuit-json-to-lbrn 0.0.21 → 0.0.22

package/lib/ConvertContext.ts

@@ -9,19 +9,23 @@ export interface ConvertContext {
   db: CircuitJsonUtilObjects
   project: LightBurnProject
 
-  copperCutSetting: CutSetting
+  topCopperCutSetting: CutSetting
+  bottomCopperCutSetting: CutSetting
   throughBoardCutSetting: CutSetting
   soldermaskCutSetting: CutSetting
 
   connMap: ConnectivityMap
 
-  netGeoms: Map<ConnectivityMapKey, Array<Polygon | Box>>
+  // Separate net geometries for top and bottom layers
+  topNetGeoms: Map<ConnectivityMapKey, Array<Polygon | Box>>
+  bottomNetGeoms: Map<ConnectivityMapKey, Array<Polygon | Box>>
 
   origin: { x: number; y: number }
 
   // Include flags
   includeCopper: boolean
   includeSoldermask: boolean
+  includeLayers: Array<"top" | "bottom">
 
   // Soldermask margin (can be negative)
   soldermaskMargin: number

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

@@ -1,10 +1,17 @@
-import type { PcbTrace } from "circuit-json"
+import type { PcbTrace, PcbTraceRoutePoint } from "circuit-json"
 import type { ConvertContext } from "../../ConvertContext"
 import Flatten, { BooleanOperations } from "@flatten-js/core"
 import { circleToPolygon } from "./circle-to-polygon"
 
 export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
-  const { netGeoms, connMap, origin, includeCopper, includeSoldermask } = ctx
+  const {
+    topNetGeoms,
+    bottomNetGeoms,
+    connMap,
+    origin,
+    includeCopper,
+    includeLayers,
+  } = ctx
 
   // Only include traces when including copper
   // Traces are NOT included in soldermask-only mode to prevent accidental bridging
@@ -14,83 +21,160 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
 
   const netId = connMap.getNetConnectedToId(
     trace.source_trace_id ?? trace.pcb_trace_id,
-  )!
+  )
 
   if (!netId) {
-    console.warn(`Trace ${trace.pcb_trace_id} is not connected to any net`)
+    // Skip traces that are not connected to any net
+    // This can happen for traces without a source_trace_id
     return
   }
 
   if (!trace.route || trace.route.length < 2) {
-    console.warn(`Trace ${trace.pcb_trace_id} has insufficient route points`)
     return
   }
 
   const { route } = trace
+  const wirePoint = route.find((point) => {
+    if (!("route_type" in point)) return true
+    return point.route_type === "wire"
+  })
+  const traceWidth = (wirePoint as any)?.width ?? 0.15
+
+  // Group consecutive wire segments by layer
+  // When we hit a via, we start a new segment on the new layer
+  const layerSegments = new Map<
+    "top" | "bottom",
+    Array<Array<{ x: number; y: number }>>
+  >()
+
+  let currentSegment: Array<{ x: number; y: number }> = []
+  let currentLayer: "top" | "bottom" | null = null
+
+  for (const point of route) {
+    if ("route_type" in point && point.route_type === "via") {
+      // Via marks end of current segment - save it
+      if (currentLayer && currentSegment.length > 0) {
+        if (!layerSegments.has(currentLayer)) {
+          layerSegments.set(currentLayer, [])
+        }
+        layerSegments.get(currentLayer)!.push(currentSegment)
+      }
+      // Reset for next segment
+      currentSegment = []
+      currentLayer = null
+      continue
+    }
 
-  const traceWidth =
-    route.find((point) => point.route_type === "wire")?.width ?? 0.15
-
-  const polygons: Flatten.Polygon[] = []
-
-  // Add circles for each vertex
-  for (const routePoint of route) {
-    const circle = new Flatten.Circle(
-      new Flatten.Point(routePoint.x + origin.x, routePoint.y + origin.y),
-      traceWidth / 2,
-    )
-    polygons.push(circleToPolygon(circle))
+    // Treat points without route_type as wire points (default behavior)
+    const isWirePoint = !("route_type" in point) || point.route_type === "wire"
+    if (isWirePoint && "layer" in point && point.layer) {
+      const pointLayer = point.layer as "top" | "bottom" | string
+      if (pointLayer !== "top" && pointLayer !== "bottom") {
+        continue // Skip inner layers
+      }
+
+      // If layer changed (shouldn't happen without via, but handle it)
+      if (currentLayer !== null && currentLayer !== pointLayer) {
+        // Save current segment
+        if (currentSegment.length > 0) {
+          if (!layerSegments.has(currentLayer)) {
+            layerSegments.set(currentLayer, [])
+          }
+          layerSegments.get(currentLayer)!.push(currentSegment)
+        }
+        // Start new segment
+        currentSegment = []
+      }
+
+      currentLayer = pointLayer
+      currentSegment.push({ x: point.x, y: point.y })
+    }
   }
 
-  // Add rectangles for each segment
-  for (let i = 0; i < route.length - 1; i++) {
-    const p1 = route[i]
-    const p2 = route[i + 1]
-
-    if (!p1 || !p2) continue
-
-    const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y)
-    if (segmentLength === 0) continue
-
-    const centerX = (p1.x + p2.x) / 2 + origin.x
-    const centerY = (p1.y + p2.y) / 2 + origin.y
-    const rotationDeg = (Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180) / Math.PI
-
-    const w2 = segmentLength / 2
-    const h2 = traceWidth / 2
-
-    const angleRad = (rotationDeg * Math.PI) / 180
-    const cosAngle = Math.cos(angleRad)
-    const sinAngle = Math.sin(angleRad)
-
-    const corners = [
-      { x: -w2, y: -h2 },
-      { x: w2, y: -h2 },
-      { x: w2, y: h2 },
-      { x: -w2, y: h2 },
-    ]
+  // Save final segment
+  if (currentLayer && currentSegment.length > 0) {
+    if (!layerSegments.has(currentLayer)) {
+      layerSegments.set(currentLayer, [])
+    }
+    layerSegments.get(currentLayer)!.push(currentSegment)
+  }
 
-    const rotatedCorners = corners.map((p) => ({
-      x: centerX + p.x * cosAngle - p.y * sinAngle,
-      y: centerY + p.x * sinAngle + p.y * cosAngle,
-    }))
+  // Process each layer
+  for (const [layer, segments] of layerSegments.entries()) {
+    if (!includeLayers.includes(layer)) {
+      continue
+    }
 
-    polygons.push(
-      new Flatten.Polygon(rotatedCorners.map((p) => Flatten.point(p.x, p.y))),
-    )
-  }
+    // Combine all segments for this layer into one set of polygons
+    const polygons: Flatten.Polygon[] = []
+
+    for (const points of segments) {
+      if (points.length < 2) continue
+
+      // Add circles for each vertex in this segment
+      for (const routePoint of points) {
+        const circle = new Flatten.Circle(
+          new Flatten.Point(routePoint.x + origin.x, routePoint.y + origin.y),
+          traceWidth / 2,
+        )
+        polygons.push(circleToPolygon(circle))
+      }
+
+      // Add rectangles for each line segment
+      for (let i = 0; i < points.length - 1; i++) {
+        const p1 = points[i]
+        const p2 = points[i + 1]
+
+        if (!p1 || !p2) continue
+
+        const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y)
+        if (segmentLength === 0) continue
+
+        const centerX = (p1.x + p2.x) / 2 + origin.x
+        const centerY = (p1.y + p2.y) / 2 + origin.y
+        const rotationDeg =
+          (Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180) / Math.PI
+
+        const w2 = segmentLength / 2
+        const h2 = traceWidth / 2
+
+        const angleRad = (rotationDeg * Math.PI) / 180
+        const cosAngle = Math.cos(angleRad)
+        const sinAngle = Math.sin(angleRad)
+
+        const corners = [
+          { x: -w2, y: -h2 },
+          { x: w2, y: -h2 },
+          { x: w2, y: h2 },
+          { x: -w2, y: h2 },
+        ]
+
+        const rotatedCorners = corners.map((p) => ({
+          x: centerX + p.x * cosAngle - p.y * sinAngle,
+          y: centerY + p.x * sinAngle + p.y * cosAngle,
+        }))
+
+        polygons.push(
+          new Flatten.Polygon(
+            rotatedCorners.map((p) => Flatten.point(p.x, p.y)),
+          ),
+        )
+      }
+    }
 
-  // Union all polygons together to create the final trace polygon
-  if (polygons.length === 0) return
+    // Union all polygons together to create the final trace polygon for this layer
+    if (polygons.length === 0) continue
 
-  let tracePolygon = polygons[0]!
+    let tracePolygon = polygons[0]!
 
-  for (let i = 1; i < polygons.length; i++) {
-    const poly = polygons[i]
-    if (poly) {
-      tracePolygon = BooleanOperations.unify(tracePolygon, poly)
+    for (let i = 1; i < polygons.length; i++) {
+      const poly = polygons[i]
+      if (poly) {
+        tracePolygon = BooleanOperations.unify(tracePolygon, poly)
+      }
     }
-  }
 
-  netGeoms.get(netId)?.push(tracePolygon)
+    const netGeoms = layer === "top" ? topNetGeoms : bottomNetGeoms
+    netGeoms.get(netId)?.push(tracePolygon)
+  }
 }

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

@@ -9,19 +9,24 @@ export const addPcbVia = (via: PcbVia, ctx: ConvertContext): void => {
   const {
     db,
     project,
-    copperCutSetting,
+    topCopperCutSetting,
+    bottomCopperCutSetting,
     soldermaskCutSetting,
     throughBoardCutSetting,
+    topNetGeoms,
+    bottomNetGeoms,
     origin,
     includeCopper,
     includeSoldermask,
     connMap,
     soldermaskMargin,
+    includeLayers,
   } = ctx
   const centerX = via.x + origin.x
   const centerY = via.y + origin.y
 
   // Add outer circle (copper annulus) if drawing copper - add to netGeoms for merging
+  // Vias go through all layers, so add to both top and bottom
   if (via.outer_diameter > 0 && includeCopper) {
     // Find the pcb_port associated with this via (vias don't have pcb_port_id property)
     // We need to find a port at the same location as the via
@@ -38,23 +43,40 @@ export const addPcbVia = (via: PcbVia, ctx: ConvertContext): void => {
     const polygon = circleToPolygon(circle)
 
     if (netId) {
-      // Add to netGeoms to be merged with other elements on the same net
-      ctx.netGeoms.get(netId)?.push(polygon)
+      // Add to both top and bottom netGeoms since vias go through the board
+      if (includeLayers.includes("top")) {
+        topNetGeoms.get(netId)?.push(polygon.clone())
+      }
+      if (includeLayers.includes("bottom")) {
+        bottomNetGeoms.get(netId)?.push(polygon.clone())
+      }
     } else {
-      // No net connection - draw directly
+      // No net connection - draw directly for each included layer
       const outer = createCirclePath({
         centerX,
         centerY,
         radius: outerRadius,
       })
-      project.children.push(
-        new ShapePath({
-          cutIndex: copperCutSetting.index,
-          verts: outer.verts,
-          prims: outer.prims,
-          isClosed: true,
-        }),
-      )
+      if (includeLayers.includes("top")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: topCopperCutSetting.index,
+            verts: outer.verts,
+            prims: outer.prims,
+            isClosed: true,
+          }),
+        )
+      }
+      if (includeLayers.includes("bottom")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: bottomCopperCutSetting.index,
+            verts: outer.verts,
+            prims: outer.prims,
+            isClosed: true,
+          }),
+        )
+      }
     }
   }
 

package/lib/element-handlers/addPlatedHole/addCirclePlatedHole.ts

@@ -11,19 +11,24 @@ export const addCirclePlatedHole = (
 ): void => {
   const {
     project,
-    copperCutSetting,
+    topCopperCutSetting,
+    bottomCopperCutSetting,
     soldermaskCutSetting,
     throughBoardCutSetting,
+    topNetGeoms,
+    bottomNetGeoms,
     origin,
     includeCopper,
     includeSoldermask,
     connMap,
     soldermaskMargin,
+    includeLayers,
   } = ctx
   const centerX = platedHole.x + origin.x
   const centerY = platedHole.y + origin.y
 
   // Add outer circle (copper annulus) if drawing copper - add to netGeoms for merging
+  // Plated holes go through all layers, so add to both top and bottom
   if (platedHole.outer_diameter > 0 && includeCopper) {
     const netId = connMap.getNetConnectedToId(platedHole.pcb_plated_hole_id)
     const outerRadius = platedHole.outer_diameter / 2
@@ -31,23 +36,40 @@ export const addCirclePlatedHole = (
     const polygon = circleToPolygon(circle)
 
     if (netId) {
-      // Add to netGeoms to be merged with other elements on the same net
-      ctx.netGeoms.get(netId)?.push(polygon)
+      // Add to both top and bottom netGeoms since plated holes go through the board
+      if (includeLayers.includes("top")) {
+        topNetGeoms.get(netId)?.push(polygon.clone())
+      }
+      if (includeLayers.includes("bottom")) {
+        bottomNetGeoms.get(netId)?.push(polygon.clone())
+      }
     } else {
-      // No net connection - draw directly
+      // No net connection - draw directly for each included layer
       const outer = createCirclePath({
         centerX,
         centerY,
         radius: outerRadius,
       })
-      project.children.push(
-        new ShapePath({
-          cutIndex: copperCutSetting.index,
-          verts: outer.verts,
-          prims: outer.prims,
-          isClosed: true,
-        }),
-      )
+      if (includeLayers.includes("top")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: topCopperCutSetting.index,
+            verts: outer.verts,
+            prims: outer.prims,
+            isClosed: true,
+          }),
+        )
+      }
+      if (includeLayers.includes("bottom")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: bottomCopperCutSetting.index,
+            verts: outer.verts,
+            prims: outer.prims,
+            isClosed: true,
+          }),
+        )
+      }
     }
   }
 

package/lib/element-handlers/addPlatedHole/addCircularHoleWithRectPad.ts

@@ -10,13 +10,15 @@ export const addCircularHoleWithRectPad = (
 ): void => {
   const {
     project,
-    copperCutSetting,
+    topCopperCutSetting,
+    bottomCopperCutSetting,
     soldermaskCutSetting,
     throughBoardCutSetting,
     origin,
     includeCopper,
     includeSoldermask,
     soldermaskMargin,
+    includeLayers,
   } = ctx
   const centerX = platedHole.x + origin.x
   const centerY = platedHole.y + origin.y
@@ -35,15 +37,28 @@ export const addCircularHoleWithRectPad = (
   })
 
   // Add the rectangular pad if drawing copper
+  // Plated holes go through all layers, so add to both top and bottom
   if (includeCopper) {
-    project.children.push(
-      new ShapePath({
-        cutIndex: copperCutSetting.index,
-        verts: padPath.verts,
-        prims: padPath.prims,
-        isClosed: true,
-      }),
-    )
+    if (includeLayers.includes("top")) {
+      project.children.push(
+        new ShapePath({
+          cutIndex: topCopperCutSetting.index,
+          verts: padPath.verts,
+          prims: padPath.prims,
+          isClosed: true,
+        }),
+      )
+    }
+    if (includeLayers.includes("bottom")) {
+      project.children.push(
+        new ShapePath({
+          cutIndex: bottomCopperCutSetting.index,
+          verts: padPath.verts,
+          prims: padPath.prims,
+          isClosed: true,
+        }),
+      )
+    }
   }
 
   // Add soldermask opening if drawing soldermask

package/lib/element-handlers/addPlatedHole/addHoleWithPolygonPad.ts

@@ -10,13 +10,15 @@ export const addHoleWithPolygonPad = (
 ): void => {
   const {
     project,
-    copperCutSetting,
+    topCopperCutSetting,
+    bottomCopperCutSetting,
     soldermaskCutSetting,
     throughBoardCutSetting,
     origin,
     includeCopper,
     includeSoldermask,
     soldermaskMargin,
+    includeLayers,
   } = ctx
 
   // Create the polygon pad
@@ -28,15 +30,28 @@ export const addHoleWithPolygonPad = (
     })
 
     // Add the polygon pad if drawing copper
+    // Plated holes go through all layers, so add to both top and bottom
     if (includeCopper) {
-      project.children.push(
-        new ShapePath({
-          cutIndex: copperCutSetting.index,
-          verts: pad.verts,
-          prims: pad.prims,
-          isClosed: true,
-        }),
-      )
+      if (includeLayers.includes("top")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: topCopperCutSetting.index,
+            verts: pad.verts,
+            prims: pad.prims,
+            isClosed: true,
+          }),
+        )
+      }
+      if (includeLayers.includes("bottom")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: bottomCopperCutSetting.index,
+            verts: pad.verts,
+            prims: pad.prims,
+            isClosed: true,
+          }),
+        )
+      }
     }
 
     // Add soldermask opening if drawing soldermask

package/lib/element-handlers/addPlatedHole/addOvalPlatedHole.ts

@@ -9,13 +9,15 @@ export const addOvalPlatedHole = (
 ): void => {
   const {
     project,
-    copperCutSetting,
+    topCopperCutSetting,
+    bottomCopperCutSetting,
     soldermaskCutSetting,
     throughBoardCutSetting,
     origin,
     includeCopper,
     includeSoldermask,
     soldermaskMargin,
+    includeLayers,
   } = ctx
 
   if (platedHole.outer_width <= 0 || platedHole.outer_height <= 0) {
@@ -27,6 +29,7 @@ export const addOvalPlatedHole = (
   const rotation = (platedHole.ccw_rotation ?? 0) * (Math.PI / 180)
 
   // Add outer oval (copper) if drawing copper
+  // Plated holes go through all layers, so add to both top and bottom
   if (
     platedHole.outer_width > 0 &&
     platedHole.outer_height > 0 &&
@@ -39,14 +42,26 @@ export const addOvalPlatedHole = (
       height: platedHole.outer_height,
       rotation,
     })
-    project.children.push(
-      new ShapePath({
-        cutIndex: copperCutSetting.index,
-        verts: outer.verts,
-        prims: outer.prims,
-        isClosed: true,
-      }),
-    )
+    if (includeLayers.includes("top")) {
+      project.children.push(
+        new ShapePath({
+          cutIndex: topCopperCutSetting.index,
+          verts: outer.verts,
+          prims: outer.prims,
+          isClosed: true,
+        }),
+      )
+    }
+    if (includeLayers.includes("bottom")) {
+      project.children.push(
+        new ShapePath({
+          cutIndex: bottomCopperCutSetting.index,
+          verts: outer.verts,
+          prims: outer.prims,
+          isClosed: true,
+        }),
+      )
+    }
   }
 
   // Add soldermask opening if drawing soldermask

package/lib/element-handlers/addPlatedHole/addPillHoleWithRectPad.ts

@@ -10,13 +10,15 @@ export const addPillHoleWithRectPad = (
 ): void => {
   const {
     project,
-    copperCutSetting,
+    topCopperCutSetting,
+    bottomCopperCutSetting,
     soldermaskCutSetting,
     throughBoardCutSetting,
     origin,
     includeCopper,
     includeSoldermask,
     soldermaskMargin,
+    includeLayers,
   } = ctx
   const centerX = platedHole.x + origin.x
   const centerY = platedHole.y + origin.y
@@ -35,15 +37,28 @@ export const addPillHoleWithRectPad = (
     })
 
     // Add the rectangular pad if drawing copper
+    // Plated holes go through all layers, so add to both top and bottom
     if (includeCopper) {
-      project.children.push(
-        new ShapePath({
-          cutIndex: copperCutSetting.index,
-          verts: padPath.verts,
-          prims: padPath.prims,
-          isClosed: true,
-        }),
-      )
+      if (includeLayers.includes("top")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: topCopperCutSetting.index,
+            verts: padPath.verts,
+            prims: padPath.prims,
+            isClosed: true,
+          }),
+        )
+      }
+      if (includeLayers.includes("bottom")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: bottomCopperCutSetting.index,
+            verts: padPath.verts,
+            prims: padPath.prims,
+            isClosed: true,
+          }),
+        )
+      }
     }
 
     // Add soldermask opening if drawing soldermask