circuit-to-canvas 0.0.49 → 0.0.51

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

@@ -5,13 +5,6 @@ import { drawCircle } from "../shapes/circle"
 import { drawRect } from "../shapes/rect"
 import { drawPill } from "../shapes/pill"
 import { drawPolygon } from "../shapes/polygon"
-import {
-  drawSoldermaskRingForRect,
-  drawSoldermaskRingForCircle,
-  drawSoldermaskRingForPill,
-  drawSoldermaskRingForPolygon,
-  offsetPolygonPoints,
-} from "./soldermask-margin"
 
 export interface DrawPcbSmtPadParams {
   ctx: CanvasContext
@@ -27,53 +20,20 @@ function layerToColor(layer: string, colorMap: PcbColorMap): string {
   )
 }
 
-function getSoldermaskColor(layer: string, colorMap: PcbColorMap): string {
-  return (
-    colorMap.soldermaskOverCopper[
-      layer as keyof typeof colorMap.soldermaskOverCopper
-    ] ?? colorMap.soldermaskOverCopper.top
-  )
-}
-
-function getBorderRadius(pad: PcbSmtPad, margin = 0): number {
-  return (
-    ((pad as { corner_radius?: number }).corner_radius ??
-      (pad as { rect_border_radius?: number }).rect_border_radius ??
-      0) + margin
-  )
+function getBorderRadius(pad: PcbSmtPad): number {
+  if (pad.shape === "rect" || pad.shape === "rotated_rect") {
+    return pad.corner_radius ?? pad.rect_border_radius ?? 0
+  }
+  return 0
 }
 
 export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
   const { ctx, pad, realToCanvasMat, colorMap } = params
 
   const color = layerToColor(pad.layer, colorMap)
-  const isCoveredWithSoldermask = pad.is_covered_with_solder_mask === true
-  // If covered with soldermask, fully covered with no margin; otherwise use soldermask_margin if set
-  const margin = isCoveredWithSoldermask ? 0 : (pad.soldermask_margin ?? 0)
-  const hasSoldermask =
-    !isCoveredWithSoldermask &&
-    pad.soldermask_margin !== undefined &&
-    pad.soldermask_margin !== 0
-  const soldermaskRingColor = getSoldermaskColor(pad.layer, colorMap)
-  const positiveMarginColor = colorMap.substrate
-  const soldermaskOverlayColor = getSoldermaskColor(pad.layer, colorMap)
 
   // Draw the copper pad
   if (pad.shape === "rect") {
-    // For positive margins, draw extended mask area first
-    if (hasSoldermask && margin > 0) {
-      drawRect({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
-        fill: positiveMarginColor,
-        realToCanvasMat,
-        borderRadius: getBorderRadius(pad),
-      })
-    }
-
-    // Draw the pad on top
     drawRect({
       ctx,
       center: { x: pad.x, y: pad.y },
@@ -83,54 +43,10 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
       realToCanvasMat,
       borderRadius: getBorderRadius(pad),
     })
-
-    // For negative margins, draw soldermask ring on top of the pad
-    if (hasSoldermask && margin < 0) {
-      drawSoldermaskRingForRect(
-        ctx,
-        { x: pad.x, y: pad.y },
-        pad.width,
-        pad.height,
-        margin,
-        getBorderRadius(pad),
-        0,
-        realToCanvasMat,
-        soldermaskRingColor,
-        color,
-      )
-    }
-
-    // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-    if (isCoveredWithSoldermask && margin === 0) {
-      drawRect({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width,
-        height: pad.height,
-        fill: soldermaskOverlayColor,
-        realToCanvasMat,
-        borderRadius: getBorderRadius(pad),
-      })
-    }
     return
   }
 
   if (pad.shape === "rotated_rect") {
-    // For positive margins, draw extended mask area first
-    if (hasSoldermask && margin > 0) {
-      drawRect({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
-        fill: positiveMarginColor,
-        realToCanvasMat,
-        borderRadius: getBorderRadius(pad),
-        rotation: pad.ccw_rotation ?? 0,
-      })
-    }
-
-    // Draw the pad on top
     drawRect({
       ctx,
       center: { x: pad.x, y: pad.y },
@@ -141,52 +57,10 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
       borderRadius: getBorderRadius(pad),
       rotation: pad.ccw_rotation ?? 0,
     })
-
-    // For negative margins, draw soldermask ring on top of the pad
-    if (hasSoldermask && margin < 0) {
-      drawSoldermaskRingForRect(
-        ctx,
-        { x: pad.x, y: pad.y },
-        pad.width,
-        pad.height,
-        margin,
-        getBorderRadius(pad),
-        pad.ccw_rotation ?? 0,
-        realToCanvasMat,
-        soldermaskRingColor,
-        color,
-      )
-    }
-
-    // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-    if (isCoveredWithSoldermask && margin === 0) {
-      drawRect({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width,
-        height: pad.height,
-        fill: soldermaskOverlayColor,
-        realToCanvasMat,
-        borderRadius: getBorderRadius(pad),
-        rotation: pad.ccw_rotation ?? 0,
-      })
-    }
     return
   }
 
   if (pad.shape === "circle") {
-    // For positive margins, draw extended mask area first
-    if (hasSoldermask && margin > 0) {
-      drawCircle({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        radius: pad.radius + margin,
-        fill: positiveMarginColor,
-        realToCanvasMat,
-      })
-    }
-
-    // Draw the pad on top
     drawCircle({
       ctx,
       center: { x: pad.x, y: pad.y },
@@ -194,47 +68,10 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
       fill: color,
       realToCanvasMat,
     })
-
-    // For negative margins, draw soldermask ring on top of the pad
-    if (hasSoldermask && margin < 0) {
-      drawSoldermaskRingForCircle(
-        ctx,
-        { x: pad.x, y: pad.y },
-        pad.radius,
-        margin,
-        realToCanvasMat,
-        soldermaskRingColor,
-        color,
-      )
-    }
-
-    // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-    if (isCoveredWithSoldermask && margin === 0) {
-      drawCircle({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        radius: pad.radius,
-        fill: soldermaskOverlayColor,
-        realToCanvasMat,
-      })
-    }
     return
   }
 
   if (pad.shape === "pill") {
-    // For positive margins, draw extended mask area first
-    if (hasSoldermask && margin > 0) {
-      drawPill({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
-        fill: positiveMarginColor,
-        realToCanvasMat,
-      })
-    }
-
-    // Draw the pad on top
     drawPill({
       ctx,
       center: { x: pad.x, y: pad.y },
@@ -243,51 +80,10 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
       fill: color,
       realToCanvasMat,
     })
-
-    // For negative margins, draw soldermask ring on top of the pad
-    if (hasSoldermask && margin < 0) {
-      drawSoldermaskRingForPill(
-        ctx,
-        { x: pad.x, y: pad.y },
-        pad.width,
-        pad.height,
-        margin,
-        0,
-        realToCanvasMat,
-        soldermaskRingColor,
-        color,
-      )
-    }
-
-    // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-    if (isCoveredWithSoldermask && margin === 0) {
-      drawPill({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width,
-        height: pad.height,
-        fill: soldermaskOverlayColor,
-        realToCanvasMat,
-      })
-    }
     return
   }
 
   if (pad.shape === "rotated_pill") {
-    // For positive margins, draw extended mask area first
-    if (hasSoldermask && margin > 0) {
-      drawPill({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
-        fill: positiveMarginColor,
-        realToCanvasMat,
-        rotation: pad.ccw_rotation ?? 0,
-      })
-    }
-
-    // Draw the pad on top
     drawPill({
       ctx,
       center: { x: pad.x, y: pad.y },
@@ -297,79 +93,17 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
       realToCanvasMat,
       rotation: pad.ccw_rotation ?? 0,
     })
-
-    // For negative margins, draw soldermask ring on top of the pad
-    if (hasSoldermask && margin < 0) {
-      drawSoldermaskRingForPill(
-        ctx,
-        { x: pad.x, y: pad.y },
-        pad.width,
-        pad.height,
-        margin,
-        pad.ccw_rotation ?? 0,
-        realToCanvasMat,
-        soldermaskRingColor,
-        color,
-      )
-    }
-
-    // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-    if (isCoveredWithSoldermask && margin === 0) {
-      drawPill({
-        ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width,
-        height: pad.height,
-        fill: soldermaskOverlayColor,
-        realToCanvasMat,
-        rotation: pad.ccw_rotation ?? 0,
-      })
-    }
     return
   }
 
   if (pad.shape === "polygon") {
     if (pad.points && pad.points.length >= 3) {
-      // For positive margins, draw extended mask area first
-      if (hasSoldermask && margin > 0) {
-        const expandedPoints = offsetPolygonPoints(pad.points, margin)
-        drawPolygon({
-          ctx,
-          points: expandedPoints,
-          fill: positiveMarginColor,
-          realToCanvasMat,
-        })
-      }
-
-      // Draw the copper pad
       drawPolygon({
         ctx,
         points: pad.points,
         fill: color,
         realToCanvasMat,
       })
-
-      // For negative margins, draw soldermask ring on top of the pad
-      if (hasSoldermask && margin < 0) {
-        drawSoldermaskRingForPolygon(
-          ctx,
-          pad.points,
-          margin,
-          realToCanvasMat,
-          soldermaskRingColor,
-          color,
-        )
-      }
-
-      // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-      if (isCoveredWithSoldermask && margin === 0) {
-        drawPolygon({
-          ctx,
-          points: pad.points,
-          fill: soldermaskOverlayColor,
-          realToCanvasMat,
-        })
-      }
     }
     return
   }

