Kicad nightly features

Add support for trapezoid pads and non-filled shapes

Author: qu1ck

DATAFORMAT.md

@@ -161,6 +161,9 @@ attribute.
   "type": "circle",
   "start": [x, y],
   "radius": radius,
+  // Optional boolean, defaults to 0
+  "filled": 0,
+  // Line width (only has effect for non-filled shapes)
   "width": width,
 }
 ```
@@ -199,6 +202,10 @@ attribute.
 ```js
 {
   "type": "polygon",
+  // Optional, defaults to 1
+  "filled": 1,
+  // Line width (only has effect for non-filled shapes)
+  "width": width
   // SVG path of the polygon given as 'd' attribute of svg spec.
   // If this parameter is specified everything below it is ignored.
   "svgpath": svgpath,

InteractiveHtmlBom/ecad/kicad.py

@@ -84,20 +84,35 @@ def parse_shape(self, d):
             return None
         start = self.normalize(d.GetStart())
         end = self.normalize(d.GetEnd())
-        if shape in ["segment", "rect"]:
+        if shape == "segment" or shape == "rect" and not d.IsFilled():
             return {
                 "type": shape,
                 "start": start,
                 "end": end,
                 "width": d.GetWidth() * 1e-6
             }
-        if shape == "circle":
+        if shape == "rect" and d.IsFilled():
             return {
+                "type": "polygon",
+                "pos": start,
+                "angle": 0,
+                "polygons": [[
+                    [0, 0],
+                    [end[0] - start[0], 0],
+                    [end[0] - start[0], end[1] - start[1]],
+                    [0, end[1] - start[1]]
+                ]]
+            }
+        if shape == "circle":
+            shape_dict = {
                 "type": shape,
                 "start": start,
                 "radius": d.GetRadius() * 1e-6,
                 "width": d.GetWidth() * 1e-6
             }
+            if d.IsFilled():
+                shape_dict["filled"] = 1
+            return shape_dict
         if shape == "arc":
             a1 = round(d.GetArcAngleStart() * 0.1, 2)
             a2 = round((d.GetArcAngleStart() + d.GetAngle()) * 0.1, 2)
@@ -125,12 +140,16 @@ def parse_shape(self, d):
                 parent_footprint = d.GetParentFootprint()
             if parent_footprint is not None:
                 angle = parent_footprint.GetOrientation() * 0.1,
-            return {
+            shape_dict = {
                 "type": shape,
                 "pos": start,
                 "angle": angle,
                 "polygons": polygons
             }
+            if not d.IsFilled():
+                shape_dict["filled"] = 0
+                shape_dict["width"] = d.GetWidth() * 1e-6
+            return shape_dict
         if shape == "curve":
             return {
                 "type": shape,
@@ -290,6 +309,8 @@ def parse_pad(self, pad):
             pcbnew.PAD_SHAPE_OVAL: "oval",
             pcbnew.PAD_SHAPE_CIRCLE: "circle",
         }
+        if hasattr(pcbnew, "PAD_SHAPE_TRAPEZOID"):
+            shape_lookup[pcbnew.PAD_SHAPE_TRAPEZOID] = "trapezoid"
         if hasattr(pcbnew, "PAD_SHAPE_ROUNDRECT"):
             shape_lookup[pcbnew.PAD_SHAPE_ROUNDRECT] = "roundrect"
         if hasattr(pcbnew, "PAD_SHAPE_CUSTOM"):
@@ -312,10 +333,18 @@ def parse_pad(self, pad):
             polygon_set = pad.GetCustomShapeAsPolygon()
             if polygon_set.HasHoles():
                 self.logger.warn('Detected holes in custom pad polygons')
-            if polygon_set.IsSelfIntersecting():
-                self.logger.warn(
-                    'Detected self intersecting polygons in custom pad')
             pad_dict["polygons"] = self.parse_poly_set(polygon_set)
+        if shape == "trapezoid":
+            # treat trapezoid as custom shape
+            pad_dict["shape"] = "custom"
+            delta = self.normalize(pad.GetDelta())
+            pad_dict["polygons"] = [[
+                [size[0] / 2 + delta[1] / 2, size[1] / 2 - delta[0] / 2],
+                [-size[0] / 2 - delta[1] / 2, size[1] / 2 + delta[0] / 2],
+                [-size[0] / 2 + delta[1] / 2, -size[1] / 2 - delta[0] / 2],
+                [size[0] / 2 - delta[1] / 2, -size[1] / 2 + delta[0] / 2],
+            ]]
+
         if shape in ["roundrect", "chamfrect"]:
             pad_dict["radius"] = pad.GetRoundRectCornerRadius() * 1e-6
         if shape == "chamfrect":
@@ -498,8 +527,7 @@ def parse_zones(self, zones):
     def parse_netlist(net_info):
         # type: (pcbnew.NETINFO_LIST) -> list
         nets = net_info.NetsByName().asdict().keys()
-        nets = [str(s) for s in nets]
-        nets.sort()
+        nets = sorted([str(s) for s in nets])
         return nets
 
     @staticmethod

InteractiveHtmlBom/ecad/schema/genericjsonpcbdata_v1.schema

@@ -367,6 +367,7 @@
                 "type": { "const": "circle" },
                 "start": { "$ref": "#/definitions/Coordinates" },
                 "radius": { "type": "number" },
+                "filled": { "type": "integer" },
                 "width": { "type": "number" }
             },
             "required": ["type", "start", "radius", "width"],
@@ -413,6 +414,8 @@
             "additionalProperties": false,
             "properties": {
                 "type": { "const": "polygon" },
+                "filled": { "type": "integer" },
+                "width": { "type": "number" },
                 "svgpath": { "type": "string" },
                 "pos": { "$ref": "#/definitions/Coordinates" },
                 "angle": { "type": "number" },

InteractiveHtmlBom/web/render.js

@@ -111,6 +111,7 @@ function drawText(ctx, text, color) {
 
 function drawedge(ctx, scalefactor, edge, color) {
   ctx.strokeStyle = color;
+  ctx.fillStyle = color;
   ctx.lineWidth = Math.max(1 / scalefactor, edge.width);
   ctx.lineCap = "round";
   ctx.lineJoin = "round";
@@ -147,7 +148,10 @@ function drawedge(ctx, scalefactor, edge, color) {
       ctx.moveTo(...edge.start);
       ctx.bezierCurveTo(...edge.cpa, ...edge.cpb, ...edge.end);
     }
-    ctx.stroke();
+    if("filled" in edge && edge.filled)
+      ctx.fill();
+    else
+      ctx.stroke();
   }
 }
 
@@ -216,22 +220,30 @@ function getPolygonsPath(shape) {
   return shape.path2d;
 }
 
-function drawPolygonShape(ctx, shape, color) {
+function drawPolygonShape(ctx, scalefactor, shape, color) {
   ctx.save();
-  ctx.fillStyle = color;
   if (!("svgpath" in shape)) {
     ctx.translate(...shape.pos);
     ctx.rotate(deg2rad(-shape.angle));
   }
-  ctx.fill(getPolygonsPath(shape));
+  if("filled" in shape && !shape.filled) {
+    ctx.strokeStyle = color;
+    ctx.lineWidth = Math.max(1 / scalefactor, shape.width);
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    ctx.stroke(getPolygonsPath(shape));
+  } else {
+    ctx.fillStyle = color;
+    ctx.fill(getPolygonsPath(shape));
+  }
   ctx.restore();
 }
 
 function drawDrawing(ctx, scalefactor, drawing, color) {
   if (["segment", "arc", "circle", "curve", "rect"].includes(drawing.type)) {
     drawedge(ctx, scalefactor, drawing, color);
   } else if (drawing.type == "polygon") {
-    drawPolygonShape(ctx, drawing, color);
+    drawPolygonShape(ctx, scalefactor, drawing, color);
   } else {
     drawText(ctx, drawing, color);
   }
@@ -340,7 +352,7 @@ function drawEdgeCuts(canvas, scalefactor) {
   var ctx = canvas.getContext("2d");
   var edgecolor = getComputedStyle(topmostdiv).getPropertyValue('--pcb-edge-color');
   for (var edge of pcbdata.edges) {
-    drawedge(ctx, scalefactor, edge, edgecolor);
+    drawDrawing(ctx, scalefactor, edge, edgecolor);
   }
 }
 
@@ -384,7 +396,7 @@ function drawBgLayer(layername, canvas, layer, scalefactor, edgeColor, polygonCo
     if (["segment", "arc", "circle", "curve", "rect"].includes(d.type)) {
       drawedge(ctx, scalefactor, d, edgeColor);
     } else if (d.type == "polygon") {
-      drawPolygonShape(ctx, d, polygonColor);
+      drawPolygonShape(ctx, scalefactor, d, polygonColor);
     } else {
       drawText(ctx, d, textColor);
     }
@@ -508,7 +520,7 @@ function drawBackground(canvasdict, clear = true) {
   drawFootprints(canvasdict.bg, canvasdict.layer,
     canvasdict.transform.s * canvasdict.transform.zoom, false);
 
-  drawEdgeCuts(canvasdict.bg, canvasdict.transform.s);
+  drawEdgeCuts(canvasdict.bg, canvasdict.transform.s * canvasdict.transform.zoom);
 
   var style = getComputedStyle(topmostdiv);
   var edgeColor = style.getPropertyValue('--silkscreen-edge-color');