circuit-to-canvas 0.0.45 → 0.0.46

package/lib/drawer/CircuitToCanvasDrawer.ts

@@ -182,11 +182,7 @@ export class CircuitToCanvasDrawer {
     )
 
     for (const element of elements) {
-      if (
-        element.type === "pcb_board" &&
-        (hasSoldermaskPads || hasSoldermaskHoles || hasSoldermaskPlatedHoles)
-      ) {
-        // Draw board with soldermask fill when pads or holes have soldermask
+      if (element.type === "pcb_board") {
         this.drawBoardWithSoldermask(element as PcbBoard)
       } else {
         this.drawElement(element, options)

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

@@ -5,6 +5,12 @@ import { drawCircle } from "../shapes/circle"
 import { drawRect } from "../shapes/rect"
 import { drawOval } from "../shapes/oval"
 import { drawPill } from "../shapes/pill"
+import {
+  drawSoldermaskRingForCircle,
+  drawSoldermaskRingForOval,
+  drawSoldermaskRingForPill,
+  drawSoldermaskRingForRect,
+} from "./soldermask-margin"
 
 export interface DrawPcbHoleParams {
   ctx: CanvasContext
@@ -24,12 +30,15 @@ function getRotation(hole: PCBHole): number {
 export function drawPcbHole(params: DrawPcbHoleParams): void {
   const { ctx, hole, realToCanvasMat, colorMap } = params
 
+  const isCoveredWithSoldermask = hole.is_covered_with_solder_mask === true
+  const margin = isCoveredWithSoldermask ? 0 : (hole.soldermask_margin ?? 0)
   const hasSoldermask =
-    hole.is_covered_with_solder_mask === true &&
+    !isCoveredWithSoldermask &&
     hole.soldermask_margin !== undefined &&
-    hole.soldermask_margin > 0
-  const margin = hasSoldermask ? hole.soldermask_margin! : 0
+    hole.soldermask_margin !== 0
   const positiveMarginColor = colorMap.substrate
+  const soldermaskOverlayColor = colorMap.soldermask.top
+  const soldermaskRingColor = colorMap.soldermask.top
 
   if (hole.hole_shape === "circle") {
     // For positive margins, draw extended mask area first
@@ -43,14 +52,40 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawCircle({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius: hole.hole_diameter / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForCircle(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_diameter / 2,
+          margin,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill,
+        )
+      }
+    }
+
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawCircle({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+      })
+    }
     return
   }
 
@@ -69,16 +104,47 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawRect({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_diameter,
-      height: hole.hole_diameter,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_diameter,
+        height: hole.hole_diameter,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForRect(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_diameter,
+          hole.hole_diameter,
+          margin,
+          0,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill,
+        )
+      }
+    }
+
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_diameter,
+        height: hole.hole_diameter,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 
@@ -97,16 +163,46 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawOval({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      radius_x: hole.hole_width / 2,
-      radius_y: hole.hole_height / 2,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.hole_width / 2,
+        radius_y: hole.hole_height / 2,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForOval(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width / 2,
+          hole.hole_height / 2,
+          margin,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill,
+        )
+      }
+    }
+
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawOval({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        radius_x: hole.hole_width / 2,
+        radius_y: hole.hole_height / 2,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 
@@ -125,16 +221,47 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawRect({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForRect(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width,
+          hole.hole_height,
+          margin,
+          0,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill,
+        )
+      }
+    }
+
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawRect({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 
@@ -153,16 +280,46 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPill(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width,
+          hole.hole_height,
+          margin,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill,
+        )
+      }
+    }
+
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 
@@ -182,16 +339,46 @@ export function drawPcbHole(params: DrawPcbHoleParams): void {
       })
     }
 
-    // Draw the hole
-    drawPill({
-      ctx,
-      center: { x: hole.x, y: hole.y },
-      width: hole.hole_width,
-      height: hole.hole_height,
-      fill: colorMap.drill,
-      realToCanvasMat,
-      rotation,
-    })
+    // Draw the hole (only if not fully covered with soldermask)
+    if (!isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: colorMap.drill,
+        realToCanvasMat,
+        rotation,
+      })
+
+      // For negative margins, draw soldermask ring on top of the hole
+      if (hasSoldermask && margin < 0) {
+        drawSoldermaskRingForPill(
+          ctx,
+          { x: hole.x, y: hole.y },
+          hole.hole_width,
+          hole.hole_height,
+          margin,
+          rotation,
+          realToCanvasMat,
+          soldermaskRingColor,
+          colorMap.drill,
+        )
+      }
+    }
+
+    // If fully covered, draw soldermask overlay
+    if (isCoveredWithSoldermask) {
+      drawPill({
+        ctx,
+        center: { x: hole.x, y: hole.y },
+        width: hole.hole_width,
+        height: hole.hole_height,
+        fill: soldermaskOverlayColor,
+        realToCanvasMat,
+        rotation,
+      })
+    }
     return
   }
 }