Files
kicad-action-scripts/ViaStitching/FillArea.py
T
Zdeněk bb6815b9b2 ViaStitching 1.3: checks against poured copper, snap grid, skip markers
- clearances checked with exact shapes (round via) against pads, tracks,
  vias, copper drawings, other zones' poured copper and keepouts;
  Rectangular no longer uses square box tests
- Outline follows the poured copper edge, vias on the grid
- same-net pads: only thermal relief gap and hole-to-hole spacing
- optional zone refill before placing vias
- snap grid option (disables Grid Origin choice)
- via group mode: per net, per net and pattern, new group per run
- optional markers of skipped vias on User.Drawings with reason letter
- option to keep vias out of footprint references
- warning when "Only under selected Zone" has no zone of the net selected
- dialog: options in two columns, narrower window
2026-11-16 18:42:58 +01:00

1281 lines
52 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# FillArea.py
#
# Copyright 2017 JS Reynaud <js.reynaud@gmail.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
from __future__ import print_function
from pcbnew import *
from builtins import abs
import sys
import tempfile
import shutil
import os
import random
import math
import pprint
import wx
from inspect import currentframe, getframeinfo
import time
def wxPrint(msg):
wx.LogMessage(msg)
def KicadMajorVersion():
"""Return KiCad major version as int (string compare breaks for 10+)."""
try:
return int(str(Version()).lstrip("(").split(".")[0])
except (ValueError, IndexError):
return 99
def ViaWidth(via):
"""Via copper width; KiCad 10+ padstacks need a layer argument."""
try:
return via.GetWidth(F_Cu)
except TypeError:
return via.GetWidth()
def Unfracture(poly):
"""Split outlines back into outline + holes (fractured polygons join holes by slits)."""
try:
poly.Unfracture()
except TypeError:
poly.Unfracture(SHAPE_POLY_SET.PM_FAST) # KiCad 8 and older
def PadCollidesShape(pad, shape):
"""Test pad copper polygon vs. shape; KiCad 10+ needs a layer argument."""
try:
layers = list(pad.GetLayerSet().CuStack())
if not layers:
return False
for layer in layers:
if pad.GetEffectivePolygon(layer).Collide(shape):
return True
return False
except TypeError:
# KiCad 9 and older
return pad.GetEffectivePolygon().Collide(shape)
#
if sys.version[0] == "2": # maui
None
else:
xrange = range
"""
# This script fills all areas of a specific net with Vias (Via Stitching)
#
#
# Usage in pcbnew's python console:
# First you neet to copy this file (named FillArea.py) in your kicad_plugins
# directory (~/.kicad_plugins/ on Linux)
# Launch pcbnew and open python console (last entry of Tools menu)
# Then enter the following line (one by one, Hit enter after each)
import FillArea
FillArea.FillArea().Run()
# Other example:
# You can add modifications to parameters by adding functions calls:
FillArea.FillArea().SetDebug().SetNetname("GND").SetStepMM(1.27).SetSizeMM(0.6).SetDrillMM(0.3).SetClearanceMM(0.2).Run()
# with
# SetDebug: Activate debug mode (print evolution of the board in ascii art)
# SetViaThroughAreas: Ignores areas on other layers
# SetNetname: Change the netname to consider for the filling
# (default is /GND or fallback to GND)
# SetStepMM: Change step between Via (in mm)
# SetSizeMM: Change Via copper size (in mm)
# SetDrillMM: Change Via drill hole size (in mm)
# SetClearanceMM: Change clearance for Via (in mm)
# You can also use it in command line. In this case, the first parameter is
# the pcb file path. Default options are applied.
"""
class ViaObject:
"""
ViaObject holds all information of a single Via
"""
def __init__(self, x, y, pos_x, pos_y):
self.X = x
self.Y = y
self.PosX = pos_x
self.PosY = pos_y
class FillArea:
"""
Automaticaly add via on area where there are no track/existing via,
pads and keepout areas
"""
REASON_OK = 0
REASON_NO_SIGNAL = 1
REASON_OTHER_SIGNAL = 2
REASON_KEEPOUT = 3
REASON_TRACK = 4
REASON_PAD = 5
REASON_DRAWING = 6
REASON_STEP = 7
REASON_NO_FILL = 8
REASON_BOARD_EDGE = 9
REASON_REFERENCE = 10
# Letters drawn into the "skipped via" markers
SKIP_LABELS = {
REASON_OTHER_SIGNAL: "Z",
REASON_KEEPOUT: "K",
REASON_TRACK: "T",
REASON_PAD: "P",
REASON_DRAWING: "D",
REASON_NO_FILL: "F",
REASON_BOARD_EDGE: "E",
REASON_REFERENCE: "R",
}
GRID_TYPE_BOARD_BOUNDS = "Board Bounds"
GRID_TYPE_ABSOLUTE = "Absolute (0, 0)"
GRID_TYPE_GRID_ORIGIN = "Grid Origin"
FILL_TYPE_RECTANGULAR = "Rectangular"
FILL_TYPE_STAR = "Star"
FILL_TYPE_CONCENTRIC = "Concentric"
FILL_TYPE_OUTLINE = "Outline"
FILL_TYPE_OUTLINE_NO_HOLES = "Outline (No Holes)"
GROUP_MODE_PER_NET = "Per net"
GROUP_MODE_PER_PATTERN = "Per net and pattern"
GROUP_MODE_PER_RUN = "New group per run"
def __init__(self, filename=None):
self.filename = None
self.clearance = 0
# Net name to use
self.SetPCB(GetBoard())
# Set the filename
self.SetFile(filename)
# Step between via
self.SetStepMM(2.54)
# Size of the via (diameter of copper)
self.SetSizeMM(0.46)
# Size of the drill (diameter)
self.SetDrillMM(0.20)
# Isolation between via and other elements
# ie: radius from the border of the via
self.SetClearanceMM(0.2)
self.only_selected_area = False
self.delete_vias = False
self.via_through_areas = False
self.same_net_tracks = False
self.refill_zones = False
self.mark_skipped = False
self.skip_reference = False
self.ref_shapes = []
self.pad_gap_cache = {}
self.area_fill_cache = {}
self.snap = 0
self.grid_origin = VECTOR2I(0, 0)
self.skipped = {} # (x, y) -> reason, drawn by DrawSkippedMarkers()
self.unfilled_zones = []
if self.pcb is not None:
for lnet in ["GND", "/GND"]:
if self.pcb.FindNet(lnet) is not None:
self.SetNetname(lnet)
break
self.netname = None
self.debug = False
self.random = False
self.grid_type = self.GRID_TYPE_BOARD_BOUNDS
self.fill_type = self.FILL_TYPE_RECTANGULAR
self.group_mode = self.GROUP_MODE_PER_NET
if self.netname is None:
self.SetNetname("GND")
self.tmp_dir = None
self.parent_area = None
self.pcb_group = None
self.target_net = None
def SetFile(self, filename):
self.filename = filename
if self.filename:
self.SetPCB(LoadBoard(self.filename))
def SetDebug(self):
wxPrint("Set debug")
self.debug = True
return self
def SetRandom(self, r):
random.seed()
self.random = r
return self
def SetViaThroughAreas(self, r):
self.via_through_areas = r
return self
def SetSameNetTracks(self, r):
self.same_net_tracks = r
return self
def SetSkipReference(self, r):
self.skip_reference = r
return self
def SetMarkSkipped(self, r):
self.mark_skipped = r
return self
def AddSkipped(self, p, reason):
if self.mark_skipped and reason in self.SKIP_LABELS:
self.skipped.setdefault((int(p.x), int(p.y)), reason)
def DrawSkippedMarkers(self, group_name):
"""Draw a circle with the reason letter on User.Drawings for every skipped via position."""
if not self.mark_skipped or not self.skipped:
return 0
# A position rejected for one zone may still have got a via from another zone (other layer)
placed = [via.GetPosition() for via in self.pcb_group.GetItems() if via.GetClass() == "PCB_VIA"] if self.pcb_group else []
group = PCB_GROUP(None)
group.SetName(group_name + " skipped")
self.pcb.Add(group)
radius = int(self.size / 2)
count = 0
for (x, y), reason in sorted(self.skipped.items()):
p = VECTOR2I(x, y)
if any((p - v).EuclideanNorm() < radius for v in placed):
continue
circle = PCB_SHAPE(self.pcb)
circle.SetShape(SHAPE_T_CIRCLE)
circle.SetLayer(Dwgs_User)
circle.SetWidth(FromMM(0.05))
circle.SetCenter(p)
circle.SetEnd(VECTOR2I(x + radius, y))
self.pcb.Add(circle)
group.AddItem(circle)
text = PCB_TEXT(self.pcb)
text.SetLayer(Dwgs_User)
text.SetText(self.SKIP_LABELS[reason])
h = max(int(radius * 1.2), FromMM(0.2))
text.SetTextSize(VECTOR2I(h, h))
text.SetTextThickness(max(h // 8, FromMM(0.02)))
text.SetHorizJustify(GR_TEXT_H_ALIGN_CENTER)
text.SetVertJustify(GR_TEXT_V_ALIGN_CENTER)
text.SetPosition(p)
self.pcb.Add(text)
group.AddItem(text)
count += 1
wxPrint("{} skipped via positions marked on User.Drawings (group '{}'): "
"P=pad T=track Z=other zone K=keepout D=copper drawing F=no poured copper E=board edge R=reference".format(count, group.GetName()))
return count
def SetRefillZones(self, r):
self.refill_zones = r
return self
def GetZoneFill(self, zone):
"""Filled copper of the zone, one SHAPE_POLY_SET per copper layer.
Only the via centre has to lie on poured copper: the fill edge already keeps
the zone clearance, so the via copper may reach slightly past it; clearance to
the surrounding objects is checked separately (CheckViaPosition / pads / tracks).
Returns None when the zone is not filled (fill check is then skipped).
"""
polys = []
for layer in zone.GetLayerSet().CuStack():
try:
fill = zone.GetFilledPolysList(layer)
except Exception:
fill = None
if fill is None or fill.OutlineCount() == 0:
continue
polys.append(SHAPE_POLY_SET(fill))
if polys:
return polys
self.unfilled_zones.append("{} ({})".format(zone.GetNetname(), zone.GetLayerName()))
return None
@staticmethod
def IsOnZoneFill(zone_fill, p):
return zone_fill is None or any(poly.Contains(p) for poly in zone_fill)
def ReportUnfilledZones(self):
if self.unfilled_zones:
wxPrint("WARNING: zone(s) not filled, vias were not checked against the poured copper: {}.\n"
"Fill all zones (B) before running the plugin.".format(", ".join(self.unfilled_zones)))
def SetGridType(self, grid_type):
self.grid_type = grid_type
return self
def SetSnapMM(self, s):
"""Snap every via to a fine grid (grid origin of the board + n * s); 0 = off."""
self.snap = int(FromMM(s)) if s and s > 0 else 0
return self
def SnapCandidates(self, p):
"""The 4 snap grid points around p, nearest first (just p when snap is off)."""
if not self.snap:
return [p]
o = self.grid_origin
fx = int(math.floor((p.x - o.x) / float(self.snap)))
fy = int(math.floor((p.y - o.y) / float(self.snap)))
pts = [VECTOR2I(o.x + (fx + i) * self.snap, o.y + (fy + j) * self.snap) for i in (0, 1) for j in (0, 1)]
pts.sort(key=lambda q: (q - p).EuclideanNorm())
return pts
def GetGridOrig(self, lboard):
if self.snap:
# Snap grid follows the editor grid, which starts at the board grid origin
return self.pcb.GetDesignSettings().GetGridOrigin()
if self.grid_type == self.GRID_TYPE_ABSOLUTE:
return VECTOR2I(0, 0)
elif self.grid_type == self.GRID_TYPE_GRID_ORIGIN:
return self.pcb.GetDesignSettings().GetGridOrigin()
else:
return lboard.GetPosition()
def SetFillType(self, fill_type):
self.fill_type = fill_type
return self
def SetGroupMode(self, group_mode):
self.group_mode = group_mode
return self
def GetGroupName(self):
"""Name of the group the new vias go to (depends on group_mode)."""
base = "ViaStitching {}".format(self.netname)
if self.group_mode == self.GROUP_MODE_PER_NET:
return base
base = "{} {}".format(base, self.fill_type)
if self.group_mode == self.GROUP_MODE_PER_PATTERN:
return base
# New group per run: first free "<base> #N"
names = set(g.GetName() for g in self.pcb.Groups())
n = 1
while "{} #{}".format(base, n) in names:
n += 1
return "{} #{}".format(base, n)
def SetPCB(self, pcb):
self.pcb = pcb
if self.pcb is not None:
self.pcb.BuildListOfNets()
return self
def SetNetname(self, netname):
self.netname = netname # .upper()
# wx.LogMessage(self.netname)
return self
def SetStepMM(self, s):
self.step = float(FromMM(s))
return self
def SetSizeMM(self, s):
self.size = float(FromMM(s))
return self
def SetDrillMM(self, s):
self.drill = float(FromMM(s))
return self
def OnlyOnSelectedArea(self):
self.only_selected_area = True
return self
def DeleteVias(self):
self.delete_vias = True
return self
def SetClearanceMM(self, s):
self.clearance = float(FromMM(s))
return self
def GetReasonSymbol(self, reason):
if isinstance(reason, ViaObject):
return "X"
if reason == self.REASON_NO_SIGNAL:
return " "
if reason == self.REASON_OTHER_SIGNAL:
return "O"
if reason == self.REASON_KEEPOUT:
return "K"
if reason == self.REASON_TRACK:
return "T"
if reason == self.REASON_PAD:
return "P"
if reason == self.REASON_DRAWING:
return "D"
if reason == self.REASON_STEP:
return "-"
return str(reason)
def PrintRect(self, rectangle):
"""debuging tool
Print board in ascii art
"""
print("_" * (len(rectangle) + 2))
for y in range(len(rectangle[0])):
print("|", end="")
for x in range(len(rectangle)):
print("%s" % self.GetReasonSymbol(rectangle[x][y]), end="")
print("|")
print("_" * (len(rectangle) + 2))
print(
"""
OK = 'X'
NO_SIGNAL = ' '
OTHER_SIGNAL = 'O'
KEEPOUT = 'K'
TRACK = 'T'
PAD = 'P'
DRAWING = 'D'
STEP = '-'
"""
)
def AddVia(self, position, x, y):
if self.parent_area:
m = PCB_VIA(self.parent_area)
m.SetPosition(position)
if self.target_net is None:
self.target_net = self.pcb.FindNet(self.netname)
m.SetNet(self.target_net)
m.SetViaType(VIATYPE_THROUGH)
m.SetDrill(int(self.drill))
m.SetWidth(int(self.size))
m.SetIsFree(True)
# again possible to mark via as own since no timestamp_t binding kicad v5.1.4
# m.SetParentGroup(self.parent_group)
# wx.LogMessage('adding vias')
self.pcb.Add(m)
self.pcb_group.AddItem(m)
return m
else:
wxPrint("\nUnable to find a valid parent area (zone)")
def RefillBoardAreas(self):
for i in range(self.pcb.GetAreaCount()):
area = self.pcb.GetArea(i)
# No more making a real refill since it's crashing KiCad
if KicadMajorVersion() < 7:
None
else:
area.SetNeedRefill(True)
# area.UnFill()
# filler = ZONE_FILLER(self.pcb)
# filler.Fill(self.pcb.Zones())
def AreaFillCached(self, area):
"""Poured copper of a zone, one SHAPE_POLY_SET per copper layer (cached per run).
None when the zone is not filled."""
key = area.m_Uuid.AsString()
if key not in self.area_fill_cache:
polys = []
for layer in area.GetLayerSet().CuStack():
try:
fill = area.GetFilledPolysList(layer)
except Exception:
fill = None
if fill is not None and fill.OutlineCount() > 0:
polys.append(SHAPE_POLY_SET(fill))
self.area_fill_cache[key] = polys if (polys or area.IsFilled()) else None
return self.area_fill_cache[key]
def CheckViaInAllAreas(self, via, all_areas):
"""
Checks a via (round, through all layers) against keepouts and zones of other nets.
- Rule area forbidding vias: the via must not touch its outline.
- Copper zone of another net (unless "Ignore other areas"): the via copper plus
clearance must not touch its poured copper, otherwise the via would punch a hole
into it. An unfilled zone is checked against its outline instead, where a target
net zone with higher priority on the same layer wins.
Rule areas without via restriction and zones of the target net are ignored.
"""
p = VECTOR2I(int(via.PosX), int(via.PosY))
radius = int(self.size / 2)
for area in all_areas:
if area.GetIsRuleArea():
if area.GetDoNotAllowVias() and area.Outline().Collide(p, radius):
return self.REASON_KEEPOUT
continue
if area.GetNetname() == self.netname or self.via_through_areas:
continue
clr = int(max(self.clearance, area.GetLocalClearance() or 0)) + radius
fill = self.AreaFillCached(area)
if fill is not None:
if any(poly.Collide(p, clr) for poly in fill):
return self.REASON_OTHER_SIGNAL
continue
# Not filled: use the drawn outline
if not area.Outline().Collide(p, clr):
continue
area_layers = set(area.GetLayerSet().CuStack())
covered = any(
other.GetNetname() == self.netname
and not other.GetIsRuleArea()
and other.GetAssignedPriority() > area.GetAssignedPriority()
and area_layers.issubset(set(other.GetLayerSet().CuStack()))
and other.Outline().Contains(p)
for other in all_areas
)
if not covered:
return self.REASON_OTHER_SIGNAL
return self.REASON_OK
def ClearViaInStepSize(self, rectangle, x, y, distance):
"""
Stepsize==0
O O O O O O O O O
O O O O O O O O O
O O O O O O O O O
O O O O O O O O O
O O O O O O O O O
O O O O O O O O O
O O O O O O O O O
Standard
O O O O O
O O O O O
O O O O O
O O O O O
Star
O O O O O
O O O O
O O O O O
O O O O
O O O O O
O O O O
O O O O O
"""
for x_pos in range(x - distance, x + distance + 1):
if (x_pos >= 0) and (x_pos < len(rectangle)):
# Star or Standard shape
distance_y = distance - abs(x - x_pos) if self.fill_type == self.FILL_TYPE_STAR else distance
for y_pos in range(y - distance_y, y + distance_y + 1):
if (y_pos >= 0) and (y_pos < len(rectangle[0])):
if (x_pos == x) and (y_pos == y):
continue
rectangle[x_pos][y_pos] = self.REASON_STEP
"""
Check if vias would not overlap and if in same outline then apply at minimum 60% of self.step
"""
def CheckViaDistance(self, p, via, outline):
p2 = VECTOR2I(via.GetPosition())
dist = self.clearance + self.size / 2 + ViaWidth(via) / 2
# If via in same outline, then apply bigger space
if outline.Collide(p2):
dist = int(max(dist, self.step * 0.6))
return (p - p2).EuclideanNorm() >= dist
"""
Add via along outline (SHAPE_LINE_CHAIN), starting at offset (fraction between 0.0 and 1.0)
Avoid placing vias to close to via present in all_vias
"""
def GetBoardEdge(self):
"""Board outline shrunk so that a via centre inside it keeps the edge clearance."""
board_edge = SHAPE_POLY_SET()
try:
# KiCad 10+: aInferOutlineIfNecessary is a required argument
self.pcb.GetBoardPolygonOutlines(board_edge, True)
except TypeError:
# KiCad 9 and older
self.pcb.GetBoardPolygonOutlines(board_edge)
b_clearance = max(self.pcb.GetDesignSettings().m_CopperEdgeClearance, self.clearance) + self.size / 2
board_edge.Deflate(int(b_clearance), CORNER_STRATEGY_ROUND_ALL_CORNERS, FromMM(0.01))
return board_edge
def PrepareObstacles(self, include_net_vias=False):
"""Collect everything a via must keep clear of. Existing vias of the target net are
included only on request (outline/concentric check their spacing by CheckViaDistance)."""
self.obs_board_edge = self.GetBoardEdge()
self.obs_areas = [self.pcb.GetArea(i) for i in xrange(self.pcb.GetAreaCount())]
# Each obstacle: (inflated bounding box for a quick reject, item, kind)
reach = int(self.size / 2 + self.clearance) + FromMM(1) # generous margin for the bbox prefilter
self.obstacles = []
def add(item, kind):
bbox = item.GetBoundingBox()
bbox.Inflate(reach + int(item.GetOwnClearance(UNDEFINED_LAYER, "") if kind != "drawing" else 0))
self.obstacles.append((bbox, item, kind))
for pad in self.pcb.GetPads():
add(pad, "pad")
for track in self.pcb.GetTracks():
if track.GetNetname() == self.netname:
if track.GetClass() == "PCB_VIA":
if include_net_vias:
add(track, "track")
continue
if self.same_net_tracks:
continue
add(track, "track")
try:
drawings = list(self.pcb.Drawings())
except Exception:
drawings = list(self.pcb.DrawingsList())
for draw in drawings:
if IsCopperLayer(draw.GetLayer()):
add(draw, "drawing")
# Visible footprint references: a via must not cut through the reference text
self.ref_shapes = []
if self.skip_reference:
for fp in self.pcb.GetFootprints():
ref = fp.Reference()
if ref.IsVisible() and ref.GetText():
self.ref_shapes.append(self.TextBoxPoly(ref))
@staticmethod
def TextBoxPoly(text):
"""Text box of a (possibly rotated) text as a polygon."""
box = text.GetTextBox(None)
c = text.GetDrawPos()
a = text.GetDrawRotation().AsRadians()
cos_a, sin_a = math.cos(a), math.sin(a)
poly = SHAPE_POLY_SET()
poly.NewOutline()
for x, y in ((box.GetLeft(), box.GetTop()), (box.GetRight(), box.GetTop()),
(box.GetRight(), box.GetBottom()), (box.GetLeft(), box.GetBottom())):
dx, dy = x - c.x, y - c.y
poly.Append(int(c.x + dx * cos_a + dy * sin_a), int(c.y - dx * sin_a + dy * cos_a))
return poly
def IsSameNetPad(self, pad):
"""Pads of the target net need no clearance to the via, only no overlap
and hole-to-hole spacing."""
return pad.GetNetname() == self.netname
def SameNetPadGap(self, pad):
"""Copper gap a via must keep to a pad of the target net: the thermal relief gap
when the pad is connected to a target zone by a thermal relief, otherwise 0."""
key = pad.m_Uuid.AsString()
if key in self.pad_gap_cache:
return self.pad_gap_cache[key]
conn = pad.GetLocalZoneConnection()
fp = pad.GetParentFootprint()
if conn == ZONE_CONNECTION_INHERITED and fp is not None:
conn = fp.GetLocalZoneConnection()
try:
pad_gap = pad.GetLocalThermalGapOverride()
except Exception:
pad_gap = None
gap = 0
pad_layers = list(pad.GetLayerSet().CuStack())
for zone in self.pcb.Zones():
if zone.GetNetname() != self.netname or zone.GetIsRuleArea():
continue
if not any(zone.IsOnLayer(layer) for layer in pad_layers):
continue
c = conn if conn != ZONE_CONNECTION_INHERITED else zone.GetPadConnection()
if c == ZONE_CONNECTION_THERMAL or (c == ZONE_CONNECTION_THT_THERMAL and pad.GetAttribute() == PAD_ATTRIB_PTH):
gap = max(gap, pad_gap if pad_gap else zone.GetThermalReliefGap())
self.pad_gap_cache[key] = gap
return gap
def SameNetPadBlocksVia(self, pad, p):
"""Pad of the target net: no clearance needed, only keep the via out of the pad
(no via-in-pad / solder wicking) and out of its thermal relief gap, and keep
the minimum hole-to-hole distance."""
radius = int(self.size / 2) + int(self.SameNetPadGap(pad))
for layer in pad.GetLayerSet().CuStack():
if pad.GetEffectiveShape(layer).Collide(p, radius):
return True
if pad.HasHole():
hole_gap = int(self.drill / 2) + int(self.pcb.GetDesignSettings().m_HoleToHoleMin)
if pad.GetEffectiveHoleShape().Collide(p, hole_gap):
return True
return False
def CheckViaPosition(self, p, zone_clearance=0):
"""Return REASON_OK if a via at p keeps clearance to all obstacles."""
if not self.obs_board_edge.Collide(p):
return self.REASON_BOARD_EDGE
reason = self.CheckViaInAllAreas(ViaObject(x=0, y=0, pos_x=p.x, pos_y=p.y), self.obs_areas)
if reason != self.REASON_OK:
return reason
base = max(self.clearance, zone_clearance)
radius = int(self.size / 2)
for poly in self.ref_shapes:
if poly.Collide(p, radius):
return self.REASON_REFERENCE
for bbox, item, kind in self.obstacles:
if not bbox.Contains(p):
continue
if kind == "pad" and self.IsSameNetPad(item):
if self.SameNetPadBlocksVia(item, p):
return self.REASON_PAD
elif kind == "pad":
clr = int(max(base, item.GetOwnClearance(UNDEFINED_LAYER, ""))) + radius
for layer in item.GetLayerSet().CuStack():
if item.GetEffectiveShape(layer).Collide(p, clr):
return self.REASON_PAD
if item.HasHole() and item.GetEffectiveHoleShape().Collide(p, clr):
return self.REASON_PAD
elif kind == "track":
clr = int(max(base, item.GetOwnClearance(UNDEFINED_LAYER, ""))) + radius
if item.GetEffectiveShape().Collide(p, clr):
return self.REASON_TRACK
else: # copper text or graphic shape
clr = int(base) + radius
try:
hit = item.GetEffectiveShape(item.GetLayer()).Collide(p, clr)
except Exception:
bbox_d = item.GetBoundingBox()
bbox_d.Inflate(clr)
hit = bbox_d.Contains(p)
if hit:
return self.REASON_DRAWING
return self.REASON_OK
def OutlineCandidates(self, outline, offset=0):
"""Via positions along a closed outline.
Straight horizontal / vertical parts get their vias on the via grid (grid origin +
n * pitch, same grid as the rectangular fill), so stitching along straight edges
lines up. Slanted parts and arcs are walked at a regular pitch along the length.
"""
step = int(max(self.step, self.size + self.clearance))
origin = self.grid_origin
tol = FromMM(0.005)
points = []
carry = step * offset # distance to the next via on slanted parts
for i in range(outline.SegmentCount()):
seg = outline.CSegment(i)
a, b = seg.A, seg.B
dx, dy = b.x - a.x, b.y - a.y
length = math.hypot(dx, dy)
if length == 0:
continue
horizontal = abs(dy) <= tol
vertical = abs(dx) <= tol
if horizontal or vertical:
start, delta, o = (a.x, dx, origin.x) if horizontal else (a.y, dy, origin.y)
lo, hi = min(start, start + delta), max(start, start + delta)
ts = []
k = int(math.ceil((lo - o) / float(step)))
while o + k * step <= hi:
ts.append((o + k * step - start) / float(delta))
k += 1
ts.sort()
for t in ts:
points.append(VECTOR2I(int(round(a.x + t * dx)), int(round(a.y + t * dy))))
carry = max(step - (1 - ts[-1]) * length, 0) if ts else max(carry - length, 0)
else:
d = carry
while d <= length:
points.append(VECTOR2I(int(round(a.x + dx * d / length)), int(round(a.y + dy * d / length))))
d += step
carry = d - length
return points
def AddViasAlongOutline(self, outline, outline_parent, all_vias, offset=0, zone_clearance=0, zone_fill=None):
via_placed = 0
for candidate in self.OutlineCandidates(outline, offset):
# With snap on, try the nearest snap grid points and take the first one that fits
first_reason = None
p = None
for q in self.SnapCandidates(candidate):
if not all(self.CheckViaDistance(q, via, outline_parent) for via in all_vias):
continue # regular spacing to other vias, not worth a marker
reason = self.CheckViaPosition(q, zone_clearance)
if reason == self.REASON_OK and not self.IsOnZoneFill(zone_fill, q):
reason = self.REASON_NO_FILL
if reason == self.REASON_OK:
p = q
break
if first_reason is None:
first_reason = (q, reason)
if p is None:
if first_reason is not None:
self.AddSkipped(first_reason[0], first_reason[1])
else:
via = self.AddVia(p, 0, 0)
all_vias.append(via)
via_placed += 1
return via_placed
def GetZoneOutlinePoly(self, zone):
"""Copy of the drawn zone outline (used when the zone is not filled)."""
# For KiCad >= 7, zone.Outline() may return an empty SHAPE_POLY_SET for inner-layer
# zones. We therefore try to build the polygon from points directly.
zone_poly = SHAPE_POLY_SET()
if KicadMajorVersion() < 7:
for layer_id in zone.GetLayerSet().CuStack():
z = zone.RawPolysList(layer_id)
if z.OutlineCount() > 0:
zone_poly.Append(z)
break
else:
src = zone.Outline()
if src is not None and src.OutlineCount() > 0:
# Manually copy each outline to avoid SWIG aliasing issues
for oi in range(src.OutlineCount()):
chain = src.Outline(oi)
zone_poly.NewOutline()
for pi in range(chain.PointCount()):
pt = chain.CPoint(pi)
zone_poly.Append(pt.x, pt.y)
for hi in range(src.HoleCount(oi)):
hchain = src.Hole(oi, hi)
zone_poly.NewHole(oi)
for pi in range(hchain.PointCount()):
pt = hchain.CPoint(pi)
zone_poly.Append(pt.x, pt.y, oi, zone_poly.HoleCount(oi) - 1)
return zone_poly
def ConcentricFillVias(self):
wxPrint("Calculate placement areas")
zones = [zone for zone in self.pcb.Zones() if zone.GetNetname() == self.netname]
wxPrint("Found {} zones with netname '{}'".format(len(zones), self.netname))
if not zones:
wxPrint("ERROR: No zones found with netname '{}'. Available zones:".format(self.netname))
for i, zone in enumerate(self.pcb.Zones()):
wxPrint(" Zone {}: netname='{}', layer={}".format(i, zone.GetNetname(), zone.GetLayerName()))
return
self.parent_area = zones[0]
# Snapshot of vias that existed BEFORE this run.
# Each zone resets to this baseline so that vias placed on OTHER zones
# do not block via placement on the current zone's perimeter.
existing_vias = [track for track in self.pcb.GetTracks() if (track.GetClass() == "PCB_VIA" and track.GetNetname() == self.netname)]
# Global list also grows so we avoid absolute overlaps between zones.
all_new_vias = []
self.PrepareObstacles()
self.grid_origin = self.GetGridOrig(self.pcb.ComputeBoundingBox(False))
wxPrint("Generating via placement")
off = 0
via_placed = 0
processed_any = False
# Process each GND zone independently to avoid cross-layer polygon merge artefacts.
# Each zone's outline is shrunk slightly and vias are placed along its boundary.
for zone in zones:
if self.only_selected_area and not zone.IsSelected():
continue
zone_clearance = zone.GetLocalClearance() or 0
zone_fill = self.GetZoneFill(zone)
# Vias follow the outer edge of the poured copper (one polygon per copper layer):
# the fill edge already keeps the clearances to the board edge and to anything
# touching the zone border. Clearance cut-outs inside the fill (around pads,
# tracks...) are ignored here - those are handled by CheckViaPosition. Holes drawn
# in the zone outline (cut-outs) are kept for the "Outline" / "Concentric" types.
# Without a fill fall back to the drawn zone outline.
outline_poly = self.GetZoneOutlinePoly(zone)
if zone_fill:
sources = []
for fill in zone_fill:
filled = SHAPE_POLY_SET(fill)
Unfracture(filled)
poly = SHAPE_POLY_SET()
for oi in range(filled.OutlineCount()):
poly.AddOutline(filled.Outline(oi))
if self.fill_type != self.FILL_TYPE_OUTLINE_NO_HOLES:
for oi in range(outline_poly.OutlineCount()):
for hi in range(outline_poly.HoleCount(oi)):
cutout = SHAPE_POLY_SET()
cutout.AddOutline(outline_poly.Hole(oi, hi))
poly.BooleanSubtract(cutout)
Unfracture(poly)
sources.append(poly)
# The fill edge already keeps the clearances: the via copper may be flush with it
inflate_amount = -int(0.5 * self.size + FromMM(0.001))
else:
sources = [outline_poly]
# Drawn zone outline: keep the via clearance from it
inflate_amount = -int(self.clearance + 0.5 * self.size)
for zone_poly in sources:
if zone_poly.OutlineCount() == 0:
if self.debug:
wxPrint(" -> Skipped (empty outline)")
continue
processed_any = True
# Shrink so the via fits inside the copper (or keeps clearance to the zone outline).
# Use ALLOW_ACUTE_CORNERS (no chamfering) to preserve complex polygon topology.
zone_poly.Inflate(inflate_amount, CORNER_STRATEGY_ALLOW_ACUTE_CORNERS, FromMM(0.01))
Unfracture(zone_poly) # Inflate may return holes joined to the outline by slits
if zone_poly.OutlineCount() == 0:
if self.debug:
wxPrint(" -> Skipped (empty after inflate)")
continue # Zone too small after shrink
# For this zone, only use pre-existing vias + already-placed-this-run vias
# for spacing checks – NOT vias placed on other zones' perimeters.
zone_vias = existing_vias + all_new_vias
# Place vias along outlines and holes of this zone
current_poly = zone_poly
while current_poly.OutlineCount() > 0:
for i in range(0, current_poly.OutlineCount()):
outline = current_poly.Outline(i)
n = self.AddViasAlongOutline(outline, outline, zone_vias, off, zone_clearance, zone_fill)
via_placed += n
if self.fill_type != self.FILL_TYPE_OUTLINE_NO_HOLES:
for k in range(0, current_poly.HoleCount(i)):
hole = current_poly.Hole(i, k)
n = self.AddViasAlongOutline(hole, outline, zone_vias, off, zone_clearance, zone_fill)
via_placed += n
# Concentric: shrink inward for next ring; Outline: single pass
if self.fill_type == self.FILL_TYPE_CONCENTRIC:
current_poly.Inflate(int(-max(self.step, self.size + self.clearance)), CORNER_STRATEGY_CHAMFER_ALL_CORNERS, FromMM(0.01))
Unfracture(current_poly)
off = 0.5 if off == 0 else 0
else:
current_poly = SHAPE_POLY_SET() # exit while loop
# Record vias placed for this zone to prevent global overlaps
all_new_vias = zone_vias[len(existing_vias):]
if not processed_any:
wxPrint("No areas to fill")
return
self.RefillBoardAreas()
self.ReportUnfilledZones()
self.DrawSkippedMarkers(self.pcb_group.GetName())
msg = "Done. {:d} vias placed. You have to refill all your pcb's areas/zones !!!".format(via_placed)
wxPrint(msg)
return via_placed
"""
Main function which does the via placement or deletion
"""
def CheckSelectedZone(self):
"""With "Only under selected Zone" a zone of the target net must be selected.
Tell the user why nothing would happen instead of silently placing 0 vias."""
selected = [zone for zone in self.pcb.Zones() if zone.IsSelected() and not zone.GetIsRuleArea()]
if any(zone.GetNetname() == self.netname for zone in selected):
return True
msg = "\"Only under selected Zone\" is checked, but no zone of net {} is selected.\n\n".format(self.netname)
if selected:
msg += "Selected zone(s) belong to other nets: {}.\n\n".format(
", ".join(sorted(set("{} ({})".format(zone.GetNetname() or "<no net>", zone.GetLayerName()) for zone in selected))))
msg += "Select a {} zone (click its outline) and run the plugin again, or uncheck the option.".format(self.netname)
try:
wx.MessageBox(msg, "Via Stitching", wx.OK | wx.ICON_WARNING)
except Exception:
print("WARNING: " + msg.replace("\n\n", " ")) # no GUI (command line use)
return False
def Run(self):
"""
Launch the process
"""
if self.delete_vias:
# Do not perform a real delete since exposed function in python are not safe for deletion
prefix = "ViaStitching {}".format(self.netname)
groups = sorted(g.GetName() for g in self.pcb.Groups()
if g.GetName() == prefix or g.GetName().startswith(prefix + " "))
listing = "\n".join(" " + name for name in groups) if groups else " (none found)"
wx.MessageBox(
"To delete vias:\n - select one of the generated vias to select its group\n - hit delete key\n - That's all !\n\nVia groups for net {}:\n{}".format(self.netname, listing), "Information"
)
"""
if self.pcb_group is not None:
all_vias = [track for track in self.pcb.GetTracks() if (track.GetClass() == "PCB_VIA" and track.GetNetname() == self.netname)]
for via in all_vias:
if via.GetParentGroup() is not None and via.GetParentGroup().GetName() == VIA_GROUP_NAME:
via.DeleteStructure()
"""
return # no need to run the rest of logic
if self.only_selected_area and not self.CheckSelectedZone():
return
if self.refill_zones:
wxPrint("Refilling all zones...")
ZONE_FILLER(self.pcb).Fill(self.pcb.Zones())
self.area_fill_cache = {}
VIA_GROUP_NAME = self.GetGroupName()
if self.debug:
print("Enumerate groups")
for i in self.pcb.Groups():
if i.GetName() == VIA_GROUP_NAME:
if self.debug:
print("Group {} Found !".format(VIA_GROUP_NAME))
self.pcb_group = i
if self.pcb_group is None:
self.pcb_group = PCB_GROUP(None)
self.pcb_group.SetName(VIA_GROUP_NAME)
self.pcb.Add(self.pcb_group)
if self.fill_type == self.FILL_TYPE_CONCENTRIC or self.fill_type == self.FILL_TYPE_OUTLINE or self.fill_type == self.FILL_TYPE_OUTLINE_NO_HOLES:
self.ConcentricFillVias()
if self.filename:
self.pcb.Save(self.filename)
return
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
target_tracks = self.pcb.GetTracks()
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
lboard = self.pcb.ComputeBoundingBox(False)
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
origin = self.GetGridOrig(lboard)
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
# Create an initial rectangle: all is set to "REASON_NO_SIGNAL"
# get a margin to avoid out of range
l_clearance = self.clearance + self.size
if l_clearance < self.step:
l_clearance = self.step
if self.snap:
# Pitch a multiple of the snap grid => all grid points lie on the snap grid
l_clearance = int(math.ceil(l_clearance / float(self.snap))) * self.snap
# Calculate grid extents relative to origin (support negative offsets)
board_min_x = lboard.GetPosition().x
board_min_y = lboard.GetPosition().y
board_max_x = board_min_x + lboard.GetWidth()
board_max_y = board_min_y + lboard.GetHeight()
x_min = int(floor((board_min_x - origin.x - l_clearance) / l_clearance))
x_max = int(ceil((board_max_x - origin.x + l_clearance) / l_clearance))
y_min = int(floor((board_min_y - origin.y - l_clearance) / l_clearance))
y_max = int(ceil((board_max_y - origin.y + l_clearance) / l_clearance))
x_limit = x_max - x_min + 1
y_limit = y_max - y_min + 1
if self.debug:
print(
"l_clearance : {}; step : {}; size: {}; clearance: {}; x/y_limit ({} {}),board size : {} {}".format(
l_clearance, self.step, self.size, self.clearance, x_limit, y_limit, lboard.GetWidth(), lboard.GetHeight()
)
)
rectangle = [[self.REASON_NO_SIGNAL] * y_limit for i in xrange(x_limit)]
if self.debug:
print("\nInitial rectangle:")
self.PrintRect(rectangle)
all_pads = self.pcb.GetPads()
all_tracks = self.pcb.GetTracks()
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
try:
all_drawings = filter(lambda x: x.GetClass() == "PTEXT" and self.pcb.GetLayerID(x.GetLayerName()) in (F_Cu, B_Cu), self.pcb.DrawingsList())
except:
all_drawings = filter(lambda x: x.GetClass() == "PTEXT" and self.pcb.GetLayerID(x.GetLayerName()) in (F_Cu, B_Cu), self.pcb.Drawings())
# wxPrint("exception on missing BOARD.DrawingsList")
all_areas = [self.pcb.GetArea(i) for i in xrange(self.pcb.GetAreaCount())]
# target_areas = filter(lambda x: (x.GetNetname().upper() == self.netname), all_areas) # KeepOuts are filtered because they have no name
# KeepOuts are filtered because they have no name
target_areas = filter(lambda x: (x.GetNetname() == self.netname), all_areas)
board_edge = self.GetBoardEdge()
via_list = [] # Create a list of existing vias => faster than scanning through the whole rectangle
no_fill_cells = [] # inside a target area outline, but not on its poured copper
max_target_area_clearance = 0
# Enum all target areas (Search possible positions for vias on the target net)
for area in target_areas:
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
wxPrint("Processing Target Area: %s, LayerName: %s..." % (area.GetNetname(), area.GetLayerName()))
if self.parent_area is None:
self.parent_area = area
is_selected_area = area.IsSelected()
area_clearance = area.GetLocalClearance()
if max_target_area_clearance < area_clearance:
max_target_area_clearance = area_clearance
if (not self.only_selected_area) or (self.only_selected_area and is_selected_area): # All areas or only the selected area
area_fill = self.GetZoneFill(area)
# Check every possible point in the virtual coordinate system
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
for x in xrange(len(rectangle)):
if x % 10 == 0:
if self.debug:
print("%s: Line %u (x=%s;%s)" % (time.time(), currentframe().f_lineno, x, len(rectangle)))
for y in xrange(len(rectangle[0])):
# No other "target area" found yet => go on with processing
if rectangle[x][y] == self.REASON_NO_SIGNAL:
current_x = origin.x + ((x + (x_min)) * l_clearance) # Center of the via
current_y = origin.y + ((y + (y_min)) * l_clearance)
test_result = True # Start with true, if a check fails, it is set to false
# Offset is half the size of the via plus the clearance of the via or the area
offset = 0 # Use an exact zone match
point_to_test = VECTOR2I(int(current_x), int(current_y))
hit_test_area = False
if KicadMajorVersion() < 7:
# below 7.0.0
hit_test_area = area.HitTestFilledArea(area.GetLayer(), VECTOR2I(point_to_test), int(offset)) # Collides with a filled area
else:
# 7.0.0 and above
for i in range(0, area.Outline().OutlineCount()):
area_outline = area.Outline().Outline(i)
hit_test_area = hit_test_area or area_outline.PointInside(point_to_test)
# Collides with an edge/corner
hit_test_edge = area.HitTestForEdge(point_to_test, int(max(area_clearance, offset)))
# test_result only remains true if the via is inside an area and not on an edge
test_result = hit_test_area and not hit_test_edge
test_result = test_result and board_edge.Collide(point_to_test) # check if inside board outline
if test_result and not self.IsOnZoneFill(area_fill, point_to_test): # on poured copper
test_result = False
no_fill_cells.append((x, y, point_to_test))
if test_result:
# Create a via object with information about the via and place it in the rectangle
via_obj = ViaObject(x=x, y=y, pos_x=current_x, pos_y=current_y)
rectangle[x][y] = via_obj
via_list.append(via_obj)
if self.debug:
print("\nPost target areas:")
self.PrintRect(rectangle)
# Check every candidate against pads, tracks, existing vias, copper drawings, keepouts
# and the board edge with the exact copper shapes (round via, real track/pad outline).
wxPrint("Checking clearances of {} candidate positions...".format(len(via_list)))
self.PrepareObstacles(include_net_vias=True)
for via in via_list:
reason = self.CheckViaPosition(VECTOR2I(int(via.PosX), int(via.PosY)), max_target_area_clearance)
if reason != self.REASON_OK:
rectangle[via.X][via.Y] = reason
if self.debug:
print("\nPost obstacles:")
self.PrintRect(rectangle)
# Candidate positions rejected by an obstacle (cells outside any target area are not marked)
candidates = set()
for via in via_list:
candidates.add((via.X, via.Y))
if not isinstance(rectangle[via.X][via.Y], ViaObject):
self.AddSkipped(VECTOR2I(int(via.PosX), int(via.PosY)), rectangle[via.X][via.Y])
for x, y, p in no_fill_cells:
if (x, y) not in candidates:
self.AddSkipped(p, self.REASON_NO_FILL)
clear_distance = 0
if self.step != 0.0 and self.fill_type == self.FILL_TYPE_STAR:
# How much "via steps" should be removed around a via (round up)
clear_distance = int((self.step + l_clearance) / l_clearance)
via_placed = 0
for x in xrange(len(rectangle)):
for y in xrange(len(rectangle[0])):
if isinstance(rectangle[x][y], ViaObject):
if clear_distance:
self.ClearViaInStepSize(rectangle, x, y, clear_distance)
via = rectangle[x][y]
ran_x = 0
ran_y = 0
if self.random:
max_offset = max(self.step - (self.clearance + self.size), 0) / 2.0
ran_x = (random.random() * max_offset) - (max_offset / 2.0)
ran_y = (random.random() * max_offset) - (max_offset / 2.0)
if self.snap:
# Round towards zero so the offset stays within max_offset
ran_x = int(ran_x / self.snap) * self.snap
ran_y = int(ran_y / self.snap) * self.snap
if self.CheckViaPosition(VECTOR2I(int(via.PosX + ran_x), int(via.PosY + ran_y)), max_target_area_clearance) != self.REASON_OK:
ran_x = ran_y = 0 # the shifted position violates a clearance => keep the checked one
self.AddVia(VECTOR2I(int(via.PosX + ran_x), int(via.PosY + ran_y)), via.X, via.Y)
via_placed += 1
if self.debug:
print("\nFinal result:")
self.PrintRect(rectangle)
if self.debug:
print("%s: Line %u" % (time.time(), currentframe().f_lineno))
self.RefillBoardAreas()
self.ReportUnfilledZones()
self.DrawSkippedMarkers(self.pcb_group.GetName())
if self.filename:
self.pcb.Save(self.filename)
msg = "Done. {:d} vias placed. You have to refill all your pcb's areas/zones !!!".format(via_placed)
wxPrint(msg)
if __name__ == "__main__":
if len(sys.argv) < 2:
print("Usage: %s <KiCad pcb filename>" % sys.argv[0])
else:
import sys
FillArea(sys.argv[1]).SetDebug().Run()