circuit-to-canvas 0.0.46 → 0.0.48

package/lib/drawer/elements/pcb-plated-hole.ts

@@ -11,6 +11,8 @@ import {
   drawSoldermaskRingForOval,
   drawSoldermaskRingForPill,
   drawSoldermaskRingForRect,
+  drawSoldermaskRingForPolygon,
+  offsetPolygonPoints,
 } from "./soldermask-margin"
 
 export interface DrawPcbPlatedHoleParams {
@@ -249,7 +251,7 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
       })
     }
 
@@ -318,7 +320,7 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
       })
     }
 
@@ -388,7 +390,7 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         height: hole.rect_pad_height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: (hole.rect_border_radius ?? 0) + margin,
+        borderRadius: hole.rect_border_radius ?? 0,
         rotation: hole.rect_ccw_rotation,
       })
     }
@@ -453,8 +455,6 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
   }
 
   if (hole.shape === "hole_with_polygon_pad") {
-    // Note: Polygon pads don't support soldermask margins (similar to SMT polygon pads)
-    // Draw polygon pad
     const padOutline = hole.pad_outline
     if (padOutline && padOutline.length >= 3) {
       // Transform pad_outline points to be relative to hole.x, hole.y
@@ -462,12 +462,47 @@ export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {
         x: hole.x + point.x,
         y: hole.y + point.y,
       }))
+
+      // For positive margins, draw extended mask area first
+      if (hasSoldermask && margin > 0) {
+        const expandedPoints = offsetPolygonPoints(padPoints, margin)
+        drawPolygon({
+          ctx,
+          points: expandedPoints,
+          fill: positiveMarginColor,
+          realToCanvasMat,
+        })
+      }
+
+      // Draw polygon pad
       drawPolygon({
         ctx,
         points: padPoints,
         fill: copperColor,
         realToCanvasMat,
       })
+
+      // For negative margins, draw soldermask ring on top of the pad
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPolygon(
+          ctx,
+          padPoints,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          copperColor,
+        )
+      }
+
+      // If fully covered, draw soldermask overlay
+      if (isCoveredWithSoldermask) {
+        drawPolygon({
+          ctx,
+          points: padPoints,
+          fill: soldermaskRingColor,
+          realToCanvasMat,
+        })
+      }
     }
 
     // Draw drill hole (with offset, only if not fully covered with soldermask)

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

@@ -9,6 +9,8 @@ import {
   drawSoldermaskRingForRect,
   drawSoldermaskRingForCircle,
   drawSoldermaskRingForPill,
+  drawSoldermaskRingForPolygon,
+  offsetPolygonPoints,
 } from "./soldermask-margin"
 
 export interface DrawPcbSmtPadParams {
@@ -67,7 +69,7 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin),
+        borderRadius: getBorderRadius(pad),
       })
     }
 
@@ -123,7 +125,7 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
         height: pad.height + margin * 2,
         fill: positiveMarginColor,
         realToCanvasMat,
-        borderRadius: getBorderRadius(pad, margin),
+        borderRadius: getBorderRadius(pad),
         rotation: pad.ccw_rotation ?? 0,
       })
     }
@@ -328,6 +330,17 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
 
   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,
@@ -336,8 +349,20 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
         realToCanvasMat,
       })
 
