Fix a whole bunch of SVG export bugs

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'<circle aperture d={self.diameter:.3} [{self.unit}]>'
@@ -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'<rect aperture {self.w:.3}x{self.h:.3} [{self.unit}]>'
@@ -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'<obround aperture {self.w:.3}x{self.h:.3} [{self.unit}]>'
@@ -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 <uses> 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<i>{NUMBER}))?(J(?P<j>{NUMBER}))?" \
             fr"(?P<operation>D0?[123])?$",
         'aperture': r"(G54|G55)?D(?P<number>\d+)",
-        'comment': r"G0?4(?P<comment>[^*]*)",
         # Allegro combines format spec and unit into one long illegal extended command.
         'allegro_format_spec': r"FS(?P<zero>(L|T|D))?(?P<notation>(A|I))[NG0-9]*X(?P<x>[0-7][0-7])Y(?P<y>[0-7][0-7])[DM0-9]*\*MO(?P<unit>IN|MM)",
         'unit_mode': r"MO(?P<unit>(MM|IN))",
@@ -493,6 +493,10 @@ class GerberParser:
         'old_notation': r'(?P<mode>G9[01])',
         'eof': r"M0?[02]",
         'ignored': r"(?P<stmt>M01)",
+        # NOTE: The official spec says names can be empty or contain commas. I think that doesn't make sense.
+        'attribute': r"(?P<eagle_garbage>G04 #@! %)?(?P<type>TF|TA|TO|TD)(?P<name>[._$a-zA-Z][._$a-zA-Z0-9]*)(,(?P<value>.*))",
+        # Eagle file attributes handled above.
+        'comment': r"G0?4(?P<comment>[^*]*)",
         }
 
     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 = '<?xml version="1.0" encoding="utf-8"?>\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</{self.name}>'