Merge remote-tracking branch 'upstream/master'

Author: set-soft

.github/workflows/test-kikit.yml

@@ -41,13 +41,13 @@ jobs:
       - name: Build PCM package
         run: make pcm
       - name: Upload kikit-pcm package artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: kikit-pcm
           path: build/pcm-kikit
           retention-days: 7
       - name: Upload kikit-lib-pcm package artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: kikit-lib-pcm
           path: build/pcm-kikit-lib

kikit/actionPlugins/panelize.py

@@ -1,3 +1,5 @@
+import time
+import traceback
 from kikit.defs import EDA_TEXT_HJUSTIFY_T, EDA_TEXT_VJUSTIFY_T
 from pcbnewTransition import pcbnew, isV8
 from kikit.panelize_ui_impl import loadPresetChain, obtainPreset, mergePresets
@@ -23,6 +25,7 @@ def run(self):
             super().run()
         except Exception as e:
             self.exception = e
+            self.traceback = traceback.format_exc()
 
 def replaceExt(file, ext):
     return os.path.splitext(file)[0] + ext
@@ -46,41 +49,61 @@ def presetDifferential(source, target):
     return result
 
 
-def transplateBoard(source, target):
+def transplateBoard(source, target, update=lambda x: None):
+    CLEAR_MSG = "Clearing the old board in UI"
+    RENDER_MSG = "Rendering the new board in UI"
     items = chain(
         list(target.GetDrawings()),
         list(target.GetFootprints()),
         list(target.GetTracks()),
         list(target.Zones()))
     for x in items:
+        update(CLEAR_MSG)
         target.Remove(x)
 
     for x in list(target.GetNetInfo().NetsByNetcode().values()):
+        update(CLEAR_MSG)
         target.Remove(x)
 
+    update(RENDER_MSG)
+    target.SetProperties(source.GetProperties())
+    update(RENDER_MSG)
+    target.SetPageSettings(source.GetPageSettings())
+    update(RENDER_MSG)
+    target.SetTitleBlock(source.GetTitleBlock())
+    if not isV8():
+        update(RENDER_MSG)
+        target.SetZoneSettings(source.GetZoneSettings())
+
     for x in source.GetDrawings():
+        update(RENDER_MSG)
         appendItem(target, x)
     for x in source.GetFootprints():
+        update(RENDER_MSG)
         appendItem(target, x)
     for x in source.GetTracks():
+        update(RENDER_MSG)
         appendItem(target, x)
     for x in source.Zones():
+        update(RENDER_MSG)
         appendItem(target, x)
 
     for n in [n for _, n in source.GetNetInfo().NetsByNetcode().items()]:
+        update(RENDER_MSG)
         target.Add(n)
 
+    update(RENDER_MSG)
     d = target.GetDesignSettings()
     d.CloneFrom(source.GetDesignSettings())
 
-    target.SetProperties(source.GetProperties())
-    target.SetPageSettings(source.GetPageSettings())
-    target.SetTitleBlock(source.GetTitleBlock())
-    if not isV8():
-        target.SetZoneSettings(source.GetZoneSettings())
+
 
 def drawTemporaryNotification(board, sourceFilename):
-    bbox = findBoardBoundingBox(board)
+    try:
+        bbox = findBoardBoundingBox(board)
+    except Exception:
+        # If the output is empty...
+        bbox = pcbnew.BOX2I(pcbnew.VECTOR2I(0, 0), pcbnew.VECTOR2I(0, 0))
 
     text = pcbnew.PCB_TEXT(board)
     text.SetLayer(pcbnew.Margin)
@@ -278,6 +301,8 @@ def __init__(self, parent=None, board=None, preset=None):
 
         self.board = board
         self.dirty = False
+        self.progressDlg = None
+        self.lastPulse = time.time()
 
         topMostBoxSizer = wx.BoxSizer(wx.VERTICAL)
 
@@ -424,14 +449,49 @@ def OnResize(self):
     def OnClose(self, event):
         self.EndModal(0)
 