-      // If covered with soldermask and margin >= 0, draw soldermaskOverCopper overlay
-      if (isCoveredWithSoldermask && margin >= 0) {
+      // 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,

package/lib/drawer/elements/soldermask-margin.ts

@@ -324,3 +324,133 @@ export function drawSoldermaskRingForOval(
 
   ctx.restore()
 }
+
+/**
+ * Offsets polygon points by a given distance (positive = outward, negative = inward)
+ */
+export function offsetPolygonPoints(
+  points: Array<{ x: number; y: number }>,
+  offset: number,
+): Array<{ x: number; y: number }> {
+  if (points.length < 3 || offset === 0) return points
+
+  // Calculate polygon centroid
+  let centerX = 0
+  let centerY = 0
+  for (const point of points) {
+    centerX += point.x
+    centerY += point.y
+  }
+  centerX /= points.length
+  centerY /= points.length
+
+  const result: Array<{ x: number; y: number }> = []
+
+  for (const point of points) {
+    // Calculate vector from center to point
+    const vectorX = point.x - centerX
+    const vectorY = point.y - centerY
+
+    // Calculate distance from center
+    const distance = Math.sqrt(vectorX * vectorX + vectorY * vectorY)
+
+    if (distance > 0) {
+      // Normalize vector and offset
+      const normalizedX = vectorX / distance
+      const normalizedY = vectorY / distance
+
+      result.push({
+        x: point.x + normalizedX * offset,
+        y: point.y + normalizedY * offset,
+      })
+    } else {
+      // Point is at center, offset in arbitrary direction
+      result.push({
+        x: point.x + offset,
+        y: point.y,
+      })
+    }
+  }
+
+  return result
+}
+
+/**
+ * Draws a soldermask ring for polygon shapes with negative margin
+ * (soldermask appears inside the pad boundary)
+ */
+export function drawSoldermaskRingForPolygon(
+  ctx: CanvasContext,
+  points: Array<{ x: number; y: number }>,
+  margin: number,
+  realToCanvasMat: Matrix,
+  soldermaskColor: string,
+  padColor: string,
+): void {
+  if (points.length < 3 || margin >= 0) return
+
+  const scaledMargin = Math.abs(margin) * Math.abs(realToCanvasMat.a)
+
+  // For negative margins, outer is pad boundary, inner is contracted by margin
+  // Use source-atop so the ring only appears on the pad
+  const prevCompositeOp = ctx.globalCompositeOperation
+  if (ctx.globalCompositeOperation !== undefined) {
+    ctx.globalCompositeOperation = "source-atop"
+  }
+
+  // Draw outer polygon filled (at pad boundary)
+  ctx.beginPath()
+  const canvasPoints = points.map((p) =>
+    applyToPoint(realToCanvasMat, [p.x, p.y]),
+  )
+
+  const firstPoint = canvasPoints[0]
+  if (firstPoint) {
+    const [firstX, firstY] = firstPoint
+    ctx.moveTo(firstX, firstY)
+
+    for (let i = 1; i < canvasPoints.length; i++) {
+      const point = canvasPoints[i]
+      if (point) {
+        const [x, y] = point
+        ctx.lineTo(x, y)
+      }
+    }
+    ctx.closePath()
+    ctx.fillStyle = soldermaskColor
+    ctx.fill()
+  }
+
+  // Reset composite operation and restore pad color in inner area
+  if (ctx.globalCompositeOperation !== undefined) {
+    ctx.globalCompositeOperation = prevCompositeOp || "source-over"
+  }
+
+  // Restore pad color in inner polygon (contracted by margin)
+  const innerPoints = offsetPolygonPoints(points, margin)
+  if (innerPoints.length >= 3) {
+    ctx.beginPath()
+    const innerCanvasPoints = innerPoints.map((p) =>
+      applyToPoint(realToCanvasMat, [p.x, p.y]),
+    )
+
+    const firstInnerPoint = innerCanvasPoints[0]
+    if (firstInnerPoint) {
+      const [firstX, firstY] = firstInnerPoint
+      ctx.moveTo(firstX, firstY)
+
+      for (let i = 1; i < innerCanvasPoints.length; i++) {
+        const point = innerCanvasPoints[i]
+        if (point) {
+          const [x, y] = point
+          ctx.lineTo(x, y)
+        }
+      }
+      ctx.closePath()
+      ctx.fillStyle = padColor
+      ctx.fill()
+    }
+  }
+
+  ctx.restore()
+}

package/lib/drawer/types.ts

@@ -13,6 +13,7 @@ export interface CanvasContext {
     radius: number,
     startAngle: number,
     endAngle: number,
+    counterclockwise?: boolean,
   ): void
   arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void
   ellipse(
@@ -24,7 +25,7 @@ export interface CanvasContext {
     startAngle: number,
     endAngle: number,
   ): void
-  fill(): void
+  fill(fillRule?: "nonzero" | "evenodd"): void
   stroke(): void
   rect(x: number, y: number, w: number, h: number): void
   lineTo(x: number, y: number): void
@@ -38,6 +39,7 @@ export interface CanvasContext {
   globalCompositeOperation?: string
   fillStyle: string | CanvasGradient | CanvasPattern
   strokeStyle: string | CanvasGradient | CanvasPattern
+  globalAlpha: number
   lineWidth: number
   lineCap: "butt" | "round" | "square"
   lineJoin: "bevel" | "round" | "miter"

package/package.json

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