Tabs not created when frame is further than board spacing when panelizing different boards.

[Strat00s]

I don't know if this is a bug or if I am just doing something wrong, but I have a problem that I don't know how to fix.

I have 2 boards. Remote controller and receiver. They are of different dimensions. I want to panelize them onto a single board to save money. But since they have different sizes, it seems that tabs don't want to be created when the panel edge is further than the board spacing (3mm). I have made a few tests to show it (individual board, the same board panelized, and both boards panelized).
panels.zip

In the unaligned_remote example, you can see that even when the boards have the same dimension, if I move one of them, it also does not create the tabs on the sides that are further from the frame.

So my question is, is this a bug in kikit (probably not) or some configuration in the script I am using (probably, as I don't understand the majority of it)?

Here is the Python script (majority is not mine, I found it in some issue where people were trying to panelize different boards):

Spoiler warning

from kikit.panelize import *
from kikit import panelize
from kikit.units import mm, deg
from kikit import panelize_ui_impl as ki
from pcbnewTransition.pcbnew import LoadBoard, VECTOR2I
import math


"""
Custom classes for simple board alignment
"""
class Origin(Enum):
    Center = 0
    TopLeft = 1
    TopRight = 2
    BottomLeft = 3
    BottomRight = 4

class Side(Enum):
    Left = 0
    Bottom = 1
    Right = 2
    Top = 3
    Center = 5

class Board:
    def __init__(self, path, specs = {"type": "auto", "tolerance": "1"}):
        self.path = path
        self.source_area = ki.readSourceArea(specs, LoadBoard(path))
        self.width = self.source_area.GetWidth()
        self.height = self.source_area.GetHeight()
        self.center = self.source_area.GetCenter()
        self.angle = 0

    def setCenter(self, center: VECTOR2I):
        self.center = center

    def rotate(self, angle: int):
        self.angle = angle

    def move(self, x: int, y: int):
        """Move board by x and y left/right and down/up (negative = left, down)

        Args:
            x (int): move board by this much on x axis
            y (int): move board by this much on y axis
        """
        self.center = self.center + VECTOR2I(x, y)

    @property
    def left(self):
        return (self.center - int(self.width / 2)).x
    @property
    def right(self):
        return (self.center + int(self.width / 2)).x
    @property
    def top(self):
        return (self.center - int(self.height / 2)).y
    @property
    def bottom(self):
        return (self.center + int(self.height / 2)).y
    

    def setLeft(self, x: int):
        self.setCenter(VECTOR2I(x + int(self.width / 2), self.center.y))

    def setRight(self, x: int):
        self.setCenter(VECTOR2I(x - int(self.width / 2), self.center.y))

    def setTop(self, y: int):
        self.setCenter(VECTOR2I(self.center.x, y + int(self.height / 2)))

    def setBottom(self, y: int):
        self.setCenter(VECTOR2I(self.center.x, y - int(self.height / 2)))


class Panel:
    def __init__(self, board_spacing, frame_width, backbone_width, origin: Origin = Origin.BottomLeft) -> None:
        self.boards = list()
        self.origin = origin
        self.left = 0
        self.right = 0
        self.top = 0
        self.bottom = 0

        self.board_spacing = board_spacing
        self.frame_width = frame_width
        self.backbone_width = backbone_width

    @property
    def width(self):
        return abs(self.left - self.right)
    @property
    def height(self):
        return abs(self.bottom - self.top)
    
    @property
    def spacing(self):
        return self.board_spacing * 2 + self.backbone_width
    
    def recalculateSize(self):
        left = math.inf
        right = -math.inf
        top = math.inf
        bottom = -math.inf
        for s_board in self.boards:
            if (s_board.left < left):
                left = s_board.left
            if (s_board.right > right):
                right = s_board.right
            if (s_board.top < top):
                top = s_board.top
            if (s_board.bottom > bottom):
                bottom = s_board.bottom


    def addBoard(self, board: Board, position: VECTOR2I, angle: int):
        """Add board to the panel
        Args:
            board (Board): board to be added
            position (VECTOR2I): position of the new board relative to panel origin (x=0, y=0; left top corner) and center of this board
            rotation (int): rotation of the board in the panel
        """
        board.setCenter(position)
        #TODO rotation
        self.boards.append(board)
        self.recalculateSize();


    def addNextTo(self, ref_board: Board, board: Board, side: Side, align: Side, angle: int = 0):
        """Add board next to another board

        Args:
            ref_board (Board): reference board already contained in the panel
            board (Board): new board to be added
            side (Side): to which side to add the new board
            align (Side): to which side to align the new board
            angle (int, optional): new board rotation. Defaults to 0.

        Raises:
            Exception: Raises an exception when an invalid side is provided
        """

        board.setCenter(ref_board.center)

        if(side == Side.Left):
            if (align == Side.Top):
                board.setTop(ref_board.top)
            if (align == Side.Bottom):
                board.setBottom(ref_board.bottom)

            board.setRight(ref_board.left - self.spacing)

        elif(side == Side.Right):
            if (align == Side.Top):
                board.setTop(ref_board.top)
            if (align == Side.Bottom):
                board.setBottom(ref_board.bottom)

            board.setLeft(ref_board.right + self.spacing)

        elif(side == Side.Bottom):
            if (align == Side.Left):
                board.setLeft(ref_board.left)

            if (align == Side.Right):
                board.setRight(ref_board.right)
            
            board.setTop(ref_board.bottom + self.spacing)

        elif(side == Side.Top):
            if (align == Side.Left):
                board.setLeft(ref_board.left)

            if (align == Side.Right):
                board.setRight(ref_board.right)

            board.setBottom(ref_board.top - self.spacing)
        else:
            raise Exception("Invalid side provided")
        
        self.boards.append(board)
        self.recalculateSize();


    def panelize(self, panel: Panel):
        for board in self.boards:
            panel.appendBoard(board.path, board.center, tolerance=fromMm(100), inheritDrc=False)



"""
Start of the actual script
"""

backbone_size = 3 * mm
board_spacing = 3 * mm

layout = {
    "type"      : "grid",
    "hbackbone" : backbone_size, 
    "vbackbone" : backbone_size,
    "space"     : board_spacing
}
framing = {
    "type"   : "tightframe", #only rail on top and bottom
    "cuts"   : "both",
    "space"  : "3mm", # space en board and rail
    "width"  : "5mm", # Width of the rail
    "fillet" : True
}
cuts = {
    "type"    : "mousebites",
    "drill"   : "0.6mm",
    "spacing" : "1mm",
    "offset"  : "-0.4mm",
}
tabs = {
    "type"   : "annotation" 
}
tooling = {
    "type"    : "3hole",
    "hoffset" : "3mm",
    "voffset" : "3mm",
    "size"    : "3mm"
}
post = {
    "type"            : "auto",
    "reconstructarcs" : True,
    "millradius"      : "1mm",
}
#fiducials = {
#    "type"    : "3fid",
#    "hoffset" : "3.85mm",
#    "voffset" : "3.85mm"
#}


## Obtain full config by combining above with default
preset = ki.obtainPreset([], layout=layout, tabs=tabs, cuts=cuts, framing=framing, tooling=tooling, post=post)


# define paths to boards
receiver_path = r"path/to/board"
remote_path     = r"path/to/board"

#create panel
panel = panelize.Panel(r"path/to/panel")
panel.setGridOrigin(VECTOR2I(0, 0))

#position boards and panelize them
my_panel = Panel(3 * mm, 5 * mm, 3 * mm)
board1 = Board(receiver_path)
board2 = Board(remote_path)

my_panel.addBoard(board1, VECTOR2I(0, 0), 0)
my_panel.addNextTo(board1, board2, Side.Right, Side.Center)
my_panel.panelize(panel)



### No clue what the rest does, but it somewhat works, so there might be a problem here

substrates = panel.substrates[len(panel.substrates):] # Collect set of newly added boards

# Prepare frame and partition
framingSubstrates = ki.dummyFramingSubstrate(panel.substrates, preset)
panel.buildPartitionLineFromBB(framingSubstrates)
backboneCuts = ki.buildBackBone(preset["layout"], panel, substrates, preset)


######## --------------------- Continue doPanelization
tabCuts = ki.buildTabs(preset, panel, substrates, framingSubstrates)
frameCuts = ki.buildFraming(preset, panel)


ki.buildTooling(preset, panel)
ki.buildFiducials(preset, panel)
for textSection in ["text", "text2", "text3", "text4"]:
    ki.buildText(preset[textSection], panel)
ki.buildPostprocessing(preset["post"], panel)

ki.makeTabCuts(preset, panel, tabCuts)
ki.makeOtherCuts(preset, panel, chain(backboneCuts, frameCuts))


ki.buildCopperfill(preset["copperfill"], panel)

ki.setStackup(preset["source"], panel)
ki.setPageSize(preset["page"], panel, LoadBoard(remote_path))
ki.positionPanel(preset["page"], panel)
ki.runUserScript(preset["post"], panel)

ki.buildDebugAnnotation(preset["debug"], panel)

panel.save(reconstructArcs=preset["post"]["reconstructarcs"], refillAllZones=preset["post"]["refillzones"])

[yaqwsx]

I haven't tested the code; nevertheless - when you encounter missing tabs, first check if the partition line corresponds to what you expect (you can render it via panel.debugRenderPartitionLines()). If the partition line is not between PCBs, no tabs will be created there (see https://yaqwsx.github.io/KiKit/v1.3/panelization/tabs/)

[Strat00s]

You are correct, the lines are not being generated when the boards are offset:

Missaligned

Aligned

The link you gave me gave frankly zero information about what might be the problem other than the partition lines are being generated wrongly. But I don't know why.

I guess the problem is somewhere here:

substrates = panel.substrates
# Prepare frame and partition
framingSubstrates = ki.dummyFramingSubstrate(substrates, preset)
panel.buildPartitionLineFromBB(framingSubstrates)

But I don't know what the problem is. dummyFramingSubstrate method is not mentioned anywhere. I guess it creates the frame around the boards as a substrate and returns both the frame and board substrates. But why is the buildPartitionLineFromBB working properly only when the boards are aligned is beyond me 🤷

Also when the boards are not aligned, I get this warning from shapely:

...\Python39\site-packages\shapely\set_operations.py:133: RuntimeWarning: invalid value encountered in intersection
  return lib.intersection(a, b, **kwargs)

[yaqwsx]

Also when the boards are not aligned, I get this warning from shapely:

Please, downgrade to Shapely 1.8; you are using Shapely 2.0 which is not compatible (we enforce this in the upstream version already).

dummyFramingSubstrate generates "fake" substrates on places where the frame should be.

It is possible there is a bug in the partition line-building algorithm. To be honest; it wasn't tested much on such cases. Nevertheless, you don't have to use buildPartitionLineFromBB and you can supply your own partition line (if you have other mean to generate it) as a work-around.

[Strat00s]

Progress.

Spoiler warning

Partition lines seem to work.

The 3D viewer is saying, that the board outline is malformed. But DRC does not report any errors/warnings about the board outline. When I remove a section from the board outline, it then does say that the outline is malformed. This is how the gerber looks, so I gues it's just a bug.

Spoiler warning

Now I just need to generate backbones and I got a pretty usable script for (multi) board panelization. Thanks.

[putyn]

hi @Strat00s - would it be possible to share your panelization script? I am trying to do something very similar with multiple boards of different size.

[Strat00s]

hi @Strat00s - would it be possible to share your panelization script? I am trying to do something very similar with multiple boards of different size.

Sure. But it has been so long that I have no idea how to use it (just rename it to .py).
panelize.txt

All I know is that you have to run it from the Kicad environment. I had this script for it:

set cwd=%cd%
cd "C:\Program Files\KiCad\7.0"
.\bin\kicad-cmd.bat
cd %cwd%