import math from copy import copy from itertools import zip_longest from dataclasses import dataclass, field, KW_ONLY from ..utils import LengthUnit, MM, rotate_point from ..layers import LayerStack from ..graphic_objects import Line, Arc, Flash from ..apertures import Aperture, CircleAperture, RectangleAperture, ExcellonTool def sgn(x): return -1 if x < 0 else 1 class Board: def __init__(self): self.objects = set() def to_layer_stack(self, layer_stack): if layer_stack is None: layer_stack = LayerStack() for obj in self.objects: obj.render(stack) @dataclass class Positioned: x: float y: float _: KW_ONLY rotation: float = 0.0 unit: LengthUnit = MM parent: object = None @property def abs_pos(self, dx, dy, da): x, y = rotate_point(self.x, self.y, da) if self.parent is None: px, py, pa = dx, dy, 0 else: px, py, pa = self.parent.abs_pos(dx, dy, da) return x+px, y+py, self.rotation+da+pa @dataclass class Pad(Positioned): pass @dataclass class SMDPad(Pad): copper_aperture: Aperture mask_aperture: Aperture paste_aperture: Aperture silk_features: list side: str = 'top' def to_layer_stack(self, layer_stack): x, y, rotation = self.abs_pos stack[self.side, 'copper'].objects.append(Flash(x, y, self.copper_aperture.rotated(rotation), unit=self.unit)) stack[self.side, 'mask' ].objects.append(Flash(x, y, self.mask_aperture.rotated(rotation), unit=self.unit)) stack[self.side, 'paste' ].objects.append(Flash(x, y, self.paste_aperture.rotated(rotation), unit=self.unit)) stack[self.side, 'silk' ].objects.extend([copy(feature).rotate(rotation).offset(x, y, self.unit) for feature in self.silk_features]) def flip(self): self.side = 'top' if self.side == 'bottom' else 'top' class THTPad(Pad): drill_dia: float pad_top: SMDPad pad_bottom: SMDPad = None aperture_inner: Aperture = None plated: bool = True def __post_init__(self): if self.pad_bottom is None: self.pad_bottom = copy(self.pad_top) self.pad_bottom.flip() self.pad_top.parent = self.pad_bottom.parent = self if (self.pad_top.side, self.pad_bottom.side) != ('top', 'bottom'): raise ValueError(f'The top and bottom pads must have side set to top and bottom, respectively. Currently, the top pad side is set to {self.pad_top.side} and the bottom pad side to {self.pad_bottom.side}.') def to_layer_stack(self, layer_stack, x, y, rotation): x, y, rotation = self.abs_pos self.top_pad.to_layer_stack(layer_stack) self.bottom_pad.to_layer_stack(layer_stack) for (side, use), layer in layer_stack.inner_layers: layer.objects.append(Flash(x, y, self.aperture_inner.rotated(rotation), unit=self.unit)) hole = Flash(self.x, self.y, ExcellonTool(self.drill_dia, plated=self.plated, unit=self.unit), unit=self.unit) if self.plated: layer_stack.drill_pth.objects.append(hole) else: layer_stack.drill_npth.objects.append(hole) @dataclass class Via(Positioned): diameter: float hole: float def to_layer_stack(self, layer_stack): x, y, rotation = self.abs_pos aperture = CircleAperture(diameter=self.diameter, unit=self.unit) tool = ExcellonTool(diameter=self.hole, unit=self.unit) for (side, use), layer in layer_stack.copper_layers: layer.objects.append(Flash(x, y, aperture, unit=self.unit)) layer_stack.drill_pth.objects.append(Flash(x, y, tool, unit=self.unit)) @dataclass class Trace: width: float start: object = None end: object = None side: str = 'top' waypoints: [(float, float)] = field(default_factory=list) style: str = 'direct' orientation: [str] = tuple() # 'top' or 'bottom' roundover: float = 0 unit: LengthUnit = MM parent: object = None DIRECT = 'direct' OBLIQUE = 'oblique' ORTHO = 'ortho' CW = 'cw' CCW = 'ccw' def _route(self, p1, p2, orientation): x1, y1 = p1 x2, y2 = p2 dx = x2-x1 dy = y2-y1 yield p1 if self.style == 'direct' or \ math.isclose(x1, x2, abs_tol=1e-6) or math.isclose(y1, y2, abs_tol=1e-6) or \ (self.style == 'oblique' and math.isclose(dx, dy, abs_tol=1e-6)): yield p2 return p = (abs(dy) > abs(dx)) == ((dx >= 0) == (dy >= 0)) if self.style == 'oblique': if p == (orientation == 'cw'): if abs(dy) > abs(dx): yield (0, sgn(dy)*(abs(dy)-abs(dx))) else: yield (sgn(dx)*(abs(dx)-abs(dy)), 0) else: if abs(dy) > abs(dx): yield (dx, sgn(dy)*abs(dx)) else: yield (sgn(dx)*abs(dy), dy) else: # self.style == 'ortho' pass #if p == (orientation == 'cw'): #else: yield p2 def to_layer_stack(self, layer_stack, x, y, rotation): start, end = self.start, self.end if not isinstance(start, tuple): start = start.abs_pos if not isinstance(end, tuple): end = end.abs_pos points = [start, *self.waypoints, end] aperture = CircleAperture(diameter=self.width, unit=self.unit) for p1, p2, orientation in zip_longest(points[:-1], points[1:], self.orientation): layer_stack[self.side, 'copper'].extend(self._route(p1, p2, orientation, aperture)) if __name__ == '__main__': from ..utils import setup_svg, Tag from ..newstroke import Newstroke font = Newstroke() tags = [] for n in range(0, 8*6): theta = 2*math.pi / (8*6) * n dx, dy = math.cos(theta), math.sin(theta) tr = Trace(0.1, style='oblique') points_cw = list(tr._route((0, 0), (dx, dy), 'cw')) points_ccw = list(tr._route((0, 0), (dx, dy), 'ccw')) pd = lambda points: f'M {points[0][0]}, {points[0][1]} ' + ' '.join(f'L {x}, {y}' for x, y in points[1:]) strokes = list(font.render(f'α={n/(8*6)*360}', size=0.2)) xs = [x for st in strokes for x, _y in st] ys = [y for st in strokes for _x, y in st] min_x, min_y, max_x, max_y = min(xs), min(ys), max(xs), max(ys) xf = f'translate({n//6*1.1 + 0.1} {n%6*1.3 + 0.3}) scale(0.5 0.5) translate(1 1)' txf = f'{xf} translate(0 -1.2) translate({-(max_x-min_x)/2} {-max_y})' tags.append(Tag('circle', cx='0', cy='0', r='1', fill='none', stroke='black', opacity='0.5', stroke_width='0.05', transform=xf)) tags.append(Tag('path', fill='none', stroke='red', opacity='0.5', stroke_width='0.05', stroke_linecap='round', transform=xf, d=pd(points_cw))) tags.append(Tag('path', fill='none', stroke='blue', opacity='0.5', stroke_width='0.05', stroke_linecap='round', transform=xf, d=pd(points_ccw))) tags.append(Tag('path', fill='none', stroke='black', opacity='0.5', stroke_width='0.02', stroke_linejoin='round', stroke_linecap='round', transform=txf, d=' '.join(pd(points) for points in strokes))) print(setup_svg([Tag('g', tags, transform='scale(20 20)')], [(0, 0), (20*10*1.1 + 0.1, 20*10*1.3 + 0.1)]))