Initial placement generation for svg-pcb backend (#413)

Changes to the experimental svg-pcb backend. Adds a better initial
placement, instead of all components stacked, tries to pack components
with a fixed aspect ratio, recursively by group bottom-up. Also now
generates the entire svg-pcb code block instead of just snippets.

Also adds svgpcb backend to unit test outputs.

Changes the footprint data json to store area and bounding box. Moves
the FootprintDataTable into electronics_model, where the svg-pcb backend
and the footprint data generation is now.

Author: ducky64

edg/abstract_parts/SelectorArea.py

@@ -1,29 +1,8 @@
-from typing import Optional
-
-from pydantic import RootModel
-import os
-
 from ..electronics_model import *
 from .PartsTable import PartsTableRow
 from .PartsTablePart import PartsTableFootprintFilter, PartsTablePart
 
 
-class FootprintJson(RootModel):  # script relpath imports are weird so this is duplicated here
-  root: dict[str, float]  # footprint name -> area
-
-
-class FootprintAreaTable:
-  _table: Optional[FootprintJson] = None
-
-  @classmethod
-  def area_of(cls, footprint: str) -> float:
-    """Returns the area of a footprint, returning infinity if unavailable"""
-    if cls._table is None:
-      with open(os.path.join(os.path.dirname(__file__), "resources", "kicad_footprints.json"), 'r') as f:
-        cls._table = FootprintJson.model_validate_json(f.read())
-    return cls._table.root.get(footprint) or float('inf')
-
-
 @abstract_block
 class SelectorArea(PartsTablePart):
   """A base mixin that defines a footprint_area range specification for blocks that automatically select parts.
@@ -44,6 +23,10 @@ def __init__(self, *args, footprint_area: RangeLike = RangeExpr.ALL, **kwargs):
     super().__init__(*args, **kwargs)
     self.footprint_area = self.ArgParameter(footprint_area)
 
+  @classmethod
+  def _footprint_area(cls, footprint_name: str) -> float:
+    return FootprintDataTable.area_of(footprint_name)
+
 
 @non_library
 class PartsTableAreaSelector(PartsTableFootprintFilter, SelectorArea):
@@ -54,4 +37,9 @@ def __init__(self, *args, **kwargs):
 
   def _row_filter(self, row: PartsTableRow) -> bool:
     return super()._row_filter(row) and \
-      (Range.exact(FootprintAreaTable.area_of(row[self.KICAD_FOOTPRINT])).fuzzy_in(self.get(self.footprint_area)))
+      (Range.exact(FootprintDataTable.area_of(row[self.KICAD_FOOTPRINT])).fuzzy_in(self.get(self.footprint_area)))
+
+  @classmethod
+  def _row_area(cls, row: PartsTableRow) -> float:
+    """Returns the area of the part in the row, for use in sorting."""
+    return FootprintDataTable.area_of(row[cls.KICAD_FOOTPRINT])

edg/abstract_parts/__init__.py

@@ -22,7 +22,7 @@
 from .Categories import MultipackDevice
 
 from .ESeriesUtil import ESeriesUtil
-from .SelectorArea import SelectorArea, PartsTableAreaSelector, FootprintAreaTable
+from .SelectorArea import SelectorArea, PartsTableAreaSelector
 
 from .AbstractDevices import Battery
 from .AbstractConnector import BananaJack, BananaSafetyJack, RfConnector, RfConnectorTestPoint, RfConnectorAntenna,\

edg/abstract_parts/resources/kicad_footprints.json

@@ -0,0 +1,42 @@
+from typing import Optional, List, Tuple
+
+from pydantic import RootModel, BaseModel
+import os
+
+
+class FootprintData(BaseModel):
+  area: float
+  bbox: Tuple[float, float, float, float]  # [x_min, y_min, x_max, y_max]
+
+
+class FootprintJson(RootModel):  # script relpath imports are weird so this is duplicated here
+  root: dict[str, FootprintData]  # footprint name -> data
+
+
+class FootprintDataTable:
+  _table: Optional[FootprintJson] = None
+
+  @classmethod
+  def _get_table(cls) -> FootprintJson:
+    if cls._table is None:
+      with open(os.path.join(os.path.dirname(__file__), "resources", "kicad_footprints.json"), 'r') as f:
+        cls._table = FootprintJson.model_validate_json(f.read())
+    return cls._table
+
+  @classmethod
+  def area_of(cls, footprint: str) -> float:
+    """Returns the area of a footprint, returning infinity if unavailable"""
+    elt = cls._get_table().root.get(footprint)
+    if elt is None:
+      return float('inf')
+    else:
+      return elt.area
+
+  @classmethod
+  def bbox_of(cls, footprint: str) -> Optional[Tuple[float, float, float, float]]:
+    """Returns the bounding box of a footprint, returning None if unavailable"""
+    elt = cls._get_table().root.get(footprint)
+    if elt is None:
+      return None
+    else:
+      return elt.bbox

edg/electronics_model/KicadFootprintData.py

@@ -1,13 +1,116 @@
 import importlib
 import inspect
-from typing import List, Tuple, NamedTuple, Dict
+import math
+from typing import List, Tuple, NamedTuple, Dict, Union, Set
 
 from .. import edgir
+from .KicadFootprintData import FootprintDataTable
 from ..core import *
 from .NetlistGenerator import NetlistTransform, NetBlock, Netlist
 from .SvgPcbTemplateBlock import SvgPcbTemplateBlock
 
 
+class PlacedBlock(NamedTuple):
+    """A placement of a hierarchical block, including the coordinates of its immediate elements.
+    Elements are placed in local space, with (0, 0) as the origin and elements moved as a group.
+    Elements are indexed by name."""
+    elts: Dict[str, Tuple[Union['PlacedBlock', TransformUtil.Path], Tuple[float, float]]]  # name -> elt, (x, y)
+    height: float
+    width: float
+
+
+def arrange_netlist(netlist: Netlist) -> PlacedBlock:
+    FOOTPRINT_BORDER = 1  # mm
+    BLOCK_BORDER = 2  # mm
+
+    # create list of blocks by path
+    block_subblocks: Dict[Tuple[str, ...], Set[str]] = {}
+    block_footprints: Dict[Tuple[str, ...], List[NetBlock]] = {}
+
+    # for here, we only group one level deep
+    for block in netlist.blocks:
+        containing_path = block.full_path.blocks[0:min(len(block.full_path.blocks) - 1, 1)]
+        block_footprints.setdefault(containing_path, []).append(block)
+        for i in range(len(containing_path)):
+            block_subblocks.setdefault(tuple(containing_path[:i]), set()).add(containing_path[i])
+
+    def arrange_hierarchy(root: Tuple[str, ...]) -> PlacedBlock:
+        """Recursively arranges the immediate components of a hierarchy, treating each element
+        as a bounding box rectangle, and trying to maintain some aspect ratio."""
+        # TODO don't count borders as part of a block's width / height
+        ASPECT_RATIO = 16 / 9
+
+        sub_placed: List[Tuple[str, float, float, Union[PlacedBlock, NetBlock]]] = []  # (name, width, height, PlacedBlock or footprint)
+        for subblock in block_subblocks.get(root, set()):
+            subplaced = arrange_hierarchy(root + (subblock,))
+            sub_placed.append((subblock, subplaced.width + BLOCK_BORDER, subplaced.height + BLOCK_BORDER, subplaced))
+
+        for footprint in block_footprints.get(root, []):
+            bbox = FootprintDataTable.bbox_of(footprint.footprint) or (1, 1, 1, 1)
+            width = bbox[2] - bbox[0] + FOOTPRINT_BORDER
+            height = bbox[3] - bbox[1] + FOOTPRINT_BORDER
+            # use refdes as key so it's globally unique, for when this is run with blocks grouped together
+            sub_placed.append((footprint.refdes, width, height, footprint))
+
+        total_area = sum(width * height for _, width, height, _ in sub_placed)
+        max_width = math.sqrt(total_area * ASPECT_RATIO)
+
+        x_max = 0.0
+        y_max = 0.0
+        # track the y limits and y position of the prior elements
+        x_stack: List[Tuple[float, float, float]] = []  # [(x pos of next, y pos, y limit)]
+        elts: Dict[str, Tuple[Union[PlacedBlock, TransformUtil.Path], Tuple[float, float]]] = {}
+        for name, width, height, entry in sorted(sub_placed, key=lambda x: -x[2]):  # by height
+            if not x_stack:  # only on first component
+                next_y = 0.0
+            else:
+                next_y = x_stack[-1][1]  # y position of the next element
+
+            while True:  # advance rows as needed
+                if not x_stack:
+                    break
+                if x_stack[-1][0] + width > max_width:  # out of X space, advance a row
+                    _, _, next_y = x_stack.pop()
+                    continue
+                if next_y + height > x_stack[-1][2]:  # out of Y space, advance a row
+                    _, _, next_y = x_stack.pop()
+                    continue
+                break
+
+            if not x_stack:
+                next_x = 0.0
+            else:
+                next_x = x_stack[-1][0]
+
+            if isinstance(entry, PlacedBlock):  # assumed (0, 0) at top left
+                elts[name] = (entry, (next_x, next_y))
+            elif isinstance(entry, NetBlock):  # account for footprint origin, flipping y-axis
+                bbox = FootprintDataTable.bbox_of(entry.footprint) or (0, 0, 0, 0)
+                elts[name] = (entry.full_path, (next_x - bbox[0], next_y + bbox[3]))
+            x_stack.append((next_x + width, next_y, next_y + height))
+            x_max = max(x_max, next_x + width)
+            y_max = max(y_max, next_y + height)
+        return PlacedBlock(
+            elts=elts, width=x_max, height=y_max
+        )
+    return arrange_hierarchy(())
+
+
+def flatten_packed_block(block: PlacedBlock) -> Dict[TransformUtil.Path, Tuple[float, float]]:
+    """Flatten a packed_block to a dict of individual components."""
+    flattened: Dict[TransformUtil.Path, Tuple[float, float]] = {}
+    def walk_group(block: PlacedBlock, x_pos: float, y_pos: float) -> None:
+        for _, (elt, (elt_x, elt_y)) in block.elts.items():
+            if isinstance(elt, PlacedBlock):
+                walk_group(elt, x_pos + elt_x, y_pos + elt_y)
+            elif isinstance(elt, TransformUtil.Path):
+                flattened[elt] = (x_pos + elt_x, y_pos + elt_y)
+            else:
+                raise TypeError
+    walk_group(block, 0, 0)
+    return flattened
+
+
 class SvgPcbGeneratedBlock(NamedTuple):
     path: TransformUtil.Path
     fn_name: str
@@ -45,26 +148,15 @@ def run(self) -> List[SvgPcbGeneratedBlock]:
         return self._svgpcb_blocks
 
 
-class SvgPcbCompilerResult(NamedTuple):
-    functions: list[str]
-    instantiations: list[str]
-
-
 class SvgPcbBackend(BaseBackend):
     def run(self, design: CompiledDesign, args: Dict[str, str] = {}) -> List[Tuple[edgir.LocalPath, str]]:
         netlist = NetlistTransform(design).run()
         result = self._generate(design, netlist)
-        if result.functions:  # pack layout templates into a file
-            svgpcb_str = ""
-            svgpcb_str += "\n".join(result.functions)
-            svgpcb_str += "\n" + "\n".join(result.instantiations)
-            return [
-                (edgir.LocalPath(), svgpcb_str)
-            ]
-        else:
-            return []  # no layout templates, ignore
+        return [
+            (edgir.LocalPath(), result)
+        ]
 
-    def _generate(self, design: CompiledDesign, netlist: Netlist) -> SvgPcbCompilerResult:
+    def _generate(self, design: CompiledDesign, netlist: Netlist) -> str:
         """Generates SVBPCB fragments as a structured result"""
         def block_matches_prefixes(block: NetBlock, prefixes: List[Tuple[str, ...]]):
             for prefix in prefixes:
@@ -80,21 +172,70 @@ def filter_blocks_by_pathname(blocks: List[NetBlock], exclude_prefixes: List[Tup
         svgpcb_block_prefixes = [block.path.to_tuple() for block in svgpcb_blocks]
         netlist = NetlistTransform(design).run()
         other_blocks = filter_blocks_by_pathname(netlist.blocks, svgpcb_block_prefixes)
+        arranged_blocks = arrange_netlist(netlist)
+        pos_dict = flatten_packed_block(arranged_blocks)
 
         svgpcb_block_instantiations = [
             f"const {SvgPcbTemplateBlock._svgpcb_pathname_to_svgpcb(block.path)} = {block.fn_name}(pt(0, 0))"
             for block in svgpcb_blocks
         ]
-        other_block_instantiations = [
-            f"""\
+
+        # note, dimensions in inches
+        other_block_instantiations = []
+        for block in other_blocks:
+            x_pos, y_pos = pos_dict.get(block.full_path, (0, 0))  # in mm, need to convert to in below
+            block_code = f"""\
 const {SvgPcbTemplateBlock._svgpcb_pathname_to_svgpcb(block.full_path)} = board.add({SvgPcbTemplateBlock._svgpcb_footprint_to_svgpcb(block.footprint)}, {{
-  translate: pt(0, 0), rotate: 0,
+  translate: pt({x_pos/25.4:.3f}, {y_pos/25.4:.3f}), rotate: 0,
   id: '{SvgPcbTemplateBlock._svgpcb_pathname_to_svgpcb(block.full_path)}'
 }})"""
-            for block in other_blocks
-        ]
-
-        return SvgPcbCompilerResult(
-            [block.svgpcb_code for block in svgpcb_blocks],
-            svgpcb_block_instantiations + other_block_instantiations
-        )
+            other_block_instantiations.append(block_code)
+
+        NEWLINE = '\n'
+        full_code = f"""\
+const board = new PCB();
+
+{NEWLINE.join(svgpcb_block_instantiations + other_block_instantiations)}
+
+const limit0 = pt(-{2/25.4}, -{2/25.4});
+const limit1 = pt({arranged_blocks.width/25.4}, {arranged_blocks.height/25.4});
+const xMin = Math.min(limit0[0], limit1[0]);
+const xMax = Math.max(limit0[0], limit1[0]);
+const yMin = Math.min(limit0[1], limit1[1]);
+const yMax = Math.max(limit0[1], limit1[1]);
+
+const filletRadius = 0.1;
+const outline = path(
+  [(xMin+xMax/2), yMax],
+  ["fillet", filletRadius, [xMax, yMax]],
+  ["fillet", filletRadius, [xMax, yMin]],
+  ["fillet", filletRadius, [xMin, yMin]],
+  ["fillet", filletRadius, [xMin, yMax]],
+  [(xMin+xMax/2), yMax],
+);
+board.addShape("outline", outline);
+
+renderPCB({{
+  pcb: board,
+  layerColors: {{
+    "F.Paste": "#000000ff",
+    "F.Mask": "#000000ff",
+    "B.Mask": "#000000ff",
+    "componentLabels": "#00e5e5e5",
+    "outline": "#002d00ff",
+    "padLabels": "#ffff99e5",
+    "B.Cu": "#ef4e4eff",
+    "F.Cu": "#ff8c00cc",
+  }},
+  limits: {{
+    x: [xMin, xMax],
+    y: [yMin, yMax]
+  }},
+  background: "#00000000",
+  mmPerUnit: 25.4
+}})
+
+{NEWLINE.join([block.svgpcb_code for block in svgpcb_blocks])}
+"""
+
+        return full_code

edg/electronics_model/SvgPcbBackend.py

@@ -41,6 +41,7 @@
 # for power users to build custom blackbox handlers
 from .KiCadSchematicParser import KiCadSymbol, KiCadLibSymbol
 from .KiCadSchematicBlock import KiCadBlackbox, KiCadBlackboxBase
+from .KicadFootprintData import FootprintDataTable
 
 from .RefdesRefinementPass import RefdesRefinementPass
 from .NetlistBackend import NetlistBackend