package/lib/drawer/elements/pcb-soldermask/board.ts

@@ -0,0 +1,44 @@
+import type { PcbBoard } from "circuit-json"
+import type { Matrix } from "transformation-matrix"
+import { applyToPoint } from "transformation-matrix"
+import type { CanvasContext } from "../../types"
+import { drawPolygonPath } from "../helper-functions/draw-polygon"
+
+/**
+ * Draws the base soldermask layer covering the entire board.
+ */
+export function drawBoardSoldermask(params: {
+  ctx: CanvasContext
+  board: PcbBoard
+  realToCanvasMat: Matrix
+  soldermaskColor: string
+}): void {
+  const { ctx, board, realToCanvasMat, soldermaskColor } = params
+  const { width, height, center, outline } = board
+
+  if (outline && Array.isArray(outline) && outline.length >= 3) {
+    // Draw filled polygon for custom outline
+    const canvasPoints = outline.map((p) => {
+      const [x, y] = applyToPoint(realToCanvasMat, [p.x, p.y])
+      return { x, y }
+    })
+
+    ctx.beginPath()
+    drawPolygonPath({ ctx, points: canvasPoints })
+    ctx.fillStyle = soldermaskColor
+    ctx.fill()
+  } else if (width !== undefined && height !== undefined && center) {
+    // Draw filled rectangle
+    const [cx, cy] = applyToPoint(realToCanvasMat, [center.x, center.y])
+    const scaledWidth = width * Math.abs(realToCanvasMat.a)
+    const scaledHeight = height * Math.abs(realToCanvasMat.a)
+
+    ctx.fillStyle = soldermaskColor
+    ctx.fillRect(
+      cx - scaledWidth / 2,
+      cy - scaledHeight / 2,
+      scaledWidth,
+      scaledHeight,
+    )
+  }
+}

