# -*- coding: utf-8 -*- # Copyright (c) 2023 Salvador E. Tropea # Copyright (c) 2023 Instituto Nacional de Tecnología Industrial # License: GPL-3.0 # Project: KiBot (formerly KiPlot) # Some code is adapted from: https://github.com/30350n/pcb2blender from dataclasses import dataclass, field import json import os import re import struct from typing import List from pcbnew import B_Paste, F_Paste, PCB_TEXT_T, ToMM from .gs import GS from .misc import (MOD_THROUGH_HOLE, MOD_SMD, UI_VIRTUAL, W_UNKPCB3DTXT, W_NOPCB3DBR, W_NOPCB3DTL, W_BADPCB3DTXT, W_UNKPCB3DNAME, W_BADPCB3DSTK) from .optionable import Optionable from .out_base import VariantOptions from .macros import macros, document, output_class # noqa: F401 from . import log logger = log.get_logger() @dataclass class StackedBoard: """ Name and position of a stacked board """ name: str offset: List[float] @dataclass class BoardDef: """ A sub-PCBs, its bounds and stacked boards """ name: str bounds: List[float] stacked_boards: List[StackedBoard] = field(default_factory=list) def sanitized(name): """ Replace character that aren't alphabetic by _ """ return re.sub(r"[\W]+", "_", name) class PCB2Blender_ToolsOptions(VariantOptions): def __init__(self): with document: self.output = GS.def_global_output """ *Filename for the output (%i=pcb2blender, %x=pcb3d) """ self.board_bounds_create = True """ Create the file that informs the size of the used PCB area. This is the bounding box reported by KiCad for the PCB edge with 1 mm of margin """ self.board_bounds_dir = 'layers' """ Sub-directory where the bounds file is stored """ self.board_bounds_file = 'bounds' """ Name of the bounds file """ self.pads_info_create = True """ Create the files containing the PCB pads information """ self.pads_info_dir = 'pads' """ Sub-directory where the pads info files are stored """ self.stackup_create = False """ Create a JSON file containing the board stackup """ self.stackup_file = 'board.yaml' """ Name for the stackup file """ self.stackup_dir = '.' """ Directory for the stackup file """ self.sub_boards_create = True """ Extract sub-PCBs and their Z axis position """ self.sub_boards_dir = 'boards' """ Directory for the boards definitions """ self.sub_boards_bounds_file = 'bounds' """ File name for the sub-PCBs bounds """ self.sub_boards_stacked_prefix = 'stacked_' """ Prefix used for the stack files """ self.show_components = Optionable """ *[list(string)|string=all] [none,all] List of components to include in the pads list, can be also a string for `none` or `all`. The default is `all` """ super().__init__() self._expand_id = 'pcb2blender' self._expand_ext = 'pcb3d' def config(self, parent): super().config(parent) # List of components self._show_all_components = False if isinstance(self.show_components, str): if self.show_components == 'all': self._show_all_components = True self.show_components = [] elif isinstance(self.show_components, type): # Default is all self._show_all_components = True else: # a list self.show_components = self.solve_kf_filters(self.show_components) def do_board_bounds(self, dir_name): if not self.board_bounds_create: return dir_name = os.path.join(dir_name, self.board_bounds_dir) os.makedirs(dir_name, exist_ok=True) fname = os.path.join(dir_name, self.board_bounds_file) # PCB bounding box using the PCB edge, converted to mm bounds = tuple(map(GS.to_mm, GS.get_rect_for(GS.board.ComputeBoundingBox(aBoardEdgesOnly=True)))) # Apply 1 mm margin (x, y, w, h) bounds = (bounds[0]-1, bounds[1]-1, bounds[2]+2, bounds[3]+2) with open(fname, 'wb') as f: # Four big endian float numbers f.write(struct.pack("!ffff", *bounds)) @staticmethod def is_not_virtual_ki6(m): return bool(m.GetAttributes() & (MOD_THROUGH_HOLE | MOD_SMD)) @staticmethod def is_not_virtual_ki5(m): return bool(m.GetAttributes() != UI_VIRTUAL) def do_pads_info(self, dir_name): if not self.pads_info_create: return dir_name = os.path.join(dir_name, self.pads_info_dir) os.makedirs(dir_name, exist_ok=True) is_not_virtual = self.is_not_virtual_ki5 if GS.ki5 else self.is_not_virtual_ki6 for i, footprint in enumerate(GS.get_modules()): has_model = len(footprint.Models()) > 0 is_tht_or_smd = is_not_virtual(footprint) value = footprint.GetValue() value = value.replace('/', '_') reference = footprint.GetReference() for j, pad in enumerate(footprint.Pads()): name = os.path.join(dir_name, sanitized("{}_{}_{}_{}".format(value, reference, i, j))) is_flipped = pad.IsFlipped() has_paste = pad.IsOnLayer(B_Paste if is_flipped else F_Paste) with open(name, 'wb') as f: f.write(struct.pack("!ff????BBffffBff", *map(GS.to_mm, pad.GetPosition()), is_flipped, has_model, is_tht_or_smd, has_paste, pad.GetAttribute(), pad.GetShape(), *map(GS.to_mm, pad.GetSize()), GS.get_pad_orientation_in_radians(pad), pad.GetRoundRectRadiusRatio(), pad.GetDrillShape(), *map(GS.to_mm, pad.GetDrillSize()))) def do_stackup(self, dir_name): if not self.stackup_create or (not GS.global_pcb_finish and not GS.stackup): return dir_name = os.path.join(dir_name, self.stackup_dir) os.makedirs(dir_name, exist_ok=True) fname = os.path.join(dir_name, self.stackup_file) # Create the board_info board_info = {} if GS.global_pcb_finish: board_info['copper_finish'] = GS.global_pcb_finish if GS.stackup: layers_parsed = [] for la in GS.stackup: parsed_layer = {'name': la.name, 'type': la.type} if la.color is not None: parsed_layer['color'] = la.color if la.thickness is not None: parsed_layer['thickness'] = la.thickness/1000 layers_parsed.append(parsed_layer) board_info['stackup'] = layers_parsed data = json.dumps(board_info, indent=3) logger.debug('Stackup: '+str(data)) with open(fname, 'wt') as f: f.write(data) def get_boarddefs(self): """ Extract the sub-PCBs and their positions using texts. This is the original mechanism and the code is from the plug-in. """ boarddefs = {} tls = {} # Top Left coordinates brs = {} # Bottom right coordinates stacks = {} # PCB stack relations # Collect the information from the texts for drawing in GS.board.GetDrawings(): if drawing.Type() != PCB_TEXT_T: continue text = drawing.GetText() # Only process text starting with PCB3D_ if not text.startswith("PCB3D_"): continue # Store the position of the text according to the declared type pos = tuple(map(ToMM, drawing.GetPosition())) if text.startswith("PCB3D_TL_"): tls.setdefault(text[9:], pos) elif text.startswith("PCB3D_BR_"): brs.setdefault(text[9:], pos) elif text.startswith("PCB3D_STACK_"): stacks.setdefault(text, pos) else: logger.warning(W_UNKPCB3DTXT+'Unknown PCB3D mark: `{}`'.format(text)) # Separate the PCBs for name in tls.copy(): # Look for the Bottom Right corner if name in brs: # Remove both tl_pos = tls.pop(name) br_pos = brs.pop(name) # Add a definition with the bbox (x, y, w, h) boarddef = BoardDef(sanitized(name), (tl_pos[0], tl_pos[1], br_pos[0]-tl_pos[0], br_pos[1]-tl_pos[1])) boarddefs[boarddef.name] = boarddef else: logger.warning(W_NOPCB3DBR+'PCB3D_TL_{} without corresponding PCB3D_BR_{}'.format(name, name)) for name in brs.keys(): logger.warning(W_NOPCB3DTL+'PCB3D_BR_{} without corresponding PCB3D_TL_{}'.format(name, name)) # Solve the stack (relative positions) for stack_str in stacks.copy(): # Extract the parameters try: other, onto, target, z_offset = stack_str[12:].split("_") z_offset = float(z_offset) except ValueError: onto = '' if onto != "ONTO": logger.warning(W_BADPCB3DTXT+'Malformed stack marker `{}` must be PCB3D_STACK_other_ONTO_target_zoffset'. format(stack_str)) continue # Check the names and sanity check other_name = sanitized(other) # The name of the current board if other_name not in boarddefs and other_name != 'FPNL': logger.warning(W_UNKPCB3DNAME+'Unknown `{}` in `{}` valid names are: {}'. format(other_name, stack_str, list(boarddefs))) continue target_name = sanitized(target) # The name of the board below if target_name not in boarddefs: logger.warning(W_UNKPCB3DNAME+'Unknown `{}` in `{}` valid names are: {}'. format(target_name, stack_str, list(boarddefs))) continue if target_name == other_name: logger.warning(W_BADPCB3DSTK+"Can't stack a board onto itself ({})".format(stack_str)) continue # Add this board to the target stack_pos = stacks.pop(stack_str) target_pos = boarddefs[target_name].bounds[:2] stacked = StackedBoard(other_name, (stack_pos[0]-target_pos[0], stack_pos[1]-target_pos[1], z_offset)) boarddefs[target_name].stacked_boards.append(stacked) return boarddefs def do_sub_boards(self, dir_name): if not self.sub_boards_create: return dir_name = os.path.join(dir_name, self.sub_boards_dir) os.makedirs(dir_name, exist_ok=True) boarddefs = self.get_boarddefs() logger.debug('Collected board definitions: '+str(boarddefs)) for boarddef in boarddefs.values(): subdir = os.path.join(dir_name, boarddef.name) os.makedirs(subdir, exist_ok=True) with open(os.path.join(subdir, self.sub_boards_bounds_file), 'wb') as f: f.write(struct.pack("!ffff", *boarddef.bounds)) for stacked in boarddef.stacked_boards: with open(os.path.join(subdir, self.sub_boards_stacked_prefix+stacked.name), 'wb') as f: f.write(struct.pack("!fff", *stacked.offset)) def run(self, output): super().run(output) dir_name = os.path.dirname(output) self.apply_show_components() self.filter_pcb_components(do_3D=True) self.do_board_bounds(dir_name) self.do_pads_info(dir_name) self.do_stackup(dir_name) self.do_sub_boards(dir_name) self.unfilter_pcb_components(do_3D=True) self.undo_show_components() def get_targets(self, out_dir): files = [] if self.board_bounds_create: files.append(os.path.join(out_dir, self.board_bounds_dir, self.board_bounds_file)) if self.pads_info_create: dir_name = os.path.join(out_dir, self.pads_info_dir) for i, footprint in enumerate(GS.get_modules()): value = footprint.GetValue() reference = footprint.GetReference() for j in range(len(footprint.Pads())): files.append(os.path.join(dir_name, sanitized("{}_{}_{}_{}".format(value, reference, i, j)))) if self.stackup_create and (GS.global_pcb_finish or GS.stackup): files.append(os.path.join(out_dir, self.stackup_dir, self.stackup_file)) if self.sub_boards_create: dir_name = os.path.join(out_dir, self.sub_boards_dir) boarddefs = self.get_boarddefs() for boarddef in boarddefs.values(): subdir = os.path.join(dir_name, boarddef.name) files.append(os.path.join(subdir, self.sub_boards_bounds_file)) for stacked in boarddef.stacked_boards: files.append(os.path.join(subdir, self.sub_boards_stacked_prefix+stacked.name)) else: files.append(dir_name) return files @output_class class PCB2Blender_Tools(BaseOutput): # noqa: F821 """ PCB2Blender Tools A bunch of tools used to generate PCB3D files used to export PCBs to Blender. Blender is the most important free software 3D render package. The PCB3D file format is used by the PCB2Blender project (https://github.com/30350n/pcb2blender) to import KiCad PCBs in Blender. You need to install a Blender plug-in to load PCB3D files. The tools in this output are used by internal templates used to generate PCB3D files. """ def __init__(self): super().__init__() self._category = 'PCB/3D/Auxiliar' with document: self.options = PCB2Blender_ToolsOptions """ *[dict] Options for the `pcb2blender_tools` output """