circuit-to-canvas 0.0.110 → 0.0.111

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AnyCircuitElement, PcbRenderLayer, NinePointAnchor, PcbPlatedHole, PCBVia, PcbHole, PcbSmtPad, PcbVia, PcbTrace, PcbBoard, PcbPanel, PcbSilkscreenText, PcbSilkscreenRect, PcbSilkscreenCircle, PcbSilkscreenLine, PcbSilkscreenPath, PcbSilkscreenPill, PcbSilkscreenOval, PcbCutout, PCBKeepout, PcbCopperPour, PcbCopperText, PcbFabricationNoteText, PcbFabricationNoteRect, PcbNoteRect, PcbFabricationNotePath, PcbNotePath, PcbNoteText, PcbNoteDimension, PcbFabricationNoteDimension, PcbCourtyardCircle } from 'circuit-json';
+import { AnyCircuitElement, PcbRenderLayer, NinePointAnchor, PcbPlatedHole, PCBVia, PcbHole, PcbSmtPad, PcbVia, PcbCutout, PcbTrace, PcbBoard, PcbPanel, PcbSilkscreenText, PcbSilkscreenRect, PcbSilkscreenCircle, PcbSilkscreenLine, PcbSilkscreenPath, PcbSilkscreenPill, PcbSilkscreenOval, PCBKeepout, PcbCopperPour, PcbCopperText, PcbFabricationNoteText, PcbFabricationNoteRect, PcbNoteRect, PcbFabricationNotePath, PcbNotePath, PcbNoteText, PcbNoteDimension, PcbFabricationNoteDimension, PcbCourtyardCircle } from 'circuit-json';
 import { Matrix } from 'transformation-matrix';
 
 /**
@@ -364,6 +364,7 @@ interface DrawPcbSmtPadParams {
     holes?: PcbHole[];
     platedHoles?: PcbPlatedHole[];
     vias?: PcbVia[];
+    cutouts?: PcbCutout[];
 }
 declare function drawPcbSmtPad(params: DrawPcbSmtPadParams): void;
 

package/dist/index.js

@@ -1637,22 +1637,24 @@ function drawPadWithDrillCutouts(params) {
   ctx.restore();
 }
 function getPadDrillCutouts(params) {
-  const { pad, holes = [], platedHoles = [], vias = [] } = params;
+  const { pad, holes = [], platedHoles = [], vias = [], cutouts = [] } = params;
   const padBounds = getPadBounds(pad);
   if (!padBounds) return [];
-  const cutouts = [];
-  for (const hole of holes) {
-    const cutout = getHoleDrillCutout(hole);
+  const drillCutouts = [];
+  const addIfOverlapping = (cutout) => {
     if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout);
+      drillCutouts.push(cutout);
     }
+  };
+  for (const cutout of cutouts) {
+    addIfOverlapping(getBoardCutout(cutout));
+  }
+  for (const hole of holes) {
+    addIfOverlapping(getHoleDrillCutout(hole));
   }
   for (const platedHole of platedHoles) {
     if (!layersIncludePadLayer(platedHole.layers, pad.layer)) continue;
-    const cutout = getPlatedHoleDrillCutout(platedHole);
-    if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout);
-    }
+    addIfOverlapping(getPlatedHoleDrillCutout(platedHole));
   }
   for (const via of vias) {
     if (!layersIncludePadLayer(via.layers, pad.layer)) continue;
@@ -1664,11 +1666,9 @@ function getPadDrillCutouts(params) {
       y: via.y,
       radius
     };
-    if (boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout);
-    }
+    addIfOverlapping(cutout);
   }
-  return cutouts;
+  return drillCutouts;
 }
 function appendPadPath(ctx, pad, realToCanvasMat) {
   if (pad.shape === "rect" || pad.shape === "rotated_rect") {
@@ -1741,11 +1741,16 @@ function appendDrillCutoutPath(ctx, drillCutout, realToCanvasMat) {
     });
     return;
   }
+  if (drillCutout.shape === "polygon") {
+    appendPolygonPath(ctx, drillCutout.points, realToCanvasMat);
+    return;
+  }
   appendRectPath(ctx, {
     x: drillCutout.x,
     y: drillCutout.y,
     width: drillCutout.width,
     height: drillCutout.height,
+    radius: drillCutout.radius,
     rotation: drillCutout.rotation,
     realToCanvasMat
   });
@@ -1883,6 +1888,9 @@ function getPadBounds(pad) {
   }
 }
 function getDrillCutoutBounds(cutout) {
+  if (cutout.shape === "polygon") {
+    return getPointBounds(cutout.points);
+  }
   if (cutout.shape === "circle") {
     return boundsAroundCenter(cutout.x, cutout.y, cutout.radius, cutout.radius);
   }
@@ -1906,6 +1914,32 @@ function getDrillCutoutBounds(cutout) {
   }
   return boundsAroundCenter(cutout.x, cutout.y, halfWidth, halfHeight);
 }
+function getBoardCutout(cutout) {
+  if (cutout.shape === "circle") {
+    if (cutout.radius <= 0) return;
+    return {
+      shape: "circle",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      radius: cutout.radius
+    };
+  }
+  if (cutout.shape === "rect") {
+    if (cutout.width <= 0 || cutout.height <= 0) return;
+    return {
+      shape: "rect",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      width: cutout.width,
+      height: cutout.height,
+      radius: cutout.corner_radius,
+      rotation: cutout.rotation
+    };
+  }
+  if (cutout.shape === "polygon" && cutout.points.length >= 3) {
+    return { shape: "polygon", points: cutout.points };
+  }
+}
 function getPointBounds(points) {
   let minX = Infinity;
   let maxX = -Infinity;
@@ -5318,6 +5352,9 @@ var CircuitToCanvasDrawer = class {
     const drawablePlatedHoles = elements.filter(
       (el) => shouldDrawElement(el, options) && el.type === "pcb_plated_hole"
     );
+    const drawableCutouts = elements.filter(
+      (el) => shouldDrawElement(el, options) && el.type === "pcb_cutout"
+    );
     if (board) {
       drawPcbBoard({
         ctx: this.ctx,
@@ -5349,7 +5386,8 @@ var CircuitToCanvasDrawer = class {
           colorMap: this.colorMap,
           holes: drawableHoles,
           platedHoles: drawablePlatedHoles,
-          vias: drawableVias
+          vias: drawableVias,
+          cutouts: drawableCutouts
         });
       }
       if (element.type === "pcb_copper_text") {

package/lib/drawer/CircuitToCanvasDrawer.ts

@@ -243,6 +243,10 @@ export class CircuitToCanvasDrawer {
       (el): el is PcbPlatedHole =>
         shouldDrawElement(el, options) && el.type === "pcb_plated_hole",
     )
+    const drawableCutouts = elements.filter(
+      (el): el is PcbCutout =>
+        shouldDrawElement(el, options) && el.type === "pcb_cutout",
+    )
 
     // Step 2: Draw board outline/material (inner board)
     if (board) {
@@ -283,6 +287,7 @@ export class CircuitToCanvasDrawer {
           holes: drawableHoles,
           platedHoles: drawablePlatedHoles,
           vias: drawableVias,
+          cutouts: drawableCutouts,
         })
       }
 

package/lib/drawer/elements/helper-functions/pcb-smtpad-drill-cutouts.ts

@@ -1,4 +1,10 @@
-import type { PcbHole, PcbPlatedHole, PcbSmtPad, PcbVia } from "circuit-json"
+import type {
+  PcbCutout,
+  PcbHole,
+  PcbPlatedHole,
+  PcbSmtPad,
+  PcbVia,
+} from "circuit-json"
 import type { Matrix } from "transformation-matrix"
 import { applyToPoint } from "transformation-matrix"
 import type { CanvasContext } from "../../types"
@@ -34,14 +40,21 @@ interface DrillCutoutRect {
   y: number
   width: number
   height: number
+  radius?: number
   rotation?: number
 }
 
+interface DrillCutoutPolygon {
+  shape: "polygon"
+  points: Array<{ x: number; y: number }>
+}
+
 type DrillCutout =
   | DrillCutoutCircle
   | DrillCutoutOval
   | DrillCutoutPill
   | DrillCutoutRect
+  | DrillCutoutPolygon
 
 interface Bounds {
   minX: number
@@ -55,6 +68,7 @@ export interface PcbSmtPadDrillCutoutParams {
   holes?: PcbHole[]
   platedHoles?: PcbPlatedHole[]
   vias?: PcbVia[]
+  cutouts?: PcbCutout[]
 }
 
 export function drawPadWithDrillCutouts(params: {
@@ -87,26 +101,28 @@ export function drawPadWithDrillCutouts(params: {
 export function getPadDrillCutouts(
   params: PcbSmtPadDrillCutoutParams,
 ): DrillCutout[] {
-  const { pad, holes = [], platedHoles = [], vias = [] } = params
+  const { pad, holes = [], platedHoles = [], vias = [], cutouts = [] } = params
   const padBounds = getPadBounds(pad)
   if (!padBounds) return []
 
-  const cutouts: DrillCutout[] = []
-
-  for (const hole of holes) {
-    const cutout = getHoleDrillCutout(hole)
+  const drillCutouts: DrillCutout[] = []
+  const addIfOverlapping = (cutout: DrillCutout | undefined): void => {
     if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout)
+      drillCutouts.push(cutout)
     }
   }
 
+  for (const cutout of cutouts) {
+    addIfOverlapping(getBoardCutout(cutout))
+  }
+
+  for (const hole of holes) {
+    addIfOverlapping(getHoleDrillCutout(hole))
+  }
+
   for (const platedHole of platedHoles) {
     if (!layersIncludePadLayer(platedHole.layers, pad.layer)) continue
-
-    const cutout = getPlatedHoleDrillCutout(platedHole)
-    if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout)
-    }
+    addIfOverlapping(getPlatedHoleDrillCutout(platedHole))
   }
 
   for (const via of vias) {
@@ -120,12 +136,10 @@ export function getPadDrillCutouts(
       y: via.y,
       radius,
     }
-    if (boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout)
-    }
+    addIfOverlapping(cutout)
   }
 
-  return cutouts
+  return drillCutouts
 }
 
 function appendPadPath(
@@ -215,11 +229,17 @@ function appendDrillCutoutPath(
     return
   }
 
+  if (drillCutout.shape === "polygon") {
+    appendPolygonPath(ctx, drillCutout.points, realToCanvasMat)
+    return
+  }
+
   appendRectPath(ctx, {
     x: drillCutout.x,
     y: drillCutout.y,
     width: drillCutout.width,
     height: drillCutout.height,
+    radius: drillCutout.radius,
     rotation: drillCutout.rotation,
     realToCanvasMat,
   })
@@ -429,6 +449,10 @@ function getPadBounds(pad: PcbSmtPad): Bounds | undefined {
 }
 
 function getDrillCutoutBounds(cutout: DrillCutout): Bounds {
+  if (cutout.shape === "polygon") {
+    return getPointBounds(cutout.points)
+  }
+
   if (cutout.shape === "circle") {
     return boundsAroundCenter(cutout.x, cutout.y, cutout.radius, cutout.radius)
   }
@@ -455,6 +479,35 @@ function getDrillCutoutBounds(cutout: DrillCutout): Bounds {
   return boundsAroundCenter(cutout.x, cutout.y, halfWidth, halfHeight)
 }
 
+function getBoardCutout(cutout: PcbCutout): DrillCutout | undefined {
+  if (cutout.shape === "circle") {
+    if (cutout.radius <= 0) return
+    return {
+      shape: "circle",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      radius: cutout.radius,
+    }
+  }
+
+  if (cutout.shape === "rect") {
+    if (cutout.width <= 0 || cutout.height <= 0) return
+    return {
+      shape: "rect",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      width: cutout.width,
+      height: cutout.height,
+      radius: cutout.corner_radius,
+      rotation: cutout.rotation,
+    }
+  }
+
+  if (cutout.shape === "polygon" && cutout.points.length >= 3) {
+    return { shape: "polygon", points: cutout.points }
+  }
+}
+
 function getPointBounds(points: Array<{ x: number; y: number }>): Bounds {
   let minX = Infinity
   let maxX = -Infinity

package/lib/drawer/elements/pcb-smtpad.ts

@@ -1,10 +1,16 @@
-import type { PcbHole, PcbPlatedHole, PcbSmtPad, PcbVia } from "circuit-json"
+import type {
+  PcbCutout,
+  PcbHole,
+  PcbPlatedHole,
+  PcbSmtPad,
+  PcbVia,
+} from "circuit-json"
 import type { Matrix } from "transformation-matrix"
-import type { PcbColorMap, CanvasContext } from "../types"
 import { drawCircle } from "../shapes/circle"
-import { drawRect } from "../shapes/rect"
 import { drawPill } from "../shapes/pill"
 import { drawPolygon } from "../shapes/polygon"
+import { drawRect } from "../shapes/rect"
+import type { CanvasContext, PcbColorMap } from "../types"
 import {
   drawPadWithDrillCutouts,
   getPadDrillCutouts,
@@ -18,6 +24,7 @@ export interface DrawPcbSmtPadParams {
   holes?: PcbHole[]
   platedHoles?: PcbPlatedHole[]
   vias?: PcbVia[]
+  cutouts?: PcbCutout[]
 }
 
 function layerToColor(layer: string, colorMap: PcbColorMap): string {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-to-canvas",
   "main": "dist/index.js",
-  "version": "0.0.110",
+  "version": "0.0.111",
   "type": "module",
   "scripts": {
     "build": "tsup-node ./lib/index.ts --format esm --dts",

package/tests/elements/pcb-smtpad-cutout.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test"
+import { createCanvas } from "@napi-rs/canvas"
+import type { PcbCutout, PcbSmtPad } from "circuit-json"
+import { CircuitToCanvasDrawer } from "../../lib/drawer"
+
+test("cutout removes overlapping SMT pad copper", async () => {
+  const scale = 4
+  const canvas = createCanvas(100 * scale, 100 * scale)
+  const ctx = canvas.getContext("2d")
+  ctx.scale(scale, scale)
+  const drawer = new CircuitToCanvasDrawer(ctx)
+  drawer.configure({
+    colorOverrides: { drill: "rgba(0,0,0,0)" },
+  })
+
+  const pad: PcbSmtPad = {
+    type: "pcb_smtpad",
+    pcb_smtpad_id: "pad1",
+    shape: "rect",
+    layer: "top",
+    x: 50,
+    y: 50,
+    width: 40,
+    height: 20,
+  }
+  const cutout: PcbCutout = {
+    type: "pcb_cutout",
+    pcb_cutout_id: "cutout1",
+    shape: "circle",
+    center: { x: 50, y: 50 },
+    radius: 5,
+  }
+
+  drawer.drawElements([pad, cutout])
+
+  await expect(canvas.toBuffer("image/png")).toMatchPngSnapshot(
+    import.meta.path,
+  )
+})