package/lib/drawer/elements/pcb-soldermask/cutout.ts

@@ -0,0 +1,74 @@
+import type { PcbCutout } from "circuit-json"
+import type { Matrix } from "transformation-matrix"
+import { applyToPoint } from "transformation-matrix"
+import type { CanvasContext, PcbColorMap } from "../../types"
+import { drawPolygonPath } from "../helper-functions/draw-polygon"
+import { drawRoundedRectPath } from "../helper-functions/draw-rounded-rect"
+/**
+ * Process soldermask for a board cutout.
+ * Cutouts go through the entire board, so they cut through soldermask too.
+ */
+export function processCutoutSoldermask(params: {
+  ctx: CanvasContext
+  cutout: PcbCutout
+  realToCanvasMat: Matrix
+  colorMap: PcbColorMap
+}): void {
+  const { ctx, cutout, realToCanvasMat, colorMap } = params
+  // Cutouts go through the entire board, so they cut through soldermask too
+  // Use drill color to indicate the cutout
+  ctx.fillStyle = colorMap.drill
+
+  if (cutout.shape === "rect") {
+    const [cx, cy] = applyToPoint(realToCanvasMat, [
+      cutout.center?.x ?? 0,
+      cutout.center?.y ?? 0,
+    ])
+    const scaledWidth = cutout.width * Math.abs(realToCanvasMat.a)
+    const scaledHeight = cutout.height * Math.abs(realToCanvasMat.a)
+    const scaledRadius =
+      (cutout.corner_radius ?? 0) * Math.abs(realToCanvasMat.a)
+
+    ctx.save()
+    ctx.translate(cx, cy)
+    if (cutout.rotation) {
+      ctx.rotate((-cutout.rotation * Math.PI) / 180)
+    }
+
+    ctx.beginPath()
+    drawRoundedRectPath({
+      ctx,
+      cx: 0,
+      cy: 0,
+      width: scaledWidth,
+      height: scaledHeight,
+      radius: scaledRadius,
+    })
+    ctx.restore()
+    ctx.fill()
+  } else if (cutout.shape === "circle") {
+    const [cx, cy] = applyToPoint(realToCanvasMat, [
+      cutout.center?.x ?? 0,
+      cutout.center?.y ?? 0,
+    ])
+    const scaledRadius = cutout.radius * Math.abs(realToCanvasMat.a)
+
+    ctx.beginPath()
+    ctx.arc(cx, cy, scaledRadius, 0, Math.PI * 2)
+    ctx.closePath()
+    ctx.fill()
+  } else if (
+    cutout.shape === "polygon" &&
+    cutout.points &&
+    cutout.points.length >= 3
+  ) {
+    const canvasPoints = cutout.points.map((p) => {
+      const [x, y] = applyToPoint(realToCanvasMat, [p.x, p.y])
+      return { x, y }
+    })
+
+    ctx.beginPath()
+    drawPolygonPath({ ctx, points: canvasPoints })
+    ctx.fill()
+  }
+}