+    def _updatePanelizationProgress(self, message, force=False):
+        self.phase = message
+        now = time.time()
+
+        if now - self.lastPulse > 1 / 50 or force:
+            self.lastPulse = now
+            if self.progressDlg is not None:
+                self.progressDlg.Pulse(newmsg=f"Running KiKit: {self.phase}")
+            if force:
+                self.progressDlg.Refresh()
+            wx.GetApp().Yield()
+
+    def _panelizationRoutine(self, tempdir, input, panelFile, preset):
+        panelize_ui.doPanelization(input, panelFile, preset)
+
+        # KiCAD 6 does something strange here, so we will load an empty
+        # file if we read it directly, but we can always make a copy and
+        # read that. Copying a file can be lengthy, so we will copy the
+        # file in a thread.
+        copyPanelName = os.path.join(tempdir, "panel-copy.kicad_pcb")
+        shutil.copy(panelFile, copyPanelName)
+        try:
+            shutil.copy(replaceExt(panelFile, ".kicad_pro"), replaceExt(copyPanelName, "kicad_pro"))
+            shutil.copy(replaceExt(panelFile, ".kicad_prl"), replaceExt(copyPanelName, "kicad_prl"))
+        except FileNotFoundError:
+            # We don't care if we didn't manage to copy the files
+            pass
+        self.temporary_panel = pcbnew.LoadBoard(copyPanelName)
+
+    def _pulseWhilePcbnewRefresh(self):
+        while not self.refreshDone:
+            time.sleep(1/50)
+            self._updatePanelizationProgress("Pcbnew is updating the preview")
+
+
     def OnPanelize(self, event):
         with tempfile.TemporaryDirectory(prefix="kikit") as dirname:
             try:
-                progressDlg = wx.ProgressDialog(
-                    "Running kikit", "Running kikit, please wait",
+                self.progressDlg = wx.ProgressDialog(
+                    "Running kikit", f"Running KiKit:",
                     parent=self)
-                progressDlg.Show()
-                progressDlg.Pulse()
+                self._updatePanelizationProgress("Starting up")
+                self.progressDlg.Show()
 
                 args = self.kikitArgs()
                 preset = obtainPreset([], **args)
@@ -458,43 +518,38 @@ def OnPanelize(self, event):
                     dlg.ShowModal()
                     dlg.Destroy()
                     return
-                thread = ExceptionThread(target=panelize_ui.doPanelization,
-                                         args=(input, panelFile, preset))
+
+                # We run as much as possible in a separate thread to not stall
+                # the UI...
+                thread = ExceptionThread(target=self._panelizationRoutine,
+                                         args=(dirname, input, panelFile, preset))
                 thread.daemon = True
                 thread.start()
                 while True:
-                    progressDlg.Pulse()
-                    thread.join(timeout=1)
+                    self._updatePanelizationProgress("Panelization")
+                    thread.join(timeout=1 / 50)
                     if not thread.is_alive():
                         break
-                if thread.exception and not isinstance(thread.exception, NonFatalErrors):
+                if thread.exception:
                     raise thread.exception
-                # KiCAD 6 does something strange here, so we will load
-                # an empty file if we read it directly, but we can always make
-                # a copy and read that:
-                copyPanelName = os.path.join(dirname, "panel-copy.kicad_pcb")
-                shutil.copy(panelFile, copyPanelName)
-                try:
-                    shutil.copy(replaceExt(panelFile, ".kicad_pro"), replaceExt(copyPanelName, "kicad_pro"))
-                    shutil.copy(replaceExt(panelFile, ".kicad_prl"), replaceExt(copyPanelName, "kicad_prl"))
-                except FileNotFoundError:
-                    # We don't care if we didn't manage to copy the files
-                    pass
-                panel = pcbnew.LoadBoard(copyPanelName)
-                transplateBoard(panel, self.board)
+
+                # ...however, transplate board and pcbnew.Refresh has to happen
+                # in the main thread
+                transplateBoard(self.temporary_panel, self.board, self._updatePanelizationProgress)
                 drawTemporaryNotification(self.board, panelFile)
+                self._updatePanelizationProgress("Pcbnew will now refresh panel, the UI might freeze", force=True)
+                pcbnew.Refresh()
+                self._updatePanelizationProgress("Done", force=True)
                 self.dirty = True
-                if thread.exception:
-                    raise thread.exception
             except Exception as e:
                 dlg = wx.MessageDialog(
                     None, f"Cannot perform:\n\n{e}", "Error", wx.OK)
                 dlg.ShowModal()
                 dlg.Destroy()
             finally:
-                progressDlg.Hide()
-                progressDlg.Destroy()
-        pcbnew.Refresh()
+                self.progressDlg.Hide()
+                self.progressDlg.Destroy()
+                self.progressDlg = None
 
     def populateInitialValue(self, initialPreset=None):
         preset = loadPresetChain([":default"])

kikit/common.py

@@ -75,6 +75,8 @@ def collectEdges(board, layerId, sourceArea=None):
             continue
         if isinstance(edge, pcbnew.PCB_DIMENSION_BASE):
             continue
+        if isinstance(edge, pcbnew.PCB_TEXT):
+            continue
         if not sourceArea or fitsIn(edge.GetBoundingBox(), sourceArea):
             edges.append(edge)
     return edges

kikit/drc.py

@@ -61,6 +61,8 @@ class DrcExclusion:
     objects: List[pcbnew.BOARD_ITEM] = field(default_factory=list)
 
     def eqRepr(self) -> Tuple[str, Union[Tuple[str, str], str]]:
+        if len(self.objects) == 0:
+            return (self.type, ())
         if len(self.objects) == 1:
             objRepr = str(self.objects[0].m_Uuid.AsString()) if isinstance(self.objects[0], pcbnew.BOARD_ITEM) else self.objects[0]
             return (self.type, objRepr)

kikit/export.py

@@ -184,6 +184,7 @@ def pasteDxfExport(board, plotDir):
     popt.SetScale(1)
     popt.SetDXFPlotUnits(DXF_UNITS_MILLIMETERS)
     popt.SetDXFPlotPolygonMode(False)
+    popt.SetDrillMarksType(DRILL_MARKS_NO_DRILL_SHAPE)
 
     plot_plan = [
         # name, id, comment

kikit/panelize.py

@@ -52,6 +52,9 @@ def __init__(self, errors: List[Tuple[KiPoint, str]]) -> None:
         for pos, err in errors:
             message += f"- Location [{toMm(pos[0])}, {toMm(pos[1])}]\n"
             message += textwrap.indent(err, "  ")
+            if not message.endswith("\n"):
+                message += "\n"
+        message = message[:-1]
         super().__init__(message)
 
 def identity(x):
@@ -348,7 +351,7 @@ def isBoardEdge(edge):
 
     The rule is: all drawings on Edge.Cuts layer are edges.
     """
-    return isinstance(edge, pcbnew.PCB_SHAPE) and edge.GetLayerName() == "Edge.Cuts"
+    return isinstance(edge, pcbnew.PCB_SHAPE) and edge.GetLayer() == pcbnew.Edge_Cuts
 
 def tabSpacing(width, count):
     """
@@ -556,6 +559,7 @@ def save(self, reconstructArcs: bool=False, refillAllZones: bool=False,
         for e in boardsEdges:
             e.SetWidth(edgeWidth)
 
+        self._validateVCuts()
         vcuts = self._renderVCutH() + self._renderVCutV()
         keepouts = []
         for cut, clearanceArea in vcuts:
@@ -615,7 +619,10 @@ def save(self, reconstructArcs: bool=False, refillAllZones: bool=False,
             if zName.startswith("KIKIT_zone_"):
                 zonesToRefill.append(zone)
                 zone.SetZoneName(originalZoneNames[zName])
-        fillerTool.Fill(zonesToRefill)
+        if len(zonesToRefill) > 0:
+            # Even if there are no zones to refill, the refill algorithm takes
+            # non-trivial time to compute, hence, skip it.
+            fillerTool.Fill(zonesToRefill)
 
         fillBoard.Save(self.filename)
         self._adjustPageSize()
@@ -1201,6 +1208,32 @@ def _setVCutLabelStyle(self, label, origin, position):
         label.SetTextSize(toKiCADPoint((self.vCutSettings.textSize, self.vCutSettings.textSize)))
         label.SetHorizJustify(EDA_TEXT_HJUSTIFY_T.GR_TEXT_HJUSTIFY_LEFT)
 
+    def _validateVCuts(self, tolerance=fromMm(1)):
+        """
+        Validates V-cuts for cuttitng the PCBs. Renders the violations into the
+        PCB as a side effect.
+        """
+        if len(self.hVCuts) == 0 and len(self.vVCuts) == 0:
+            return
+
+        collisionPolygons = shapely.ops.unary_union([x.substrates.buffer(-tolerance) for x in self.substrates])
+        minx, miny, maxx, maxy = self.panelBBox()
+
+        lines = \
+            [LineString([(minx, y), (maxx, y)]) for y in self.hVCuts] + \
+            [LineString([(x, miny), (x, maxy)]) for x in self.vVCuts]
+
+        error_message = "V-Cut cuts the original PCBs. You should:\n"
+        error_message += "- either reconsider your tab placement,\n"
+        error_message += "- or use different cut type – e.g., mouse bites."
+        for line in lines:
+            for geom in listGeometries(collisionPolygons.intersection(line)):
+                if geom.is_empty:
+                    continue
+                annotationPos = sorted(geom.coords, key=lambda p: -p[1])[0]
+                self._renderLines([geom], Layer.Margin)
+                self.reportError(toKiCADPoint(annotationPos), error_message)
+
     def _renderVCutV(self):
         """ return list of PCB_SHAPE V-Cuts """
         bBox = self.boardSubstrate.boundingBox()
@@ -1508,7 +1541,7 @@ def makeVCuts(self, cuts, boundCurves=False, offset=fromMm(0)):
                 message += "- your vertical or horizontal PCB edges are not precisely vertical or horizontal.\n"
                 message += "Modify the design or accept curve approximation via V-cuts."
                 self._renderLines([cut], Layer.Margin)
-                self.reportError(toKiCADPoint(cut[0]), message)
+                self.reportError(toKiCADPoint(cut.coords[0]), message)
                 continue
             cut = cut.simplify(1).parallel_offset(offset, "left")
             start = roundPoint(cut.coords[0])

kikit/substrate.py

@@ -51,6 +51,10 @@ def getStartPoint(geom):
         point = geom.GetStart() + pcbnew.VECTOR2I(geom.GetRadius(), 0)
     elif geom.GetShape() == STROKE_T.S_RECT:
         point = geom.GetStart()
+    elif geom.GetShape() == STROKE_T.S_POLYGON:
+        # Polygons don't use the properties for start point, look into the
+        # geometry
+        point = geom.GetPolyShape().Outline(0).CPoints()[0]
     else:
         point = geom.GetStart()
     return point
@@ -62,6 +66,14 @@ def getEndPoint(geom):
     elif geom.GetShape() == STROKE_T.S_RECT:
         # Rectangle is closed, so it starts at the same point as it ends
         point = geom.GetStart()
+    elif geom.GetShape() == STROKE_T.S_POLYGON:
+        # Polygons don't use the properties for start point, look into the
+        # geometry
+        outline = geom.GetPolyShape().Outline(0)
+        if outline.IsClosed():
+            point = outline.CPoints()[0]
+        else:
+            point = outline.CPoints()[-1]
     else:
         if hasattr(geom, 'IsClosed'):
             point = geom.GetStart() if geom.IsClosed() else geom.GetEnd()