From 4ed83580963669e29305c45b104b78a22ef3e86c Mon Sep 17 00:00:00 2001 From: jaseg Date: Sun, 23 Jan 2022 14:41:59 +0100 Subject: Fix a whole bunch of SVG export bugs --- gerbonara/gerber/aperture_macros/parse.py | 4 +- gerbonara/gerber/aperture_macros/primitive.py | 24 +++--- gerbonara/gerber/apertures.py | 47 +++++------ gerbonara/gerber/cam.py | 20 +++-- gerbonara/gerber/graphic_objects.py | 10 ++- gerbonara/gerber/graphic_primitives.py | 46 ++++++----- gerbonara/gerber/rs274x.py | 108 +++++++++++++++++--------- gerbonara/gerber/tests/image_support.py | 4 + gerbonara/gerber/tests/test_rs274x.py | 6 +- gerbonara/gerber/utils.py | 2 +- 10 files changed, 162 insertions(+), 109 deletions(-) diff --git a/gerbonara/gerber/aperture_macros/parse.py b/gerbonara/gerber/aperture_macros/parse.py index 2126e0f..3a6f6e1 100644 --- a/gerbonara/gerber/aperture_macros/parse.py +++ b/gerbonara/gerber/aperture_macros/parse.py @@ -119,7 +119,7 @@ class ApertureMacro: primitive_defs = [ prim.to_gerber(unit) for prim in self.primitives ] return '*\n'.join(comments + variable_defs + primitive_defs) - def to_graphic_primitives(self, offset, rotation, parameters : [float], unit=None): + def to_graphic_primitives(self, offset, rotation, parameters : [float], unit=None, polarity_dark=True): variables = dict(self.variables) for number, value in enumerate(parameters, start=1): if number in variables: @@ -127,7 +127,7 @@ class ApertureMacro: variables[number] = value for primitive in self.primitives: - yield from primitive.to_graphic_primitives(offset, rotation, variables, unit) + yield from primitive.to_graphic_primitives(offset, rotation, variables, unit, polarity_dark) def rotated(self, angle): dup = copy.deepcopy(self) diff --git a/gerbonara/gerber/aperture_macros/primitive.py b/gerbonara/gerber/aperture_macros/primitive.py index 13f462f..18aaf51 100644 --- a/gerbonara/gerber/aperture_macros/primitive.py +++ b/gerbonara/gerber/aperture_macros/primitive.py @@ -81,11 +81,11 @@ class Circle(Primitive): if self.rotation is None: self.rotation = ConstantExpression(0) - def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None): + def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True): with self.Calculator(self, variable_binding, unit) as calc: x, y = gp.rotate_point(calc.x, calc.y, deg_to_rad(calc.rotation) + rotation, 0, 0) x, y = x+offset[0], y+offset[1] - return [ gp.Circle(x, y, calc.diameter/2, polarity_dark=bool(calc.exposure)) ] + return [ gp.Circle(x, y, calc.diameter/2, polarity_dark=(bool(calc.exposure) == polarity_dark)) ] def dilate(self, offset, unit): self.diameter += UnitExpression(offset, unit) @@ -100,7 +100,7 @@ class VectorLine(Primitive): end_y : UnitExpression rotation : Expression - def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None): + def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True): with self.Calculator(self, variable_binding, unit) as calc: center_x = (calc.end_x + calc.start_x) / 2 center_y = (calc.end_y + calc.start_y) / 2 @@ -112,7 +112,7 @@ class VectorLine(Primitive): rotation += deg_to_rad(calc.rotation) + math.atan2(delta_y, delta_x) return [ gp.Rectangle(center_x, center_y, length, calc.width, rotation=rotation, - polarity_dark=bool(calc.exposure)) ] + polarity_dark=(bool(calc.exposure) == polarity_dark)) ] def dilate(self, offset, unit): self.width += UnitExpression(2*offset, unit) @@ -128,14 +128,14 @@ class CenterLine(Primitive): y : UnitExpression rotation : Expression - def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None): + def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True): with self.Calculator(self, variable_binding, unit) as calc: rotation += deg_to_rad(calc.rotation) x, y = gp.rotate_point(calc.x, calc.y, rotation, 0, 0) x, y = x+offset[0], y+offset[1] w, h = calc.width, calc.height - return [ gp.Rectangle(x, y, w, h, rotation, polarity_dark=bool(calc.exposure)) ] + return [ gp.Rectangle(x, y, w, h, rotation, polarity_dark=(bool(calc.exposure) == polarity_dark)) ] def dilate(self, offset, unit): self.width += UnitExpression(2*offset, unit) @@ -151,13 +151,13 @@ class Polygon(Primitive): diameter : UnitExpression rotation : Expression - def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None): + def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True): with self.Calculator(self, variable_binding, unit) as calc: rotation += deg_to_rad(calc.rotation) x, y = gp.rotate_point(calc.x, calc.y, rotation, 0, 0) x, y = x+offset[0], y+offset[1] return [ gp.RegularPolygon(calc.x, calc.y, calc.diameter/2, calc.n_vertices, rotation, - polarity_dark=bool(calc.exposure)) ] + polarity_dark=(bool(calc.exposure) == polarity_dark)) ] def dilate(self, offset, unit): self.diameter += UnitExpression(2*offset, unit) @@ -174,13 +174,13 @@ class Thermal(Primitive): gap_w : UnitExpression rotation : Expression - def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None): + def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True): with self.Calculator(self, variable_binding, unit) as calc: rotation += deg_to_rad(calc.rotation) x, y = gp.rotate_point(calc.x, calc.y, rotation, 0, 0) x, y = x+offset[0], y+offset[1] - dark = bool(calc.exposure) + dark = (bool(calc.exposure) == polarity_dark) return [ gp.Circle(x, y, calc.d_outer/2, polarity_dark=dark), @@ -226,7 +226,7 @@ class Outline(Primitive): coords = ','.join(coord.to_gerber(unit) for xy in self.coords for coord in xy) return f'{self.code},{self.exposure.to_gerber()},{len(self.coords)-1},{coords},{self.rotation.to_gerber()}' - def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None): + def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True): with self.Calculator(self, variable_binding, unit) as calc: bound_coords = [ (calc(x)+offset[0], calc(y)+offset[1]) for x, y in self.coords ] bound_radii = [None] * len(bound_coords) @@ -234,7 +234,7 @@ class Outline(Primitive): rotation += deg_to_rad(calc.rotation) bound_coords = [ gp.rotate_point(*p, rotation, 0, 0) for p in bound_coords ] - return [gp.ArcPoly(bound_coords, bound_radii, polarity_dark=calc.exposure)] + return [gp.ArcPoly(bound_coords, bound_radii, polarity_dark=(bool(calc.exposure) == polarity_dark))] def dilate(self, offset, unit): # we would need a whole polygon offset/clipping library here diff --git a/gerbonara/gerber/apertures.py b/gerbonara/gerber/apertures.py index 1b5aa2e..d288a2a 100644 --- a/gerbonara/gerber/apertures.py +++ b/gerbonara/gerber/apertures.py @@ -1,6 +1,6 @@ import math -from dataclasses import dataclass, replace, fields, InitVar, KW_ONLY +from dataclasses import dataclass, replace, field, fields, InitVar, KW_ONLY from .aperture_macros.parse import GenericMacros from .utils import MM, Inch @@ -8,17 +8,17 @@ from .utils import MM, Inch from . import graphic_primitives as gp -def _flash_hole(self, x, y, unit=None): +def _flash_hole(self, x, y, unit=None, polarity_dark=True): if getattr(self, 'hole_rect_h', None) is not None: - return [*self.primitives(x, y, unit), + return [*self.primitives(x, y, unit, polarity_dark), gp.Rectangle((x, y), (self.unit.convert_to(unit, self.hole_dia), self.unit.convert_to(unit, self.hole_rect_h)), - rotation=self.rotation, polarity_dark=False)] + rotation=self.rotation, polarity_dark=(not polarity_dark))] elif self.hole_dia is not None: - return [*self.primitives(x, y, unit), - gp.Circle(x, y, self.unit.convert_to(unit, self.hole_dia/2), polarity_dark=False)] + return [*self.primitives(x, y, unit, polarity_dark), + gp.Circle(x, y, self.unit.convert_to(unit, self.hole_dia/2), polarity_dark=(not polarity_dark))] else: - return self.primitives(x, y, unit) + return self.primitives(x, y, unit, polarity_dark) def strip_right(*args): args = list(args) @@ -42,6 +42,7 @@ class Length: class Aperture: _ : KW_ONLY unit : str = None + attrs : dict = field(default_factory=dict) @property def hole_shape(self): @@ -63,8 +64,8 @@ class Aperture: return out - def flash(self, x, y, unit=None): - return self.primitives(x, y, unit) + def flash(self, x, y, unit=None, polarity_dark=True): + return self.primitives(x, y, unit, polarity_dark) def equivalent_width(self, unit=None): raise ValueError('Non-circular aperture used in interpolation statement, line width is not properly defined.') @@ -74,7 +75,6 @@ class Aperture: # we emulate this parameter. Our circle, rectangle and oblong classes below have a rotation parameter. Only at # export time during to_gerber, this parameter is evaluated. unit = settings.unit if settings else None - #print(f'aperture to gerber {self.unit=} {settings=} {unit=}') actual_inst = self._rotated() params = 'X'.join(f'{float(par):.4}' for par in actual_inst.params(unit) if par is not None) return ','.join((actual_inst.gerber_shape_code, params)) @@ -96,8 +96,8 @@ class ExcellonTool(Aperture): plated : bool = None depth_offset : Length(float) = 0 - def primitives(self, x, y, unit=None): - return [ gp.Circle(x, y, self.unit.convert_to(unit, self.diameter/2)) ] + def primitives(self, x, y, unit=None, polarity_dark=True): + return [ gp.Circle(x, y, self.unit.convert_to(unit, self.diameter/2), polarity_dark=polarity_dark) ] def to_xnc(self, settings): z_off = 'Z' + settings.write_excellon_value(self.depth_offset, self.unit) if self.depth_offset is not None else '' @@ -146,8 +146,8 @@ class CircleAperture(Aperture): hole_rect_h : Length(float) = None rotation : float = 0 # radians; for rectangular hole; see hack in Aperture.to_gerber - def primitives(self, x, y, unit=None): - return [ gp.Circle(x, y, self.unit.convert_to(unit, self.diameter/2)) ] + def primitives(self, x, y, unit=None, polarity_dark=True): + return [ gp.Circle(x, y, self.unit.convert_to(unit, self.diameter/2), polarity_dark=polarity_dark) ] def __str__(self): return f'' @@ -187,8 +187,9 @@ class RectangleAperture(Aperture): hole_rect_h : Length(float) = None rotation : float = 0 # radians - def primitives(self, x, y, unit=None): - return [ gp.Rectangle(x, y, self.unit.convert_to(unit, self.w), self.unit.convert_to(unit, self.h), rotation=self.rotation) ] + def primitives(self, x, y, unit=None, polarity_dark=True): + return [ gp.Rectangle(x, y, self.unit.convert_to(unit, self.w), self.unit.convert_to(unit, self.h), + rotation=self.rotation, polarity_dark=polarity_dark) ] def __str__(self): return f'' @@ -236,8 +237,9 @@ class ObroundAperture(Aperture): hole_rect_h : Length(float) = None rotation : float = 0 - def primitives(self, x, y, unit=None): - return [ gp.Obround(x, y, self.unit.convert_to(unit, self.w), self.unit.convert_to(unit, self.h), rotation=self.rotation) ] + def primitives(self, x, y, unit=None, polarity_dark=True): + return [ gp.Obround(x, y, self.unit.convert_to(unit, self.w), self.unit.convert_to(unit, self.h), + rotation=self.rotation, polarity_dark=polarity_dark) ] def __str__(self): return f'' @@ -285,8 +287,9 @@ class PolygonAperture(Aperture): def __post_init__(self): self.n_vertices = int(self.n_vertices) - def primitives(self, x, y, unit=None): - return [ gp.RegularPolygon(x, y, self.unit.convert_to(unit, self.diameter)/2, self.n_vertices, rotation=self.rotation) ] + def primitives(self, x, y, unit=None, polarity_dark=True): + return [ gp.RegularPolygon(x, y, self.unit.convert_to(unit, self.diameter)/2, self.n_vertices, + rotation=self.rotation, polarity_dark=polarity_dark) ] def __str__(self): return f'<{self.n_vertices}-gon aperture d={self.diameter:.3} [{self.unit}]>' @@ -322,10 +325,10 @@ class ApertureMacroInstance(Aperture): def gerber_shape_code(self): return self.macro.name - def primitives(self, x, y, unit=None): + def primitives(self, x, y, unit=None, polarity_dark=True): return self.macro.to_graphic_primitives( offset=(x, y), rotation=self.rotation, - parameters=self.parameters, unit=unit) + parameters=self.parameters, unit=unit, polarity_dark=polarity_dark) def dilated(self, offset, unit=MM): return replace(self, macro=self.macro.dilated(offset, unit)) diff --git a/gerbonara/gerber/cam.py b/gerbonara/gerber/cam.py index ffeb471..554491d 100644 --- a/gerbonara/gerber/cam.py +++ b/gerbonara/gerber/cam.py @@ -157,7 +157,7 @@ class CamFile: self.import_settings = None self.objects = [] - def to_svg(self, tag=Tag, margin=0, arg_unit=MM, svg_unit=MM, force_bounds=None, color='black'): + def to_svg(self, tag=Tag, margin=0, arg_unit=MM, svg_unit=MM, force_bounds=None, fg='black', bg='white'): if force_bounds is None: (min_x, min_y), (max_x, max_y) = self.bounding_box(svg_unit, default=((0, 0), (0, 0))) @@ -180,6 +180,8 @@ class CamFile: h = 1.0 if math.isclose(h, 0.0) else h primitives = [ prim for obj in self.objects for prim in obj.to_primitives(unit=svg_unit) ] + view = tag('sodipodi:namedview', [], id='namedview1', pagecolor=bg, + inkscape__document_units=svg_unit.shorthand) tags = [] polyline = None for primitive in primitives: @@ -188,25 +190,29 @@ class CamFile: polyline = gp.Polyline(primitive) else: if not polyline.append(primitive): - tags.append(polyline.to_svg(tag, color)) + tags.append(polyline.to_svg(tag, fg, bg)) polyline = gp.Polyline(primitive) else: if polyline: - tags.append(polyline.to_svg(tag, color)) + tags.append(polyline.to_svg(tag, fg, bg)) polyline = None - tags.append(primitive.to_svg(tag, color)) + tags.append(primitive.to_svg(tag, fg, bg)) if polyline: - tags.append(polyline.to_svg(tag, color)) + tags.append(polyline.to_svg(tag, fg, bg)) # setup viewport transform flipping y axis xform = f'translate({min_x} {min_y+h}) scale(1 -1) translate({-min_x} {-min_y})' svg_unit = 'in' if svg_unit == 'inch' else 'mm' # TODO export apertures as where reasonable. - return tag('svg', [tag('g', tags, transform=xform)], + return tag('svg', [view, tag('g', tags, transform=xform)], width=f'{w}{svg_unit}', height=f'{h}{svg_unit}', viewBox=f'{min_x} {min_y} {w} {h}', - xmlns="http://www.w3.org/2000/svg", xmlns__xlink="http://www.w3.org/1999/xlink", root=True) + xmlns="http://www.w3.org/2000/svg", + xmlns__xlink="http://www.w3.org/1999/xlink", + xmlns__sodipodi='http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd', + xmlns__inkscape='http://www.inkscape.org/namespaces/inkscape', + root=True) def size(self, unit=MM): (x0, y0), (x1, y1) = self.bounding_box(unit, default=((0, 0), (0, 0))) diff --git a/gerbonara/gerber/graphic_objects.py b/gerbonara/gerber/graphic_objects.py index 4d9a1f8..1f357da 100644 --- a/gerbonara/gerber/graphic_objects.py +++ b/gerbonara/gerber/graphic_objects.py @@ -1,6 +1,6 @@ import math -from dataclasses import dataclass, KW_ONLY, astuple, replace, fields +from dataclasses import dataclass, KW_ONLY, astuple, replace, field, fields from .utils import MM, InterpMode from . import graphic_primitives as gp @@ -23,6 +23,7 @@ class GerberObject: _ : KW_ONLY polarity_dark : bool = True unit : str = None + attrs : dict = field(default_factory=dict) def converted(self, unit): return replace(self, @@ -74,7 +75,7 @@ class Flash(GerberObject): def to_primitives(self, unit=None): conv = self.converted(unit) - yield from self.aperture.flash(conv.x, conv.y, unit) + yield from self.aperture.flash(conv.x, conv.y, unit, self.polarity_dark) def to_statements(self, gs): yield from gs.set_polarity(self.polarity_dark) @@ -141,13 +142,14 @@ class Region(GerberObject): self.poly.polarity_dark = self.polarity_dark # FIXME: is this the right spot to do this? if unit == self.unit: yield self.poly + else: to = lambda value: self.unit.convert_to(unit, value) conv_outline = [ (to(x), to(y)) for x, y in self.poly.outline ] convert_entry = lambda entry: (entry[0], (to(entry[1][0]), to(entry[1][1]))) conv_arc = [ None if entry is None else convert_entry(entry) for entry in self.poly.arc_centers ] - yield gp.ArcPoly(conv_outline, conv_arc) + yield gp.ArcPoly(conv_outline, conv_arc, polarity_dark=self.polarity_dark) def to_statements(self, gs): yield from gs.set_polarity(self.polarity_dark) @@ -329,7 +331,7 @@ class Arc(GerberObject): conv = self.converted(unit) yield gp.Arc(x1=conv.x1, y1=conv.y1, x2=conv.x2, y2=conv.y2, - cx=conv.cx+conv.x1, cy=conv.cy+conv.y1, + cx=conv.cx, cy=conv.cy, clockwise=self.clockwise, width=self.aperture.equivalent_width(unit), polarity_dark=self.polarity_dark) diff --git a/gerbonara/gerber/graphic_primitives.py b/gerbonara/gerber/graphic_primitives.py index 4ed4d0c..07ceb5c 100644 --- a/gerbonara/gerber/graphic_primitives.py +++ b/gerbonara/gerber/graphic_primitives.py @@ -50,7 +50,8 @@ class Circle(GraphicPrimitive): def bounding_box(self): return ((self.x-self.r, self.y-self.r), (self.x+self.r, self.y+self.r)) - def to_svg(self, tag, color='black'): + def to_svg(self, tag, fg, bg): + color = fg if self.polarity_dark else bg return tag('circle', cx=self.x, cy=self.y, r=self.r, style=f'fill: {color}') @@ -75,8 +76,8 @@ class Obround(GraphicPrimitive): def bounding_box(self): return self.to_line().bounding_box() - def to_svg(self, tag, color='black'): - return self.to_line().to_svg(tag, color) + def to_svg(self, tag, fg, bg): + return self.to_line().to_svg(tag, fg, bg) def arc_bounds(x1, y1, x2, y2, cx, cy, clockwise): @@ -162,22 +163,18 @@ def arc_bounds(x1, y1, x2, y2, cx, cy, clockwise): return (min_x+cx, min_y+cy), (max_x+cx, max_y+cy) -# FIXME use math.dist instead -def point_distance(a, b): - return math.sqrt((b[0] - a[0])**2 + (b[1] - a[1])**2) - def point_line_distance(l1, l2, p): + # https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line x1, y1 = l1 x2, y2 = l2 x0, y0 = p - length = point_distance(l1, l2) + length = math.dist(l1, l2) if math.isclose(length, 0): - return point_distance(l1, p) - return abs((x2-x1)*(y1-y0) - (x1-x0)*(y2-y1)) / length + return math.dist(l1, p) + return ((x2-x1)*(y1-y0) - (x1-x0)*(y2-y1)) / length def svg_arc(old, new, center, clockwise): r = math.hypot(*center) - d = point_line_distance(old, new, center) # invert sweep flag since the svg y axis is mirrored sweep_flag = int(not clockwise) # In the degenerate case where old == new, we always take the long way around. To represent this "full-circle arc" @@ -190,7 +187,8 @@ def svg_arc(old, new, center, clockwise): f'A {r:.6} {r:.6} 0 1 {sweep_flag} {new[0]:.6} {new[1]:.6}' else: # normal case - large_arc = int((d > 0) == clockwise) + d = point_line_distance(old, new, (old[0]+center[0], old[1]+center[1])) + large_arc = int((d < 0) == clockwise) return f'A {r:.6} {r:.6} 0 {large_arc} {sweep_flag} {new[0]:.6} {new[1]:.6}' @dataclass @@ -231,7 +229,8 @@ class ArcPoly(GraphicPrimitive): if len(self.outline) == 0: return - yield f'M {self.outline[0][0]:.6}, {self.outline[0][1]:.6}' + yield f'M {self.outline[0][0]:.6} {self.outline[0][1]:.6}' + for old, new, arc in self.segments: if not arc: yield f'L {new[0]:.6} {new[1]:.6}' @@ -239,7 +238,8 @@ class ArcPoly(GraphicPrimitive): clockwise, center = arc yield svg_arc(old, new, center, clockwise) - def to_svg(self, tag, color='black'): + def to_svg(self, tag, fg, bg): + color = fg if self.polarity_dark else bg return tag('path', d=' '.join(self._path_d()), style=f'fill: {color}') class Polyline: @@ -270,7 +270,8 @@ class Polyline: else: return False - def to_svg(self, tag, color='black'): + def to_svg(self, tag, fg, bg): + color = fg if self.polarity_dark else bg if not self.coords: return None @@ -290,7 +291,8 @@ class Line(GraphicPrimitive): r = self.width / 2 return add_bounds(Circle(self.x1, self.y1, r).bounding_box(), Circle(self.x2, self.y2, r).bounding_box()) - def to_svg(self, tag, color='black'): + def to_svg(self, tag, fg, bg): + color = fg if self.polarity_dark else bg return tag('path', d=f'M {self.x1:.6} {self.y1:.6} L {self.x2:.6} {self.y2:.6}', style=f'fill: none; stroke: {color}; stroke-width: {self.width:.6}; stroke-linecap: round') @@ -310,7 +312,7 @@ class Arc(GraphicPrimitive): r = self.width/2 endpoints = add_bounds(Circle(self.x1, self.y1, r).bounding_box(), Circle(self.x2, self.y2, r).bounding_box()) - arc_r = point_distance((self.cx, self.cy), (self.x1, self.y1)) + arc_r = math.dist((self.cx, self.cy), (self.x1, self.y1)) # extend C -> P1 line by line width / 2 along radius dx, dy = self.x1 - self.cx, self.y1 - self.cy @@ -325,7 +327,8 @@ class Arc(GraphicPrimitive): arc = arc_bounds(x1, y1, x2, y2, self.cx, self.cy, self.clockwise) return add_bounds(endpoints, arc) # FIXME add "include_center" switch - def to_svg(self, tag, color='black'): + def to_svg(self, tag, fg, bg): + color = fg if self.polarity_dark else bg arc = svg_arc((self.x1, self.y1), (self.x2, self.y2), (self.cx, self.cy), self.clockwise) return tag('path', d=f'M {self.x1:.6} {self.y1:.6} {arc}', style=f'fill: none; stroke: {color}; stroke-width: {self.width:.6}; stroke-linecap: round; fill: none') @@ -361,7 +364,8 @@ class Rectangle(GraphicPrimitive): def center(self): return self.x + self.w/2, self.y + self.h/2 - def to_svg(self, tag, color='black'): + def to_svg(self, tag, fg, bg): + color = fg if self.polarity_dark else bg x, y = self.x - self.w/2, self.y - self.h/2 return tag('rect', x=x, y=y, width=self.w, height=self.h, transform=svg_rotation(self.rotation, self.x, self.y), style=f'fill: {color}') @@ -387,6 +391,6 @@ class RegularPolygon(GraphicPrimitive): def bounding_box(self): return self.to_arc_poly().bounding_box() - def to_svg(self, tag, color='black'): - return self.to_arc_poly().to_svg(tag, color) + def to_svg(self, tag, fg, bg): + return self.to_arc_poly().to_svg(tag, color, fg, bg) diff --git a/gerbonara/gerber/rs274x.py b/gerbonara/gerber/rs274x.py index e7459ec..cba08fc 100644 --- a/gerbonara/gerber/rs274x.py +++ b/gerbonara/gerber/rs274x.py @@ -256,31 +256,28 @@ class GerberFile(CamFile): class GraphicsState: - polarity_dark : bool = True - image_polarity : str = 'positive' # IP image polarity; deprecated - point : tuple = None - aperture : apertures.Aperture = None - file_settings : FileSettings = None - interpolation_mode : InterpMode = InterpMode.LINEAR - multi_quadrant_mode : bool = None # used only for syntax checking - aperture_mirroring = (False, False) # LM mirroring (x, y) - aperture_rotation = 0 # LR rotation in degree, ccw - aperture_scale = 1 # LS scale factor, NOTE: same for both axes - # The following are deprecated file-wide settings. We normalize these during parsing. - image_offset : (float, float) = (0, 0) - image_rotation: int = 0 # IR image rotation in degree ccw, one of 0, 90, 180 or 270; deprecated - image_mirror : tuple = (False, False) # IM image mirroring, (x, y); deprecated - image_scale : tuple = (1.0, 1.0) # SF image scaling (x, y); deprecated - image_axes : str = 'AXBY' # AS axis mapping; deprecated - # for statement generation - aperture_map = {} - - def __init__(self, file_settings=None, aperture_map=None): + self.image_polarity = 'positive' # IP image polarity; deprecated + self.polarity_dark = True + self.point = None + self.aperture = None + self.file_settings = None + self.interpolation_mode = InterpMode.LINEAR + self.multi_quadrant_mode = None # used only for syntax checking + self.aperture_mirroring = (False, False) # LM mirroring (x, y) + self.aperture_rotation = 0 # LR rotation in degree, ccw + self.aperture_scale = 1 # LS scale factor, NOTE: same for both axes + # The following are deprecated file-wide settings. We normalize these during parsing. + self.image_offset = (0, 0) + self.image_rotation = 0 # IR image rotation in degree ccw, one of 0, 90, 180 or 270; deprecated + self.image_mirror = (False, False) # IM image mirroring, (x, y); deprecated + self.image_scale = (1.0, 1.0) # SF image scaling (x, y); deprecated + self.image_axes = 'AXBY' # AS axis mapping; deprecated self._mat = None self.file_settings = file_settings if aperture_map is not None: self.aperture_map = aperture_map + self.aperture_map = {} def __setattr__(self, name, value): # input validation @@ -299,7 +296,7 @@ class GraphicsState: # polarity handling if name == 'image_polarity': # global IP statement image polarity, can only be set at beginning of file - if self.image_polarity == 'negative': + if getattr(self, 'image_polarity', None) == 'negative': self.polarity_dark = False # evaluated before image_polarity is set below through super().__setattr__ elif name == 'polarity_dark': # local LP statement polarity for subsequent objects @@ -347,13 +344,15 @@ class GraphicsState: rx, ry = (a*x + b*y), (c*x + d*y) return rx, ry - def flash(self, x, y): + def flash(self, x, y, attrs=None): + attrs = attrs or {} self.update_point(x, y) return go.Flash(*self.map_coord(*self.point), self.aperture, polarity_dark=self.polarity_dark, - unit=self.file_settings.unit) + unit=self.file_settings.unit, + attrs=attrs) - def interpolate(self, x, y, i=None, j=None, aperture=True, multi_quadrant=False): + def interpolate(self, x, y, i=None, j=None, aperture=True, multi_quadrant=False, attrs=None): if self.point is None: warnings.warn('D01 interpolation without preceding D02 move.', SyntaxWarning) self.point = (0, 0) @@ -372,13 +371,13 @@ class GraphicsState: if i is not None or j is not None: raise SyntaxError("i/j coordinates given for linear D01 operation (which doesn't take i/j)") - return self._create_line(old_point, self.map_coord(*self.point), aperture) + return self._create_line(old_point, self.map_coord(*self.point), aperture, attrs) else: if i is None and j is None: warnings.warn('Linear segment implied during arc interpolation mode through D01 w/o I, J values', SyntaxWarning) - return self._create_line(old_point, self.map_coord(*self.point), aperture) + return self._create_line(old_point, self.map_coord(*self.point), aperture, attrs) else: if i is None: @@ -387,26 +386,28 @@ class GraphicsState: if j is None: warnings.warn('Arc is missing J value', SyntaxWarning) j = 0 - return self._create_arc(old_point, self.map_coord(*self.point), (i, j), aperture, multi_quadrant) + return self._create_arc(old_point, self.map_coord(*self.point), (i, j), aperture, multi_quadrant, attrs) - def _create_line(self, old_point, new_point, aperture=True): + def _create_line(self, old_point, new_point, aperture=True, attrs=None): + attrs = attrs or {} return go.Line(*old_point, *new_point, self.aperture if aperture else None, - polarity_dark=self.polarity_dark, unit=self.file_settings.unit) + polarity_dark=self.polarity_dark, unit=self.file_settings.unit, attrs=attrs) - def _create_arc(self, old_point, new_point, control_point, aperture=True, multi_quadrant=False): + def _create_arc(self, old_point, new_point, control_point, aperture=True, multi_quadrant=False, attrs=None): + attrs = attrs or {} clockwise = self.interpolation_mode == InterpMode.CIRCULAR_CW if not multi_quadrant: return go.Arc(*old_point, *new_point, *self.map_coord(*control_point, relative=True), clockwise=clockwise, aperture=(self.aperture if aperture else None), - polarity_dark=self.polarity_dark, unit=self.file_settings.unit) + polarity_dark=self.polarity_dark, unit=self.file_settings.unit, attrs=attrs) else: # Super-legacy. No one uses this EXCEPT everything that mentor graphics / siemens make uses this m( (cx, cy) = self.map_coord(*control_point, relative=True) arc = lambda cx, cy: go.Arc(*old_point, *new_point, cx, cy, clockwise=clockwise, aperture=(self.aperture if aperture else None), - polarity_dark=self.polarity_dark, unit=self.file_settings.unit) + polarity_dark=self.polarity_dark, unit=self.file_settings.unit, attrs=attrs) arcs = [ arc(cx, cy), arc(-cx, cy), arc(cx, -cy), arc(-cx, -cy) ] arcs = [ a for a in arcs if a.sweep_angle() <= math.pi/2 ] arcs = sorted(arcs, key=lambda a: a.numeric_error()) @@ -469,7 +470,6 @@ class GerberParser: fr"(I(?P{NUMBER}))?(J(?P{NUMBER}))?" \ fr"(?PD0?[123])?$", 'aperture': r"(G54|G55)?D(?P\d+)", - 'comment': r"G0?4(?P[^*]*)", # Allegro combines format spec and unit into one long illegal extended command. 'allegro_format_spec': r"FS(?P(L|T|D))?(?P(A|I))[NG0-9]*X(?P[0-7][0-7])Y(?P[0-7][0-7])[DM0-9]*\*MO(?PIN|MM)", 'unit_mode': r"MO(?P(MM|IN))", @@ -493,6 +493,10 @@ class GerberParser: 'old_notation': r'(?PG9[01])', 'eof': r"M0?[02]", 'ignored': r"(?PM01)", + # NOTE: The official spec says names can be empty or contain commas. I think that doesn't make sense. + 'attribute': r"(?PG04 #@! %)?(?PTF|TA|TO|TD)(?P[._$a-zA-Z][._$a-zA-Z0-9]*)(,(?P.*))", + # Eagle file attributes handled above. + 'comment': r"G0?4(?P[^*]*)", } STATEMENT_REGEXES = { key: re.compile(value) for key, value in STATEMENT_REGEXES.items() } @@ -514,6 +518,9 @@ class GerberParser: self.last_operation = None self.generator_hints = [] self.layer_hints = [] + self.file_attrs = {} + self.object_attrs = {} + self.aperture_attrs = {} @classmethod def _split_commands(kls, data): @@ -531,7 +538,8 @@ class GerberParser: extended_command = False else: - # Ignore % inside G04 comments + # Ignore % inside G04 comments. Eagle uses a completely borked file attribute syntax with unbalanced + # percent signs inside G04 comments. if not data[start:pos].startswith('G04'): extended_command = True @@ -685,10 +693,10 @@ class GerberParser: if match['shape'] in 'RO' and (math.isclose(modifiers[0], 0) or math.isclose(modifiers[1], 0)): warnings.warn('Definition of zero-width and/or zero-height rectangle or obround aperture. This is invalid according to spec.' , SyntaxWarning) - new_aperture = kls(*modifiers, unit=self.file_settings.unit) + new_aperture = kls(*modifiers, unit=self.file_settings.unit, attrs=self.aperture_attrs.copy()) elif (macro := self.aperture_macros.get(match['shape'])): - new_aperture = apertures.ApertureMacroInstance(macro, modifiers, unit=self.file_settings.unit) + new_aperture = apertures.ApertureMacroInstance(macro, modifiers, unit=self.file_settings.unit, attrs=self.aperture_attrs.copy()) else: raise ValueError(f'Aperture shape "{match["shape"]}" is unknown') @@ -854,6 +862,32 @@ class GerberParser: self.file_settings.notation = 'absolute' if match['mode'] == 'G90' else 'incremental' warnings.warn(f'Deprecated {match["mode"]} notation mode statement found. This deprecated since 2012.', DeprecationWarning) self.target.comments.append('Replaced deprecated {match["mode"]} notation mode statement with FS statement') + + def _parse_attribtue(self, match): + if match['type'] == 'TD': + if match['value']: + raise SyntaxError('TD attribute deletion command must not contain attribute fields') + + if not match['name']: + self.object_attrs = {} + self.aperture_attrs = {} + return + + if match['name'] in self.file_attrs: + raise SyntaxError('Attempt to TD delete file attribute. This does not make sense.') + elif match['name'] in self.object_attrs: + del self.object_attrs[match['name']] + elif match['name'] in self.aperture_attrs: + del self.aperture_attrs[match['name']] + else: + raise SyntaxError(f'Attempt to TD delete previously undefined attribute {match["name"]}.') + + else: + target = {'TF': self.file_attrs, 'TO': self.object_attrs, 'TA': self.aperture_attrs}[match['type']] + target[match['name']] = match['value'].split(',') + + if 'eagle' in self.file_attrs.get('.GenerationSoftware', '').lower() or match['eagle_garbage']: + self.generator_hints.append('eagle') def _parse_eof(self, _match): self.eof_found = True @@ -885,6 +919,6 @@ if __name__ == '__main__': args = parser.parse_args() bounds = (0.0, 0.0), (6.0, 6.0) # bottom left, top right - svg = str(GerberFile.open(args.testfile).to_svg(force_bounds=bounds, arg_unit='inch', color='white')) + svg = str(GerberFile.open(args.testfile).to_svg(force_bounds=bounds, arg_unit='inch', fg='white', bg='black')) print(svg) diff --git a/gerbonara/gerber/tests/image_support.py b/gerbonara/gerber/tests/image_support.py index c43f7b6..a50e243 100644 --- a/gerbonara/gerber/tests/image_support.py +++ b/gerbonara/gerber/tests/image_support.py @@ -67,6 +67,9 @@ def svg_to_png(in_svg, out_png, dpi=100, bg='black'): to_gerbv_svg_units = lambda val, unit='mm': val*72 if unit == 'inch' else val/25.4*72 def gerbv_export(in_gbr, out_svg, export_format='svg', origin=(0, 0), size=(6, 6), fg='#ffffff', bg='#000000', override_unit_spec=None): + # NOTE: gerbv seems to always export 'clear' polarity apertures as white, irrespective of --foreground, --background + # and project file color settings. + # TODO: File issue upstream. with tempfile.NamedTemporaryFile('w') as f: if override_unit_spec: units, zeros, digits = override_unit_spec @@ -92,6 +95,7 @@ def gerbv_export(in_gbr, out_svg, export_format='svg', origin=(0, 0), size=(6, 6 '--border=0', f'--origin={x:.6f}x{y:.6f}', f'--window_inch={w:.6f}x{h:.6f}', f'--background={bg}', + f'--foreground={fg}', '-o', str(out_svg), '-p', f.name] subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) diff --git a/gerbonara/gerber/tests/test_rs274x.py b/gerbonara/gerber/tests/test_rs274x.py index bf49fe8..06150de 100644 --- a/gerbonara/gerber/tests/test_rs274x.py +++ b/gerbonara/gerber/tests/test_rs274x.py @@ -433,14 +433,14 @@ def test_svg_export(reference, tmpfile): out_svg = tmpfile('Output', '.svg') with open(out_svg, 'w') as f: - f.write(str(grb.to_svg(force_bounds=bounds, arg_unit='inch', color='white'))) + f.write(str(grb.to_svg(force_bounds=bounds, arg_unit='inch', fg='black', bg='white'))) # NOTE: Instead of having gerbv directly export a PNG, we ask gerbv to output SVG which we then rasterize using # resvg. We have to do this since gerbv's built-in cairo-based PNG export has severe aliasing issues. In contrast, # using resvg for both allows an apples-to-apples comparison of both results. ref_svg = tmpfile('Reference export', '.svg') ref_png = tmpfile('Reference render', '.png') - gerbv_export(reference, ref_svg, origin=bounds[0], size=bounds[1]) + gerbv_export(reference, ref_svg, origin=bounds[0], size=bounds[1], fg='#000000', bg='#ffffff') svg_to_png(ref_svg, ref_png, dpi=72) # make dpi match Cairo's default out_png = tmpfile('Output render', '.png') @@ -471,7 +471,7 @@ def test_bounding_box(reference, tmpfile): grb = GerberFile.open(reference) out_svg = tmpfile('Output', '.svg') with open(out_svg, 'w') as f: - f.write(str(grb.to_svg(margin=margin, arg_unit='inch', color='white'))) + f.write(str(grb.to_svg(margin=margin, arg_unit='inch', fg='white', bg='black'))) out_png = tmpfile('Render', '.png') svg_to_png(out_svg, out_png, dpi=dpi) diff --git a/gerbonara/gerber/utils.py b/gerbonara/gerber/utils.py index e17b99b..00ba41e 100644 --- a/gerbonara/gerber/utils.py +++ b/gerbonara/gerber/utils.py @@ -203,7 +203,7 @@ class Tag: def __str__(self): prefix = '\n' if self.root else '' - opening = ' '.join([self.name] + [f'{key.replace("__", ":")}="{value}"' for key, value in self.attrs.items()]) + opening = ' '.join([self.name] + [f'{key.replace("__", ":").replace("_", "-")}="{value}"' for key, value in self.attrs.items()]) if self.children: children = '\n'.join(textwrap.indent(str(c), ' ') for c in self.children) return f'{prefix}<{opening}>\n{children}\n' -- cgit