WIP

11 files changed, 833 insertions, 1248 deletions

diff --git a/gerbonara/gerber/__init__.py b/gerbonara/gerber/__init__.py
index a3d4753..5cf9dc1 100644
--- a/gerbonara/gerber/__init__.py
+++ b/gerbonara/gerber/__init__.py
@@ -22,6 +22,5 @@ gerbonara provides utilities for working with Gerber (RS-274X) and Excellon
 files in python.
 """
 
-from .common import read, loads
 from .layers import load_layer, load_layer_data
 from .pcb import PCB
diff --git a/gerbonara/gerber/aperture_macros/expression.py b/gerbonara/gerber/aperture_macros/expression.py
index 74fbd90..ddd8d53 100644
--- a/gerbonara/gerber/aperture_macros/expression.py
+++ b/gerbonara/gerber/aperture_macros/expression.py
@@ -8,6 +8,10 @@ import re
 import ast
 
 
+def expr(obj):
+    return obj if isinstance(obj, Expression) else ConstantExpression(obj)
+
+
 class Expression(object):
     @property
     def value(self):
@@ -28,6 +32,35 @@ class Expression(object):
             raise IndexError(f'Cannot fully resolve expression due to unresolved variables: {expr} with variables {variable_binding}')
         return expr.value
 
+    def __add__(self, other):
+        return OperatorExpression(operator.add, self, expr(other)).optimized()
+
+    def __radd__(self, other):
+        return expr(other) + self
+
+    def __sub__(self, other):
+        return OperatorExpression(operator.sub, self, expr(other)).optimized()
+
+    def __rsub__(self, other):
+        return expr(other) - self
+
+    def __mul__(self, other):
+        return OperatorExpression(operator.mul, self, expr(other)).optimized()
+
+    def __rmul__(self, other):
+        return expr(other) * self
+
+    def __truediv__(self, other):
+        return OperatorExpression(operator.truediv, self, expr(other)).optimized()
+
+    def __rtruediv__(self, other):
+        return expr(other) / self
+
+    def __neg__(self):
+        return 0 - self
+
+    def __pos__(self):
+        return self
 
 class UnitExpression(Expression):
     def __init__(self, expr, unit):
@@ -50,10 +83,10 @@ class UnitExpression(Expression):
             return self._expr
 
         elif unit == 'mm':
-            return OperatorExpression.mul(self._expr, MILLIMETERS_PER_INCH)
+            return self._expr * MILLIMETERS_PER_INCH
 
         elif unit == 'inch':
-            return OperatorExpression.div(self._expr, MILLIMETERS_PER_INCH)
+            return self._expr / MILLIMETERS_PER_INCH)
 
         else:
             raise ValueError('invalid unit, must be "inch" or "mm".')
diff --git a/gerbonara/gerber/aperture_macros/primitive.py b/gerbonara/gerber/aperture_macros/primitive.py
index f4400f5..aeb38c4 100644
--- a/gerbonara/gerber/aperture_macros/primitive.py
+++ b/gerbonara/gerber/aperture_macros/primitive.py
@@ -2,24 +2,37 @@
 # -*- coding: utf-8 -*-
 
 # Copyright 2019 Hiroshi Murayama <opiopan@gmail.com>
+# Copyright 2022 Jan Götte <gerbonara@jaseg.de>
+
+import contextlib
+import math
+
+from expression import Expression, UnitExpression, ConstantExpression, expr
+
+from .. import graphic_primitivese as gp
+
+
+def point_distance(a, b):
+    x1, y1 = a
+    x2, y2 = b
+    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+
+def deg_to_rad(a):
+    return (a / 180) * math.pi
 
-from dataclasses import dataclass, fields
-from expression import Expression, UnitExpression, ConstantExpression
 
 class Primitive:
-    def __init__(self, unit, args, is_abstract):
+    def __init__(self, unit, args):
         self.unit = unit
-        self.is_abstract = is_abstract
 
         if len(args) > len(type(self).__annotations__):
             raise ValueError(f'Too many arguments ({len(args)}) for aperture macro primitive {self.code} ({type(self)})')
 
         for arg, (name, fieldtype) in zip(args, type(self).__annotations__.items()):
-            if is_abstract:
-                if fieldtype == UnitExpression:
-                    setattr(self, name, UnitExpression(arg, unit))
-                else:
-                    setattr(self, name, arg)
+            arg = expr(arg) # convert int/float to Expression object
+
+            if fieldtype == UnitExpression:
+                setattr(self, name, UnitExpression(arg, unit))
             else:
                 setattr(self, name, arg)
 
@@ -28,8 +41,6 @@ class Primitive:
                 raise ValueError(f'Too few arguments ({len(args)}) for aperture macro primitive {self.code} ({type(self)})')
 
     def to_gerber(self, unit=None):
-        if not self.is_abstract:
-            raise TypeError(f"Something went wrong, tried to gerber'ize bound aperture macro primitive {self}")
         return self.code + ',' + ','.join(
                 getattr(self, name).to_gerber(unit) for name in type(self).__annotations__) + '*'
 
@@ -37,27 +48,42 @@ class Primitive:
         attrs = ','.join(str(getattr(self, name)).strip('<>') for name in type(self).__annotations__)
         return f'<{type(self).__name__} {attrs}>'
 
-    def bind(self, variable_binding={}):
-        if not self.is_abstract:
-            raise TypeError('{type(self).__name__} object is already instantiated, cannot bind again.')
-        # Return instance of the same class, but replace all attributes by their actual numeric values
-        return type(self)(unit=self.unit, is_abstract=False, args=[
-            getattr(self, name).calculate(variable_binding) for name in type(self).__annotations__
-        ])
+    @contextlib.contextmanager
+    class Calculator:
+        def __init__(self, instance, variable_binding={}, unit=None):
+            self.instance = instance
+            self.variable_binding = variable_binding
+            self.unit = unit
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, _type, _value, _traceback):
+            pass
 
-class CommentPrimitive(Primitive):
-    code = 0
-    comment : str
+        def __getattr__(self, name):
+            return getattr(self.instance, name).calculate(self.variable_binding, self.unit)
 
-class CirclePrimitive(Primitive):
+        def __call__(self, expr):
+            return expr.calculate(self.variable_binding, self.unit)
+
+
+class Circle(Primitive):
     code = 1
     exposure : Expression
     diameter : UnitExpression
-    center_x : UnitExpression
-    center_y : UnitExpression
+    # center x/y
+    x : UnitExpression
+    y : UnitExpression
     rotation : Expression = ConstantExpression(0.0)
 
-class VectorLinePrimitive(Primitive):
+    def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None):
+        with self.Calculator(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.r, polarity_dark=bool(calc.exposure)) ]
+
+class VectorLine(Primitive):
     code = 20
     exposure : Expression
     width : UnitExpression
@@ -67,40 +93,90 @@ class VectorLinePrimitive(Primitive):
     end_y : UnitExpression
     rotation : Expression
 
-class CenterLinePrimitive(Primitive):
+    def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None):
+        with self.Calculator(variable_binding, unit) as calc:
+            center_x = (calc.end_x + calc.start_x) / 2
+            center_y = (calc.end_y + calc.start_y) / 2
+            delta_x = calc.end_x - calc.start_x
+            delta_y = calc.end_y - calc.start_y
+            length = point_distance((calc.start_x, calc.start_y), (calc.end_x, calc.end_y))
+
+            center_x, center_y = center_x+offset[0], center_y+offset[1]
+            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)) ]
+
+
+class CenterLine(Primitive):
     code = 21
     exposure : Expression
     width : UnitExpression
     height : UnitExpression
+    # center x/y
     x : UnitExpression
     y : UnitExpression
     rotation : Expression
 
+    def to_graphic_primitives(self, variable_binding={}, unit=None):
+        with self.Calculator(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)) ]
+            
 
-class PolygonPrimitive(Primitive):
+class Polygon(Primitive):
     code = 5
     exposure : Expression
     n_vertices : Expression
-    center_x : UnitExpression
-    center_y : UnitExpression
+    # center x/y
+    x : UnitExpression
+    y : UnitExpression
     diameter : UnitExpression
     rotation : Expression
 
+    def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None):
+        with self.Calculator(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)) ]
+
 
-class ThermalPrimitive(Primitive):
+class Thermal(Primitive):
     code = 7
-    center_x : UnitExpression
-    center_y : UnitExpression
+    # center x/y
+    x : UnitExpression
+    y : UnitExpression
     d_outer : UnitExpression
     d_inner : UnitExpression
     gap_w : UnitExpression
     rotation : Expression
 
+    def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None):
+        with self.Calculator(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)
+
+            return [
+                    gp.Circle(x, y, calc.d_outer/2, polarity_dark=dark),
+                    gp.Circle(x, y, calc.d_inner/2, polarity_dark=not dark),
+                    gp.Rectangle(x, y, d_outer, gap_w, rotation=rotation, polarity_dark=not dark),
+                    gp.Rectangle(x, y, gap_w, d_outer, rotation=rotation, polarity_dark=not dark),
+                    ]
 
-class OutlinePrimitive(Primitive):
+
+class Outline(Primitive):
     code = 4
 
-    def __init__(self, unit, args, is_abstract):
+    def __init__(self, unit, args):
         if len(args) < 11:
             raise ValueError(f'Invalid aperture macro outline primitive, not enough parameters ({len(args)}).')
         if len(args) > 5004:
@@ -108,42 +184,36 @@ class OutlinePrimitive(Primitive):
 
         self.exposure = args[0]
 
-        if is_abstract:
-            # length arg must not contain variabels (that would not make sense)
-            length_arg = args[1].calculate()
-
-            if length_arg != len(args)//2 - 2:
-                raise ValueError(f'Invalid aperture macro outline primitive, given size does not match length of coordinate list({len(args)}).')
+        # length arg must not contain variables (that would not make sense)
+        length_arg = args[1].calculate()
 
-            if len(args) % 1 != 1:
-                self.rotation = args.pop()
-            else:
-                self.rotation = ConstantExpression(0.0)
+        if length_arg != len(args)//2 - 2:
+            raise ValueError(f'Invalid aperture macro outline primitive, given size does not match length of coordinate list({len(args)}).')
 
-            if args[2] != args[-2] or args[3] != args[-1]:
-                raise ValueError(f'Invalid aperture macro outline primitive, polygon is not closed {args[2:4], args[-3:-1]}')
+        if len(args) % 1 != 1:
+            self.rotation = args.pop()
+        else:
+            self.rotation = ConstantExpression(0.0)
 
-            self.coords = [UnitExpression(arg, unit) for arg in args[1:]]
+        if args[2] != args[-2] or args[3] != args[-1]:
+            raise ValueError(f'Invalid aperture macro outline primitive, polygon is not closed {args[2:4], args[-3:-1]}')
 
-        else:
-            if len(args) % 1 != 1:
-                self.rotation = args.pop()
-            else:
-                self.rotation = 0
+        self.coords = [(UnitExpression(x, unit), UnitExpression(y, unit)) for x, y in zip(args[1::2], args[2::2])]
 
-            self.coords = args[1:]
-    
     def to_gerber(self, unit=None):
-        if not self.is_abstract:
-            raise TypeError(f"Something went wrong, tried to gerber'ize bound aperture macro primitive {self}")
         coords = ','.join(coord.to_gerber(unit) for coord in self.coords)
         return f'{self.code},{self.exposure.to_gerber()},{len(self.coords)//2-1},{coords},{self.rotation.to_gerber()}'
 
-    def bind(self, variable_binding={}):
-        if not self.is_abstract:
-            raise TypeError('{type(self).__name__} object is already instantiated, cannot bind again.')
+    def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None):
+        with self.Calculator(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)
+
+            rotation += deg_to_rad(calc.rotation)
+            bound_coords = [ rotate_point(*p, rotation, 0, 0) for p in bound_coords ]
+
+            return gp.ArcPoly(bound_coords, bound_radii, polarity_dark=calc.exposure)
 
-        return OutlinePrimitive(self.unit, is_abstract=False, args=[None, *self.coords, self.rotation])
 
 class Comment:
     def __init__(self, comment):
@@ -154,13 +224,13 @@ class Comment:
 
 PRIMITIVE_CLASSES = {
     **{cls.code: cls for cls in [
-        CommentPrimitive,
-        CirclePrimitive,
-        VectorLinePrimitive,
-        CenterLinePrimitive,
-        OutlinePrimitive,
-        PolygonPrimitive,
-        ThermalPrimitive,
+        Comment,
+        Circle,
+        VectorLine,
+        CenterLine,
+        Outline,
+        Polygon,
+        Thermal,
     ]},
     # alternative codes
     2: VectorLinePrimitive,
diff --git a/gerbonara/gerber/apertures.py b/gerbonara/gerber/apertures.py
index aa2764e..2c03a37 100644
--- a/gerbonara/gerber/apertures.py
+++ b/gerbonara/gerber/apertures.py
@@ -1,11 +1,13 @@
 
-from dataclasses import dataclass
+import math
+from dataclasses import dataclass, replace
+from aperture_macros.parse import GenericMacros
 
-from primitives import Primitive
+import graphic_primitives as gp
 
 def _flash_hole(self, x, y):
     if self.hole_rect_h is not None:
-        return self.primitives(x, y), Rectangle((x, y), (self.hole_dia, self.hole_rect_h), polarity_dark=False)
+        return self.primitives(x, y), Rectangle((x, y), (self.hole_dia, self.hole_rect_h), rotation=self.rotation, polarity_dark=False)
     else:
         return self.primitives(x, y), Circle((x, y), self.hole_dia, polarity_dark=False)
 
@@ -21,65 +23,185 @@ class Aperture:
     def hole_size(self):
         return (self.hole_dia, self.hole_rect_h)
 
+    @property
+    def params(self):
+        return dataclasses.astuple(self)
+
     def flash(self, x, y):
         return self.primitives(x, y)
 
+    @parameter
+    def equivalent_width(self):
+        raise ValueError('Non-circular aperture used in interpolation statement, line width is not properly defined.')
+
+    def to_gerber(self):
+        # Hack: The standard aperture shapes C, R, O do not have a rotation parameter. To make this API easier to use,
+        # 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. 
+        actual_inst = self._rotated()
+        params = 'X'.join(f'{par:.4}' for par in actual_inst.params)
+        return f'{actual_inst.aperture.gerber_shape_code},{params}'
 
-@dataclass
-class ApertureCircle(Aperture):
+    def __eq__(self, other):
+        return hasattr(other, to_gerber) and self.to_gerber() == other.to_gerber()
+
+    def _rotate_hole_90(self):
+        if self.hole_rect_h is None:
+            return {'hole_dia': self.hole_dia, 'hole_rect_h': None}
+        else:
+            return {'hole_dia': self.hole_rect_h, 'hole_rect_h': self.hole_dia}
+
+
+@dataclass(frozen=True)
+class CircleAperture(Aperture):
+    gerber_shape_code = 'C'
+    human_readable_shape = 'circle'
     diameter : float
     hole_dia : float = 0
     hole_rect_h : float = None
+    rotation : float = 0 # radians; for rectangular hole; see hack in Aperture.to_gerber
 
-    def primitives(self, x, y):
-        return Circle((x, y), self.diameter, polarity_dark=True),
+    def primitives(self, x, y, rotation):
+        return [ gp.Circle(x, y, self.diameter/2) ]
+
+    def __str__(self):
+        return f'<circle aperture d={self.diameter:.3}>'
 
     flash = _flash_hole
 
+    @parameter
+    def equivalent_width(self):
+        return self.diameter
 
-@dataclass
-class ApertureRectangle(Aperture):
+    def rotated(self):
+        if math.isclose(rotation % (2*math.pi), 0) or self.hole_rect_h is None:
+            return self
+        else:
+            return self.to_macro(self.rotation)
+
+    def to_macro(self):
+        return ApertureMacroInstance(GenericMacros.circle, *self.params)
+
+
+@dataclass(frozen=True)
+class RectangleAperture(Aperture):
+    gerber_shape_code = 'R'
+    human_readable_shape = 'rect'
     w : float
     h : float
     hole_dia : float = 0
     hole_rect_h : float = None
+    rotation : float = 0 # radians
 
     def primitives(self, x, y):
-        return Rectangle((x, y), (self.w, self.h), polarity_dark=True),
+        return [ gp.Rectangle(x, y, self.w, self.h, rotation=self.rotation) ]
+
+    def __str__(self):
+        return f'<rect aperture {self.w:.3}x{self.h:.3}>'
 
     flash = _flash_hole
 
+    @parameter
+    def equivalent_width(self):
+        return math.sqrt(self.w**2 + self.h**2)
+
+    def _rotated(self):
+        if math.isclose(self.rotation % math.pi, 0):
+            return self
+        elif math.isclose(self.rotation % math.pi, math.pi/2):
+            return replace(self, w=self.h, h=self.w, **self._rotate_hole_90())
+        else: # odd angle
+            return self.to_macro()
+
+    def to_macro(self):
+        return ApertureMacroInstance(GenericMacros.rect, *self.params)
+
 
-@dataclass
-class ApertureObround(Aperture):
+@dataclass(frozen=True)
+class ObroundAperture(Aperture):
+    gerber_shape_code = 'O'
+    human_readable_shape = 'obround'
     w : float
     h : float
     hole_dia : float = 0
     hole_rect_h : float = None
+    rotation : float = 0
 
     def primitives(self, x, y):
-        return Obround((x, y), self.w, self.h, polarity_dark=True)
+        return [ gp.Obround(x, y, self.w, self.h, rotation=self.rotation) ]
+
+    def __str__(self):
+        return f'<obround aperture {self.w:.3}x{self.h:.3}>'
 
     flash = _flash_hole
 
+    def _rotated(self):
+        if math.isclose(self.rotation % math.pi, 0):
+            return self
+        elif math.isclose(self.rotation % math.pi, math.pi/2):
+            return replace(self, w=self.h, h=self.w, **self._rotate_hole_90())
+        else:
+            return self.to_macro()
+
+    def to_macro(self, rotation:'radians'=0):
+        # generic macro only supports w > h so flip x/y if h > w
+        inst = self if self.w > self.h else replace(self, w=self.h, h=self.w, **_rotate_hole_90(self))
+        return ApertureMacroInstance(GenericMacros.obround, *inst.params)
+
 
-@dataclass
-class AperturePolygon(Aperture):
+@dataclass(frozen=True)
+class PolygonAperture(Aperture):
+    gerber_shape_code = 'P'
     diameter : float
     n_vertices : int
+    rotation : float = 0
     hole_dia : float = 0
-    hole_rect_h : float = None
 
     def primitives(self, x, y):
-        return Polygon((x, y), diameter, n_vertices, rotation, polarity_dark=True),
+        return [ gp.RegularPolygon(x, y, diameter, n_vertices, rotation=self.rotation) ]
+
+    def __str__(self):
+        return f'<{self.n_vertices}-gon aperture d={self.diameter:.3}'
 
     flash = _flash_hole
 
-class MacroAperture(Aperture):
-    parameters : [float]
-    self.macro : ApertureMacro
+    def _rotated(self):
+        self.rotation %= (2*math.pi / self.n_vertices)
+        return self
+
+    def to_macro(self):
+        return ApertureMacroInstance(GenericMacros.polygon, *self.params)
+
+
+class ApertureMacroInstance(Aperture):
+    params : [float]
+    rotation : float = 0
+
+    def __init__(self, macro, *parameters):
+        self.params = parameters
+        self._primitives = macro.to_graphic_primitives(parameters)
+        self.macro = macro
+
+    @property
+    def gerber_shape_code(self):
+        return self.macro.name
 
     def primitives(self, x, y):
-        return self.macro.execute(x, y, self.parameters)
+        # FIXME return graphical primitives not macro primitives here
+        return [ primitive.with_offset(x, y).rotated(self.rotation, cx=0, cy=0) for primitive in self._primitives ]
+
+    def _rotated(self):
+        if math.isclose(self.rotation % (2*math.pi), 0):
+            return self
+        else:
+            return self.to_macro()
+
+    def to_macro(self):
+        return type(self)(self.macro.rotated(self.rotation), self.params)
+
+    def __eq__(self, other):
+        return hasattr(other, 'macro') and self.macro == other.macro and \
+                hasattr(other, 'params') and self.params == other.params and \
+                hasattr(other, 'rotation') and self.rotation == other.rotation
 
 
diff --git a/gerbonara/gerber/cam.py b/gerbonara/gerber/cam.py
index 7d68ae2..fa46ba2 100644
--- a/gerbonara/gerber/cam.py
+++ b/gerbonara/gerber/cam.py
@@ -20,12 +20,16 @@ from dataclasses import dataclass
 
 @dataclass
 class FileSettings:
-    output_axes : str = 'AXBY' # For deprecated AS statement
-    image_polarity : str = 'positive'
-    image_rotation: int = 0
-    mirror_image : tuple = (False, False)
-    offset : tuple = (0, 0)
-    scale_factor : tuple = (1.0, 1.0) # For deprecated SF statement
+    '''
+    .. note::
+        Format and zero suppression are configurable. Note that the Excellon
+        and Gerber formats use opposite terminology with respect to leading
+        and trailing zeros. The Gerber format specifies which zeros are
+        suppressed, while the Excellon format specifies which zeros are
+        included. This function uses the Gerber-file convention, so an
+        Excellon file in LZ (leading zeros) mode would use
+        `zero_suppression='trailing'`
+    '''
     notation : str = 'absolute'
     units : str = 'inch'
     angle_units : str = 'degrees'
@@ -34,18 +38,6 @@ class FileSettings:
 
     # input validation
     def __setattr__(self, name, value):
-        if name == 'output_axes' and value not in [None, 'AXBY', 'AYBX']:
-            raise ValueError('output_axes must be either "AXBY", "AYBX" or None')
-        if name == 'image_rotation' and value not in [0, 90, 180, 270]:
-            raise ValueError('image_rotation must be 0, 90, 180 or 270')
-        elif name == 'image_polarity' and value not in ['positive', 'negative']:
-            raise ValueError('image_polarity must be either "positive" or "negative"')
-        elif name == 'mirror_image' and len(value) != 2:
-            raise ValueError('mirror_image must be 2-tuple of bools: (mirror_a, mirror_b)')
-        elif name == 'offset' and len(value) != 2:
-            raise ValueError('offset must be 2-tuple of floats: (offset_a, offset_b)')
-        elif name == 'scale_factor' and len(value) != 2:
-            raise ValueError('scale_factor must be 2-tuple of floats: (scale_a, scale_b)')
         elif name == 'notation' and value not in ['inch', 'mm']:
             raise ValueError('Units must be either "inch" or "mm"')
         elif name == 'units' and value not in ['absolute', 'incremental']:
@@ -54,14 +46,65 @@ class FileSettings:
             raise ValueError('Angle units may be "degrees" or "radians"')
         elif name == 'zeros' and value not in [None, 'leading', 'trailing']:
             raise ValueError('zero_suppression must be either "leading" or "trailing" or None')
-        elif name == 'number_format' and len(value) != 2:
-            raise ValueError('Number format must be a (integer, fractional) tuple of integers')
+        elif name == 'number_format':
+            if len(value) != 2:
+                raise ValueError('Number format must be a (integer, fractional) tuple of integers')
+
+            if value[0] > 6 or value[1] > 7:
+                raise ValueError('Requested precision is too high. Only up to 6.7 digits are supported by spec.')
+
 
         super().__setattr__(name, value)
 
     def __str__(self):
         return f'<File settings: units={self.units}/{self.angle_units} notation={self.notation} zeros={self.zeros} number_format={self.number_format}>'
 
+    def parse_gerber_value(self, value):
+        if not value:
+            return None
+
+        # Handle excellon edge case with explicit decimal. "That was easy!"
+        if '.' in value:
+            return float(value)
+
+        # Format precision
+        integer_digits, decimal_digits = self.number_format
+
+        # Remove extraneous information
+        sign = '-' if value[0] == '-' else ''
+        value = value.lstrip('+-')
+
+        missing_digits = MAX_DIGITS - len(value)
+
+        if self.zero_suppression == 'leading':
+            return float(sign + value[:-decimal_digits] + '.' + value[-decimal_digits:])
+
+        else: # no or trailing zero suppression
+            return float(sign + value[:integer_digits] + '.' + value[integer_digits:])
+
+    def write_gerber_value(self, value):
+        """ Convert a floating point number to a Gerber/Excellon-formatted string.  """
+        
+        integer_digits, decimal_digits = self.number_format
+
+        # negative sign affects padding, so deal with it at the end...
+        sign = '-' if value < 0 else ''
+
+        num = format(abs(value), f'0{integer_digits+decimal_digits+1}.{decimal_digits}f')
+
+        # Suppression...
+        if self.zero_suppression == 'trailing':
+            num = num.rstrip('0')
+
+        elif self.zero_suppression == 'leading':
+            num = num.lstrip('0')
+
+        # Edge case. Per Gerber spec if the value is 0 we should return a single '0' in all cases, see page 77.
+        elif not num.strip('0'):
+            num = '0'
+
+        return sign + (num or '0')
+
 
 class CamFile(object):
     """ Base class for Gerber/Excellon files.
@@ -101,40 +144,13 @@ class CamFile(object):
         decimal digits)
     """
 
-    def __init__(self, statements=None, settings=None, primitives=None,
+    def __init__(self, settings=None, primitives=None,
                  filename=None, layer_name=None):
-        if settings is not None:
-            self.notation = settings['notation']
-            self.units = settings['units']
-            self.zero_suppression = settings['zero_suppression']
-            self.zeros = settings['zeros']
-            self.format = settings['format']
-        else:
-            self.notation = 'absolute'
-            self.units = 'inch'
-            self.zero_suppression = 'trailing'
-            self.zeros = 'leading'
-            self.format = (2, 5)
-
-        self.statements = statements if statements is not None else []
-        if primitives is not None:
-            self.primitives = primitives
+        self.settings = settings if settings is not None else FileSettings()
         self.filename = filename
         self.layer_name = layer_name
 
     @property
-    def settings(self):
-        """ File settings
-
-        Returns
-        -------
-        settings : FileSettings (dict-like)
-            A FileSettings object with the specified configuration.
-        """
-        return FileSettings(self.notation, self.units, self.zero_suppression,
-                            self.format)
-
-    @property
     def bounds(self):
         """ File boundaries
         """
@@ -144,12 +160,6 @@ class CamFile(object):
     def bounding_box(self):
         pass
 
-    def to_inch(self):
-        pass
-
-    def to_metric(self):
-        pass
-
     def render(self, ctx=None, invert=False, filename=None):
         """ Generate image of layer.
 
diff --git a/gerbonara/gerber/common.py b/gerbonara/gerber/common.py
deleted file mode 100644
index 12b87c4..0000000
--- a/gerbonara/gerber/common.py
+++ /dev/null
@@ -1,71 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be>
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import rs274x
-from . import excellon
-from . import ipc356
-from .exceptions import ParseError
-from .utils import detect_file_format
-
-
-def read(filename):
-    """ Read a gerber or excellon file and return a representative object.
-
-    Parameters
-    ----------
-    filename : string
-        Filename of the file to read.
-
-    Returns
-    -------
-    file : CncFile subclass
-        CncFile object representing the file, either GerberFile, ExcellonFile,
-        or IPCNetlist. Returns None if file is not of the proper type.
-    """
-    with open(filename, 'r') as f:
-        data = f.read()
-    return loads(data, filename)
-
-
-def loads(data, filename=None):
-    """ Read gerber or excellon file contents from a string and return a
-    representative object.
-
-    Parameters
-    ----------
-    data : string
-        Source file contents as a string.
-
-    filename : string, optional
-        String containing the filename of the data source.
-
-    Returns
-    -------
-    file : CncFile subclass
-        CncFile object representing the data, either GerberFile, ExcellonFile,
-        or IPCNetlist. Returns None if data is not of the proper type.
-    """
-
-    fmt = detect_file_format(data)
-    if fmt == 'rs274x':
-        return rs274x.loads(data, filename=filename)
-    elif fmt == 'excellon':
-        return excellon.loads(data, filename=filename)
-    elif fmt == 'ipc_d_356':
-        return ipc356.loads(data, filename=filename)
-    else:
-        raise ParseError('Unable to detect file format')
diff --git a/gerbonara/gerber/gerber_statements.py b/gerbonara/gerber/gerber_statements.py
index 6faf15e..7555a18 100644
--- a/gerbonara/gerber/gerber_statements.py
+++ b/gerbonara/gerber/gerber_statements.py
@@ -20,14 +20,7 @@ Gerber (RS-274X) Statements
 **Gerber RS-274X file statement classes**
 
 """
-from .utils import (parse_gerber_value, write_gerber_value, decimal_string,
-                    inch, metric)
-
-from .am_statements import *
-from .am_read import read_macro
-from .am_primitive import eval_macro
-from .primitives import AMGroup
-
+from utils import parse_gerber_value, write_gerber_value, decimal_string, inch, metric
 
 class Statement:
     pass
@@ -86,202 +79,28 @@ class LoadPolarityStmt(ParamStmt):
 class ApertureDefStmt(ParamStmt):
     """ AD - Aperture Definition Statement """
 
-    @classmethod
-    def rect(cls, dcode, width, height, hole_diameter=None, hole_width=None, hole_height=None):
-        '''Create a rectangular aperture definition statement'''
-        if hole_diameter is not None and hole_diameter > 0:
-            return cls('AD', dcode, 'R', ([width, height, hole_diameter],))
-        elif (hole_width is not None and hole_width > 0
-              and hole_height is not None and hole_height > 0):
-            return cls('AD', dcode, 'R', ([width, height, hole_width, hole_height],))
-        return cls('AD', dcode, 'R', ([width, height],))
-
-    @classmethod
-    def circle(cls, dcode, diameter, hole_diameter=None, hole_width=None, hole_height=None):
-        '''Create a circular aperture definition statement'''
-        if hole_diameter is not None and hole_diameter > 0:
-            return cls('AD', dcode, 'C', ([diameter, hole_diameter],))
-        elif (hole_width is not None and hole_width > 0
-              and hole_height is not None and hole_height > 0):
-            return cls('AD', dcode, 'C', ([diameter, hole_width, hole_height],))
-        return cls('AD', dcode, 'C', ([diameter],))
-
-    @classmethod
-    def obround(cls, dcode, width, height, hole_diameter=None, hole_width=None, hole_height=None):
-        '''Create an obround aperture definition statement'''
-        if hole_diameter is not None and hole_diameter > 0:
-            return cls('AD', dcode, 'O', ([width, height, hole_diameter],))
-        elif (hole_width is not None and hole_width > 0
-              and hole_height is not None and hole_height > 0):
-            return cls('AD', dcode, 'O', ([width, height, hole_width, hole_height],))
-        return cls('AD', dcode, 'O', ([width, height],))
-
-    @classmethod
-    def polygon(cls, dcode, diameter, num_vertices, rotation, hole_diameter=None, hole_width=None, hole_height=None):
-        '''Create a polygon aperture definition statement'''
-        if hole_diameter is not None and hole_diameter > 0:
-            return cls('AD', dcode, 'P', ([diameter, num_vertices, rotation, hole_diameter],))
-        elif (hole_width is not None and hole_width > 0
-              and hole_height is not None and hole_height > 0):
-            return cls('AD', dcode, 'P', ([diameter, num_vertices, rotation, hole_width, hole_height],))
-        return cls('AD', dcode, 'P', ([diameter, num_vertices, rotation],))
-
-
-    @classmethod
-    def macro(cls, dcode, name):
-        return cls('AD', dcode, name, '')
-
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict.get('param')
-        d = int(stmt_dict.get('d'))
-        shape = stmt_dict.get('shape')
-        modifiers = stmt_dict.get('modifiers')
-        return cls(param, d, shape, modifiers)
-
-    def __init__(self, param, d, shape, modifiers):
-        """ Initialize ADParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter code
-
-        d : int
-            Aperture D-code
-
-        shape : string
-            aperture name
-
-        modifiers : list of lists of floats
-            Shape modifiers
-
-        Returns
-        -------
-        ParamStmt : ADParamStmt
-            Initialized ADParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.d = d
-        self.shape = shape
-        if isinstance(modifiers, tuple):
-            self.modifiers = modifiers
-        elif modifiers:
-            self.modifiers = [tuple([float(x) for x in m.split("X") if len(x)])
-                              for m in modifiers.split(",") if len(m)]
-        else:
-            self.modifiers = [tuple()]
-
-    def to_inch(self):
-        if self.units == 'metric':
-            self.units = 'inch'
-            self.modifiers = [tuple([inch(x) for x in modifier])
-                              for modifier in self.modifiers]
-
-    def to_metric(self):
-        if self.units == 'inch':
-            self.units = 'metric'
-            self.modifiers = [tuple([metric(x) for x in modifier])
-                              for modifier in self.modifiers]
+    def __init__(self, number, aperture):
+        self.number = number
+        self.aperture = aperture
 
     def to_gerber(self, settings=None):
-        if any(self.modifiers):
-            return '%ADD{0}{1},{2}*%'.format(self.d, self.shape, ','.join(['X'.join(["%.4g" % x for x in modifier]) for modifier in self.modifiers]))
-        else:
-            return '%ADD{0}{1}*%'.format(self.d, self.shape)
+        return '%ADD{self.number}{self.aperture.to_gerber()}*%'
 
     def __str__(self):
-        if self.shape == 'C':
-            shape = 'circle'
-        elif self.shape == 'R':
-            shape = 'rectangle'
-        elif self.shape == 'O':
-            shape = 'obround'
-        else:
-            shape = self.shape
-
-        return '<Aperture Definition: %d: %s>' % (self.d, shape)
-
-
-class AMParamStmt(ParamStmt):
-    """ AM - Aperture Macro Statement
-    """
-
-    @classmethod
-    def from_dict(cls, stmt_dict, units):
-        return cls(**stmt_dict, units=units)
-
-    def __init__(self, param, name, macro, units):
-        """ Initialize AMParamStmt class
+        return f'<AD aperture def for {str(self.aperture).strip("<>")}>'
 
-        Parameters
-        ----------
-        param : string
-            Parameter code
 
-        name : string
-            Aperture macro name
+class ApertureMacroStmt(ParamStmt):
+    """ AM - Aperture Macro Statement """
 
-        macro : string
-            Aperture macro string
-
-        Returns
-        -------
-        ParamStmt : AMParamStmt
-            Initialized AMParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.name = name
+    def __init__(self, macro):
         self.macro = macro
-        self.units = units
-        self.primitives = list(eval_macro(read_macro(macro), units))
-
-    @classmethod
-    def circle(cls, name, units):
-        return cls('AM', name, '1,1,$1,0,0,0*1,0,$2,0,0,0', units)
-
-    @classmethod
-    def rectangle(cls, name, units):
-        return cls('AM', name, '21,1,$1,$2,0,0,0*1,0,$3,0,0,0', units)
-    
-    @classmethod
-    def landscape_obround(cls, name, units):
-        return cls(
-            'AM', name,
-            '$4=$1-$2*'
-            '$5=$1-$4*'
-            '21,1,$5,$2,0,0,0*'
-            '1,1,$4,$4/2,0,0*'
-            '1,1,$4,-$4/2,0,0*'
-            '1,0,$3,0,0,0', units)
-
-    @classmethod
-    def portrate_obround(cls, name, units):
-        return cls(
-            'AM', name,
-            '$4=$2-$1*'
-            '$5=$2-$4*'
-            '21,1,$1,$5,0,0,0*'
-            '1,1,$4,0,$4/2,0*'
-            '1,1,$4,0,-$4/2,0*'
-            '1,0,$3,0,0,0', units)
-    
-    @classmethod
-    def polygon(cls, name, units):
-        return cls('AM', name, '5,1,$2,0,0,$1,$3*1,0,$4,0,0,0', units)
 
     def to_gerber(self, unit=None):
-        primitive_defs = '\n'.join(primitive.to_gerber(unit=unit) for primitive in self.primitives)
-        return f'%AM{self.name}*\n{primitive_defs}%'
-
-    def rotate(self, angle, center=None):
-        for primitive_def in self.primitives:
-            primitive_def.rotate(angle, center)
+        return f'%AM{self.macro.name}*\n{self.macro.to_gerber(unit=unit)}*\n%'
 
     def __str__(self):
-        return '<AM Aperture Macro %s: %s>' % (self.name, self.macro)
+        return f'<AM Aperture Macro {self.macro.name}: {self.macro}>'
 
 
 class ImagePolarityStmt(ParamStmt):
@@ -298,7 +117,7 @@ class ImagePolarityStmt(ParamStmt):
 class CoordStmt(Statement):
     """ D01 - D03 operation statements """
 
-    def __init__(self, x, y, i, j):
+    def __init__(self, x, y, i=None, j=None):
         self.x, self.y, self.i, self.j = x, y, i, j
 
     def to_gerber(self, settings=None):
@@ -309,22 +128,12 @@ class CoordStmt(Statement):
                 ret += var.upper() + write_gerber_value(val, settings.number_format, settings.zero_suppression)
         return ret + self.code + '*'
 
-    def offset(self, x=0, y=0):
-        if self.x is not None:
-            self.x += x
-        if self.y is not None:
-            self.y += y
-
     def __str__(self):
         if self.i is None:
             return f'<{self.__name__.strip()} x={self.x} y={self.y}>'
         else
             return f'<{self.__name__.strip()} x={self.x} y={self.y} i={self.i} j={self.j]>'
 
-    def render_primitives(self, state):
-        if state.interpolation_mode == InterpolateStmt:
-            yield Line(state.current_point, (self.x, self.y))
-
 class InterpolateStmt(Statement):
     """ D01 Interpolation """
     code = 'D01'
@@ -369,20 +178,12 @@ class RegionEndStatement(InterpolationModeStmt):
     """ G37 Region Mode End Statement. """
     code = 'G37'
 
-class RegionGroup:
-    def __init__(self):
-        self.outline = []
-
 class ApertureStmt(Statement):
     def __init__(self, d):
         self.d = int(d)
-        self.deprecated = True if deprecated is not None and deprecated is not False else False
 
     def to_gerber(self, settings=None):
-        if self.deprecated:
-            return 'G54D{0}*'.format(self.d)
-        else:
-            return 'D{0}*'.format(self.d)
+        return 'D{0}*'.format(self.d)
 
     def __str__(self):
         return '<Aperture: %d>' % self.d
diff --git a/gerbonara/gerber/graphic_primitives.py b/gerbonara/gerber/graphic_primitives.py
new file mode 100644
index 0000000..391a452
--- /dev/null
+++ b/gerbonara/gerber/graphic_primitives.py
@@ -0,0 +1,140 @@
+
+import math
+import itertools
+
+from dataclasses import dataclass, KW_ONLY, replace
+
+from gerber_statements import *
+
+
+class GraphicPrimitive:
+    _ : KW_ONLY
+    polarity_dark : bool = True
+
+
+def rotate_point(x, y, angle, cx=None, cy=None):
+    if cx is None:
+        return (x, y)
+    else:
+        return (cx + (x - cx) * math.cos(angle) - (y - cy) * math.sin(angle),
+                cy + (x - cx) * math.sin(angle) + (y - cy) * math.cos(angle))
+
+
+@dataclass
+class Circle(GraphicPrimitive):
+    x : float
+    y : float
+    r : float # Here, we use radius as common in modern computer graphics, not diameter as gerber uses.
+
+    def bounds(self):
+        return ((self.x-self.r, self.y-self.r), (self.x+self.r, self.y+self.r))
+
+
+@dataclass
+class Obround(GraphicPrimitive):
+    x : float
+    y : float
+    w : float
+    h : float
+    rotation : float # radians!
+
+    def decompose(self):
+        ''' decompose obround to two circles and one rectangle '''
+
+        cx = self.x + self.w/2
+        cy = self.y + self.h/2
+
+        if self.w > self.h:
+            x = self.x + self.h/2
+            yield Circle(x, cy, self.h/2)
+            yield Circle(x + self.w, cy, self.h/2)
+            yield Rectangle(x, self.y, self.w - self.h, self.h)
+
+        elif self.h > self.w:
+            y = self.y + self.w/2
+            yield Circle(cx, y, self.w/2)
+            yield Circle(cx, y + self.h, self.w/2)
+            yield Rectangle(self.x, y, self.w, self.h - self.w)
+
+        else:
+            yield Circle(cx, cy, self.w/2)
+
+    def bounds(self):
+        return ((self.x-self.w/2, self.y-self.h/2), (self.x+self.w/2, self.y+self.h/2))
+
+
+@dataclass
+class ArcPoly(GraphicPrimitive):
+    """ Polygon whose sides may be either straight lines or circular arcs """
+
+    # list of (x : float, y : float) tuples. Describes closed outline, i.e. first and last point are considered
+    # connected.
+    outline : list(tuple(float))
+    # list of radii of segments, must be either None (all segments are straight lines) or same length as outline.
+    # Straight line segments have None entry.
+    arc_centers : list(tuple(float))
+
+    @property
+    def segments(self):
+        return itertools.zip_longest(self.outline[:-1], self.outline[1:], self.radii or [])
+
+    def bounds(self):
+        for (x1, y1), (x2, y2), radius in self.segments:
+            return 
+
+
+@dataclass
+class Line(GraphicPrimitive):
+    x1 : float
+    y1 : float
+    x2 : float
+    y2 : float
+    width : float
+
+    # FIXME bounds
+
+@dataclass
+class Arc(GraphicPrimitive):
+    x : float
+    y : float
+    r : float
+    angle1 : float # radians!
+    angle2 : float # radians!
+    width : float
+
+    # FIXME bounds
+
+@dataclass
+class Rectangle(GraphicPrimitive):
+    # coordinates are center coordinates
+    x : float
+    y : float
+    w : float
+    h : float
+    rotation : float # radians, around center!
+
+    def bounds(self):
+        return ((self.x, self.y), (self.x+self.w, self.y+self.h))
+
+    @prorperty
+    def center(self):
+        return self.x + self.w/2, self.y + self.h/2
+
+
+class RegularPolygon(GraphicPrimitive):
+    x : float
+    y : float
+    r : float
+    n : int
+    rotation : float # radians!
+
+    def decompose(self):
+        ''' convert n-sided gerber polygon to normal Region defined by outline '''
+
+        delta = 2*math.pi / self.n
+
+        yield Region([
+                (self.x + math.cos(self.rotation + i*delta) * self.r,
+                 self.y + math.sin(self.rotation + i*delta) * self.r)
+                for i in range(self.n) ])
+
diff --git a/gerbonara/gerber/primitives.py b/gerbonara/gerber/primitives.py
index 25f8e06..d505ddb 100644
--- a/gerbonara/gerber/primitives.py
+++ b/gerbonara/gerber/primitives.py
@@ -38,7 +38,7 @@ class Primitive:
 

 

 class Line(Primitive):

-    def __init__(self, start, end, aperture, polarity_dark=True, rotation=0, **meta):

+    def __init__(self, start, end, aperture=None, polarity_dark=True, rotation=0, **meta):

         super().__init__(polarity_dark, rotation, **meta)

         self.start = start

         self.end = end

@@ -240,9 +240,6 @@ class Arc(Primitive):
 

 

 class Circle(Primitive):

-    """

-    """

-

     def __init__(self, position, diameter, polarity_dark=True):

         super(Circle, self).__init__(**kwargs)

         validate_coordinates(position)

@@ -922,3 +919,14 @@ class TestRecord(Primitive):
         self.net_name = net_name

         self.layer = layer

         self._to_convert = ['position']

+

+class RegionGroup:

+    def __init__(self):

+        self.outline = []

+

+    def __bool__(self):

+        return bool(self.outline)

+

+    def append(self, primitive):

+        self.outline.append(primitive)

+

diff --git a/gerbonara/gerber/rs274x.py b/gerbonara/gerber/rs274x.py
index 0c7b1f4..f2473b9 100644
--- a/gerbonara/gerber/rs274x.py
+++ b/gerbonara/gerber/rs274x.py
@@ -26,92 +26,30 @@ import os
 import re
 import sys
 import warnings
+import functools
 from pathlib import Path
 from itertools import count, chain
 from io import StringIO
 
 from .gerber_statements import *
-from .primitives import *
 from .cam import CamFile, FileSettings
 from .utils import sq_distance, rotate_point
-
+from aperture_macros.parse import ApertureMacro, GenericMacros
+import graphic_primitives as gp
+import graphic_objects as go
 
 
 class GerberFile(CamFile):
     """ A class representing a single gerber file
 
     The GerberFile class represents a single gerber file.
-
-    Parameters
-    ----------
-    statements : list
-        list of gerber file statements
-
-    settings : dict
-        Dictionary of gerber file settings
-
-    filename : string
-        Filename of the source gerber file
-
-    Attributes
-    ----------
-    comments: list of strings
-        List of comments contained in the gerber file.
-
-    size : tuple, (<float>, <float>)
-        Size in [self.units] of the layer described by the gerber file.
-
-    bounds: tuple, ((<float>, <float>), (<float>, <float>))
-        boundaries of the layer described by the gerber file.
-        `bounds` is stored as ((min x, max x), (min y, max y))
-
     """
 
-    def __init__(self, statements, settings, primitives, apertures, filename=None):
-        super(GerberFile, self).__init__(statements, settings, primitives, filename)
-
-        self.apertures = apertures
-
-        # always explicitly set polarity
-        self.statements.insert(0, LPParamStmt('LP', 'dark'))
-
-        self.aperture_macros = {}
-        self.aperture_defs = []
-        self.main_statements = []
-
-        self.context = GerberContext.from_settings(self.settings)
-
-        for stmt in self.statements:
-            self.context.update_from_statement(stmt)
-
-            if isinstance(stmt, CoordStmt):
-                self.context.normalize_coordinates(stmt)
-
-            if isinstance(stmt, AMParamStmt):
-                self.aperture_macros[stmt.name] = stmt
-
-            elif isinstance(stmt, ADParamStmt):
-                self.aperture_defs.append(stmt)
-
-            else:
-                # ignore FS, MO, AS, IN, IP, IR, MI, OF, SF, LN statements
-                if isinstance(stmt, ParamStmt) and not isinstance(stmt, LPParamStmt):
-                    continue
-
-                if isinstance(stmt, (CommentStmt, EofStmt)):
-                    continue
-
-                self.main_statements.append(stmt)
-
-        if self.context.angle != 0:
-            self.rotate(self.context.angle) # TODO is this correct/useful?
-
-        if self.context.is_negative:
-            self.negate_polarity() # TODO is this correct/useful?
-
-        self.context.notation = 'absolute'
-        self.context.zeros = 'trailing'
-
+    def __init__(self, filename=None):
+        super(GerberFile, self).__init__(filename)
+        self.apertures = []
+        self.comments = []
+        self.objects = []
 
     @classmethod
     def open(kls, filename, enable_includes=False, enable_include_dir=None):
@@ -120,14 +58,11 @@ class GerberFile(CamFile):
                 enable_include_dir = Path(filename).parent
             return kls.from_string(f.read(), enable_include_dir)
 
-
     @classmethod
     def from_string(kls, data, enable_include_dir=None):
-        return GerberParser().parse(data, enable_include_dir)
-
-    @property
-    def comments(self):
-        return [stmt.comment for stmt in self.statements if isinstance(stmt, CommentStmt)]
+        obj = kls()
+        GerberParser(obj, include_dir=enable_include_dir).parse(data)
+        return obj
 
     @property
     def size(self):
@@ -145,20 +80,40 @@ class GerberFile(CamFile):
 
         return ((min_x, max_x), (min_y, max_y))
 
-    def generate_statements(self):
-        self.settings.notation = 'absolute'
-        self.settings.zeros = 'trailing'
-        self.settings.format = self.format
-        self.units = self.units
-
+    def generate_statements(self, drop_comments=True):
         yield UnitStmt()
         yield FormatSpecStmt()
         yield ImagePolarityStmt()
         yield SingleQuadrantModeStmt()
 
-        yield from self.aperture_macros.values()
-        yield from self.aperture_defs
-        yield from self.main_statements
+        if not drop_comments:
+            yield CommentStmt('File processed by Gerbonara. Original comments:')
+            for cmt in self.comments:
+                yield CommentStmt(cmt)
+
+        # Emit gerbonara's generic, rotation-capable aperture macro replacements for the standard C/R/O/P shapes.
+        yield ApertureMacroStmt(GenericMacros.circle)
+        yield ApertureMacroStmt(GenericMacros.rect)
+        yield ApertureMacroStmt(GenericMacros.oblong)
+        yield ApertureMacroStmt(GenericMacros.polygon)
+
+        processed_macros = set()
+        aperture_map = {}
+        for number, aperture in enumerate(self.apertures, start=10):
+
+            if isinstance(aperture, ApertureMacroInstance):
+                macro_grb = aperture.macro.to_gerber() # use native units to compare macros
+                if macro_grb not in processed_macros:
+                    processed_macros.add(macro_grb)
+                    yield ApertureMacroStmt(aperture.macro)
+
+            yield ApertureDefStmt(number, aperture)
+
+            aperture_map[aperture] = number
+
+        gs = GraphicsState(aperture_map=aperture_map)
+        for primitive in self.objects:
+            yield from primitive.to_statements(gs)
 
         yield EofStmt()
 
@@ -170,130 +125,167 @@ class GerberFile(CamFile):
             for stmt in self.generate_statements():
                 print(stmt.to_gerber(self.settings), file=f)
 
-    def render_primitives(self):
-        for stmt in self.main_statements:
-            yield from stmt.render_primitives()
-
-    def to_inch(self):
-        if self.units == 'metric':
-            for thing in chain(self.aperture_macros.values(), self.aperture_defs, self.statements, self.primitives):
-                thing.to_inch()
-            self.units = 'inch'
-            self.context.units = 'inch'
-
-    def to_metric(self):
-        if self.units == 'inch':
-            for thing in chain(self.aperture_macros.values(), self.aperture_defs, self.statements, self.primitives):
-                thing.to_metric()
-            self.units='metric'
-            self.context.units='metric'
-
-    def offset(self, x_offset=0,  y_offset=0):
-        for thing in chain(self.main_statements, self.primitives):
-            thing.offset(x_offset, y_offset)
-
-    def rotate(self, angle, center=(0,0)):
-        if angle % 360 == 0:
-            return
-
-        self._generalize_apertures()
+    def offset(self, dx=0,  dy=0):
+        # TODO round offset to file resolution
+        self.objects = [ obj.with_offset(dx, dy) for obj in self.objects ]
 
-        last_x = 0
-        last_y = 0
-        last_rx = 0
-        last_ry = 0
+    def rotate(self, angle:'radians', center=(0,0)):
+        """ Rotate file contents around given point.
 
-        for macro in self.aperture_macros.values():
-            macro.rotate(angle, center)
+            Arguments:
+            angle -- Rotation angle in radians counter-clockwise.
+            center -- Center of rotation (default: document origin (0, 0))
 
-        for statement in self.main_statements:
-            if isinstance(statement, CoordStmt) and statement.x != None and statement.y != None:
+            Note that when rotating by odd angles other than 0, 90, 180 or 270 degrees this method may replace standard
+            rect and oblong apertures by macro apertures. Existing macro apertures are re-written.
+        """
+        if angle % (2*math.pi) == 0:
+            return
 
-                if statement.i is not None and statement.j is not None:
-                    cx, cy = last_x + statement.i, last_y + statement.j
-                    cx, cy = rotate_point((cx, cy), angle, center)
-                    statement.i, statement.j = cx - last_rx, cy - last_ry
+        # First, rotate apertures. We do this separately from rotating the individual objects below to rotate each
+        # aperture exactly once.
+        for ap in self.apertures:
+            ap.rotation += angle
 
-                last_x, last_y = statement.x, statement.y
-                last_rx, last_ry = rotate_point((statement.x, statement.y), angle, center)
-                statement.x, statement.y = last_rx, last_ry
+        for obj in self.objects:
+            obj.rotate(rotation, *center)
     
-    def negate_polarity(self):
-        for statement in self.main_statements:
-            if isinstance(statement, LPParamStmt):
-                statement.lp = 'dark' if statement.lp == 'clear' else 'clear'
+    def invert_polarity(self):
+        for obj in self.objects:
+            obj.polarity_dark = not p.polarity_dark
     
-    def _generalize_apertures(self):
-        # For rotation, replace standard apertures with macro apertures.
-        if not any(isinstance(stm, ADParamStmt) and stm.shape in 'ROP' for stm in self.aperture_defs):
-            return
-
-        # find an unused macro name with the given prefix
-        def free_name(prefix):
-            return next(f'{prefix}_{i}' for i in count() if f'{prefix}_{i}' not in self.aperture_macros)
-        
-        rect = free_name('MACR')
-        self.aperture_macros[rect] = AMParamStmt.rectangle(rect, self.units)
-
-        obround_landscape = free_name('MACLO')
-        self.aperture_macros[obround_landscape] = AMParamStmt.landscape_obround(obround_landscape, self.units)
-
-        obround_portrait = free_name('MACPO')
-        self.aperture_macros[obround_portrait] = AMParamStmt.portrait_obround(obround_portrait, self.units)
-
-        polygon = free_name('MACP')
-        self.aperture_macros[polygon] = AMParamStmt.polygon(polygon, self.units)
 
-        for statement in self.aperture_defs:
-            if isinstance(statement, ADParamStmt):
-                if statement.shape == 'R':
-                    statement.shape = rect
-
-                elif statement.shape == 'O':
-                    x, y, *_ = *statement.modifiers[0], 0, 0
-                    statement.shape = obround_landscape if x > y else obround_portrait
-
-                elif statement.shape == 'P':
-                    statement.shape = polygon
-
-
-@dataclass
 class GraphicsState:
     polarity_dark : bool = True
+    image_polarity : str = 'positive' # IP image polarity; deprecated
     point : tuple = None
-    aperture : ApertureDefStmt = None
+    aperture : Aperture = None
     interpolation_mode : InterpolationModeStmt = None
     multi_quadrant_mode : bool = None # used only for syntax checking
+    aperture_mirroring = (False, False) # LM mirroring (x, y)
+    aperture_rotation = 0 # LR rotation in degrees, 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 degrees 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, aperture_map=None):
+        self._mat = None
+        if aperture_map is not None:
+            self.aperture_map = aperture_map
+
+    def __setattr__(self, name, value):
+        # input validation
+        if name == 'image_axes' and value not in [None, 'AXBY', 'AYBX']:
+            raise ValueError('image_axes must be either "AXBY", "AYBX" or None')
+        elif name == 'image_rotation' and value not in [0, 90, 180, 270]:
+            raise ValueError('image_rotation must be 0, 90, 180 or 270')
+        elif name == 'image_polarity' and value not in ['positive', 'negative']:
+            raise ValueError('image_polarity must be either "positive" or "negative"')
+        elif name == 'image_mirror' and len(value) != 2:
+            raise ValueError('mirror_image must be 2-tuple of bools: (mirror_a, mirror_b)')
+        elif name == 'image_offset' and len(value) != 2:
+            raise ValueError('image_offset must be 2-tuple of floats: (offset_a, offset_b)')
+        elif name == 'image_scale' and len(value) != 2:
+            raise ValueError('image_scale must be 2-tuple of floats: (scale_a, scale_b)')
+
+        # polarity handling
+        if name == 'image_polarity': # global IP statement image polarity, can only be set at beginning of file
+            if self.image_polarity == '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
+            if self.image_polarity == 'negative':
+                value = not value
+
+        super().__setattr__(name, value)
+
+    def _update_xform(self):
+        a, b = 1, 0
+        c, d = 0, 1
+        off_x, off_y = self.image_offset
+
+        if self.image_mirror[0]:
+            a = -1
+        if self.image_mirror[1]:
+            d = -1
+
+        a *= self.image_scale[0]
+        d *= self.image_scale[1]
+
+        if ir == 90:
+            a, b, c, d = 0, -d, a, 0
+            off_x, off_y = off_y, -off_x
+        elif ir == 180:
+            a, b, c, d = -a, 0, 0, -d
+            off_x, off_y = -off_x, -off_y
+        elif ir == 270:
+            a, b, c, d = 0, d, -a, 0
+            off_x, off_y = -off_y, off_x
+
+        self.image_offset = off_x, off_y
+        self._mat = a, b, c, d
+    
+    def map_coord(self, x, y, relative=False):
+        if self._mat is None:
+            self._update_xform()
+        a, b, c, d = self.mat
+
+        if not relative:
+            return (a*x + b*y + self.image_offset[0]), (c*x + d*y + self.image_offset[1])
+        else
+            # Apply mirroring, scale and rotation, but do not apply offset
+            return (a*x + b*y), (c*x + d*y)
 
     def flash(self, x, y):
-        self.point = (x, y)
-        return Aperture(self.aperture, x, y)
+        return gp.Flash(self.aperture, *self.map_coord(x, y), polarity_dark=self.polarity_dark)
 
-    def interpolate(self, x, y, i=None, j=None):
+    def interpolate(self, x, y, i=None, j=None, aperture=True):
         if self.interpolation_mode == LinearModeStmt:
             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(x, y)
+            return self._create_line(x, y, aperture)
 
         else:
-            return self._create_arc(x, y, i, j)
+            return self._create_arc(x, y, i, j, aperture)
+
+    def _create_line(self, x, y, aperture=True):
+        old_point, self.point = self.point, self._map_coord(x, y)
+        return go.Line(old_point, self.point, self.aperture if aperture else None, self.polarity_dark)
 
-    def _create_line(self, x, y):
-        old_point, self.point = self.point, (x, y)
-        return Line(old_point, self.point, self.aperture, self.polarity_dark)
+    def _create_arc(self, x, y, i, j, aperture=True):
+        old_point, self.point = self.point, self._map_coord(x, y)
+        direction = 'ccw' if self.interpolation_mode == CircularCCWModeStmt else 'cw'
+        return go.Arc.from_coords(old_point, self.point, *self.map_coord(i, j, relative=True),
+                flipped=(direction == 'cw'), self.aperture if aperture else None, self.polarity_dark)
 
-    def _create_arc(self, x, y, i, j):
-        if self.multi_quadrant_mode is None:
-            warnings.warn('Circular arc interpolation without explicit G75 Single-Quadrant mode statement. '\
-                    'This can cause problems with older gerber interpreters.', SyntaxWarning)
+    # Helpers for gerber generation
+    def set_polarity(self, polarity_dark):
+        if self.polarity_dark != polarity_dark:
+            self.polarity_dark = polarity_dark
+            yield LoadPolarityStmt(polarity_dark)
 
-        elif self.multi_quadrant_mode:
-            raise SyntaxError('Circular arc interpolation in multi-quadrant mode (G74) is not implemented.')
+    def set_aperture(self, aperture):
+        if self.aperture != aperture:
+            self.aperture = aperture
+            yield ApertureStmt(self.aperture_map[aperture])
 
-        old_point, self.point = self.point, (x, y)
-        direction = 'ccw' if self.interpolation_mode == CircularCCWModeStmt else 'cw'
-        return Arc(old_point, self.point, (i, j), direction, self.aperture, self.polarity_dark):
+    def set_current_point(self, point):
+        if self.point != point:
+            self.point = point
+            yield MoveStmt(*point)
+
+    def set_interpolation_mode(self, mode):
+        if self.interpolation_mode != mode:
+            gs.interpolation_mode = mode
+            yield mode()
 
 
 class GerberParser:
@@ -304,7 +296,7 @@ class GerberParser:
     STATEMENT_REGEXES = {
         'unit_mode': r"MO(?P<unit>(MM|IN))",
         'interpolation_mode': r"(?P<code>G0?[123]|G74|G75)?",
-        'coord': = fr"(X(?P<x>{NUMBER}))?(Y(?P<y>{NUMBER}))?" \
+        'coord': fr"(X(?P<x>{NUMBER}))?(Y(?P<y>{NUMBER}))?" \
             fr"(I(?P<i>{NUMBER}))?(J(?P<j>{NUMBER}))?" \
             fr"(?P<operation>D0?[123])?\*",
         'aperture': r"(G54|G55)?D(?P<number>\d+)\*",
@@ -334,43 +326,19 @@ class GerberParser:
     STATEMENT_REGEXES = { key: re.compile(value) for key, value in STATEMENT_REGEXES.items() }
 
 
-    def __init__(self, include_dir=None):
+    def __init__(self, target, include_dir=None):
         """ Pass an include dir to enable IF include statements (potentially DANGEROUS!). """
+        self.target = target
         self.include_dir = include_dir
         self.include_stack = []
-        self.settings = FileSettings()
-        self.current_region = None
+        self.file_settings = FileSettings()
         self.graphics_state = GraphicsState()
-
-        self.statements = []
-        self.primitives = []
-        self.apertures = {}
+        self.aperture_map = {}
+        self.current_region = None
+        self.eof_found = False
+        self.multi_quadrant_mode = None # used only for syntax checking
         self.macros = {}
-        self.x = 0
-        self.y = 0
         self.last_operation = None
-        self.op = "D02"
-        self.aperture = 0
-        self.interpolation = 'linear'
-        self.direction = 'clockwise'
-        self.image_polarity = 'positive'
-        self.level_polarity = 'dark'
-        self.region_mode = 'off'
-        self.step_and_repeat = (1, 1, 0, 0)
-
-    def parse(self, data):
-        for stmt in self._parse(data):
-            if self.current_region is None:
-                self.statements.append(stmt)
-            else:
-                self.current_region.append(stmt)
-            self.evaluate(stmt)
-
-        # Initialize statement units
-        for stmt in self.statements:
-            stmt.units = self.settings.units
-
-        return GerberFile(self.statements, self.settings, self.primitives, self.apertures.values())
 
     @classmethod
     def _split_commands(kls, data):
@@ -402,49 +370,48 @@ class GerberParser:
                     yield word_command
                 start = cur + 1
 
-    def dump_json(self):
-        return json.dumps({"statements": [stmt.__dict__ for stmt in self.statements]})
-
-    def dump_str(self):
-        return '\n'.join(str(stmt) for stmt in self.statements) + '\n'
-
-    def _parse(self, data):
+    def parse(self, data):
         for line in self._split_commands(data):
             # We cannot assume input gerber to use well-formed statement delimiters. Thus, we may need to parse
             # multiple statements from one line.
             while line:
+                if line.strip() and self.eof_found:
+                    warnings.warn('Data found in gerber file after EOF.', SyntaxWarning)
                 for name, le_regex in self.STATEMENT_REGEXES.items():
-                    if (match := le_regex.match(line))
-                        yield from getattr(self, f'_parse_{name}')(self, match.groupdict())
+                    if (match := le_regex.match(line)):
+                        getattr(self, f'_parse_{name}')(self, match.groupdict())
                         line = line[match.end(0):]
                         break
 
                 else:
                     if line[-1] == '*':
-                        yield UnknownStmt(line)
+                        warnings.warn(f'Unknown statement found: "{line}", ignoring.', SyntaxWarning)
+                        self.target.comments.append(f'Unknown statement found: "{line}", ignoring.')
                         line = ''
+        
+        self.target.apertures = list(self.aperture_map.values())
+
+        if not self.eof_found:
+                    warnings.warn('File is missing mandatory M02 EOF marker. File may be truncated.', SyntaxWarning)
 
     def _parse_interpolation_mode(self, match):
         if match['code'] == 'G01':
             self.graphics_state.interpolation_mode = LinearModeStmt
-            yield LinearModeStmt()
         elif match['code'] == 'G02':
             self.graphics_state.interpolation_mode = CircularCWModeStmt
-            yield CircularCWModeStmt()
         elif match['code'] == 'G03':
             self.graphics_state.interpolation_mode = CircularCCWModeStmt
-            yield CircularCCWModeStmt()
         elif match['code'] == 'G74':
-            self.graphics_state.multi_quadrant_mode = True # used only for syntax checking
+            self.multi_quadrant_mode = True # used only for syntax checking
         elif match['code'] == 'G75':
-            self.graphics_state.multi_quadrant_mode = False
+            self.multi_quadrant_mode = False
             # we always emit a G75 at the beginning of the file.
 
     def _parse_coord(self, match):
-        x = parse_gerber_value(match['x'], self.settings)
-        y = parse_gerber_value(match['y'], self.settings)
-        i = parse_gerber_value(match['i'], self.settings)
-        j = parse_gerber_value(match['j'], self.settings)
+        x = self.file_settings.parse_gerber_value(match['x'])
+        y = self.file_settings.parse_gerber_value(match['y'])
+        i = self.file_settings.parse_gerber_value(match['i'])
+        j = self.file_settings.parse_gerber_value(match['j'])
 
         if not (op := match['operation']):
             if self.last_operation == 'D01':
@@ -455,8 +422,21 @@ class GerberParser:
                 raise SyntaxError('Ambiguous coordinate statement. Coordinate statement does not have an operation '\
                                   'mode and the last operation statement was not D01.')
 
+        self.last_operation = op
+
         if op in ('D1', 'D01'):
-            yield self.graphics_state.interpolate(x, y, i, j)
+            if self.graphics_state.interpolation_mode != LinearModeStmt:
+                if self.multi_quadrant_mode is None:
+                    warnings.warn('Circular arc interpolation without explicit G75 Single-Quadrant mode statement. '\
+                            'This can cause problems with older gerber interpreters.', SyntaxWarning)
+
+                elif self.multi_quadrant_mode:
+                    raise SyntaxError('Circular arc interpolation in multi-quadrant mode (G74) is not implemented.')
+
+            if self.current_region is None:
+                self.target.objects.append(self.graphics_state.interpolate(x, y, i, j))
+            else:
+                self.current_region.append(self.graphics_state.interpolate(x, y, i, j))
 
         else:
             if i is not None or j is not None:
@@ -464,380 +444,170 @@ class GerberParser:
                 
             if op in ('D2', 'D02'):
                 self.graphics_state.point = (x, y)
+                if self.current_region:
+                    # Start a new region for every outline. As gerber has no concept of fill rules or winding numbers,
+                    # it does not make a graphical difference, and it makes the implementation slightly easier.
+                    self.target.objects.append(self.current_region)
+                    self.current_region = gp.Region(polarity_dark=gp.polarity_dark)
 
             else: # D03
-                yield self.graphics_state.flash(x, y)
-
+                if self.current_region is None:
+                    self.target.objects.append(self.graphics_state.flash(x, y))
+                else:
+                    raise SyntaxError('DO3 flash statement inside region')
 
     def _parse_aperture(self, match):
         number = int(match['number'])
         if number < 10:
             raise SyntaxError(f'Invalid aperture number {number}: Aperture number must be >= 10.')
 
-        if number not in self.apertures:
+        if number not in self.aperture_map:
             raise SyntaxError(f'Tried to access undefined aperture {number}')
 
-        self.graphics_state.aperture = self.apertures[number]
+        self.graphics_state.aperture = self.aperture_map[number]
+
+    def _parse_aperture_definition(self, match):
+        # number, shape, modifiers
+        modifiers = [ float(val) for val in match['modifiers'].split(',') ]
+
+        aperture_classes = {
+                'C': ApertureCircle,
+                'R': ApertureRectangle,
+                'O': ApertureObround,
+                'P': AperturePolygon,
+            }
+
+        if (kls := aperture_classes.get(match['shape'])):
+            new_aperture = kls(*modifiers)
+
+        elif (macro := self.target.aperture_macros.get(match['shape'])):
+            new_aperture = ApertureMacroInstance(match['shape'], macro, modifiers)
+
+        else:
+            raise ValueError(f'Aperture shape "{match["shape"]}" is unknown')
+
+        self.aperture_map[int(match['number'])] = new_aperture
+
+    def _parse_aperture_macro(self, match):
+        self.target.aperture_macros[match['name']] = ApertureMacro.parse(match['macro'])
     
     def _parse_format_spec(self, match):
         # This is a common problem in Eagle files, so just suppress it
-        self.settings.zero_suppression = {'L': 'leading', 'T': 'trailing'}.get(match['zero'], 'leading')
-        self.settings.notation = 'absolute' if match.['notation'] == 'A' else 'incremental'
+        self.file_settings.zero_suppression = {'L': 'leading', 'T': 'trailing'}.get(match['zero'], 'leading')
+        self.file_settings.notation = 'absolute' if match['notation'] == 'A' else 'incremental'
 
         if match['x'] != match['y']:
             raise SyntaxError(f'FS specifies different coordinate formats for X and Y ({match["x"]} != {match["y"]})')
-        self.settings.number_format = int(match['x'][0]), int(match['x'][1])
-
-        yield from () # We always force a format spec statement at the beginning of the file
+        self.file_settings.number_format = int(match['x'][0]), int(match['x'][1])
 
     def _parse_unit_mode(self, match):
         if match['unit'] == 'MM':
-            self.settings.units = 'mm'
+            self.file_settings.units = 'mm'
         else:
-            self.settings.units = 'inch'
-
-        yield from () # We always force a unit mode statement at the beginning of the file
+            self.file_settings.units = 'inch'
 
     def _parse_load_polarity(self, match):
-        yield LoadPolarityStmt(dark=match['polarity'] == 'D')
+        self.graphics_state.polarity_dark = match['polarity'] == 'D'
 
     def _parse_offset(self, match):
         a, b = match['a'], match['b']
         a = float(a) if a else 0
         b = float(b) if b else 0
-        self.settings.offset = a, b
-        yield from () # Handled by coordinate normalization
+        self.graphics_state.offset = a, b
 
     def _parse_include_file(self, match):
         if self.include_dir is None:
-            warnings.warn('IF Include File statement found, but includes are deactivated.', ResourceWarning)
+            warnings.warn('IF include statement found, but includes are deactivated.', ResourceWarning)
         else:
-            warnings.warn('IF Include File statement found. Includes are activated, but is this really a good idea?', ResourceWarning)
+            warnings.warn('IF include statement found. Includes are activated, but is this really a good idea?', ResourceWarning)
 
         include_file = self.include_dir / param["filename"]
-        if include_file in self.include_stack
-            raise ValueError("Recusive file inclusion via IF include statement.")
+        # Do not check if path exists to avoid leaking existence via error message
+        include_file = include_file.resolve(strict=False)
+        
+        if not include_file.is_relative_to(self.include_dir):
+            raise FileNotFoundError('Attempted traversal to parent of include dir in path from IF include statement')
+
+        if not include_file.is_file():
+            raise FileNotFoundError('File pointed to by IF include statement does not exist')
+
+        if include_file in self.include_stack:
+            raise ValueError("Recusive inclusion via IF include statement.")
         self.include_stack.append(include_file)
 
         # Spec 2020-09 section 3.1: Gerber files must use UTF-8
-        yield from self._parse(f.read_text(encoding='UTF-8'))
+        self._parse(f.read_text(encoding='UTF-8'))
         self.include_stack.pop()
 
-
     def _parse_image_name(self, match):
         warnings.warn('Deprecated IN (image name) statement found. This deprecated since rev. I4 (Oct 2013).',
                 DeprecationWarning)
-        yield CommentStmt(f'Image name: {match["name"]}')
+        self.target.comments.append(f'Image name: {match["name"]}')
 
     def _parse_load_name(self, match):
         warnings.warn('Deprecated LN (load name) statement found. This deprecated since rev. I4 (Oct 2013).',
                 DeprecationWarning)
-        yield CommentStmt(f'Name of subsequent part: {match["name"]}')
 
     def _parse_axis_selection(self, match):
         warnings.warn('Deprecated AS (axis selection) statement found. This deprecated since rev. I1 (Dec 2012).',
                 DeprecationWarning)
-        self.settings.output_axes = match['axes']
-        yield from () # Handled by coordinate normalization
+        self.graphics_state.output_axes = match['axes']
 
     def _parse_image_polarity(self, match):
         warnings.warn('Deprecated IP (image polarity) statement found. This deprecated since rev. I4 (Oct 2013).',
                 DeprecationWarning)
-        self.settings.image_polarity = match['polarity']
-        yield from () # We always emit this in the header
+        self.graphics_state.image_polarity = match['polarity']
     
     def _parse_image_rotation(self, match):
         warnings.warn('Deprecated IR (image rotation) statement found. This deprecated since rev. I1 (Dec 2012).',
                 DeprecationWarning)
-        self.settings.image_rotation = int(match['rotation'])
-        yield from () # Handled by coordinate normalization
+        self.graphics_state.image_rotation = int(match['rotation'])
 
     def _parse_mirror_image(self, match):
         warnings.warn('Deprecated MI (mirror image) statement found. This deprecated since rev. I1 (Dec 2012).',
                 DeprecationWarning)
-        self.settings.mirror = bool(int(match['a'] or '0')), bool(int(match['b'] or '1'))
-        yield from () # Handled by coordinate normalization
+        self.graphics_state.mirror = bool(int(match['a'] or '0')), bool(int(match['b'] or '1'))
 
     def _parse_scale_factor(self, match):
         warnings.warn('Deprecated SF (scale factor) statement found. This deprecated since rev. I1 (Dec 2012).',
                 DeprecationWarning)
         a = float(match['a']) if match['a'] else 1.0
         b = float(match['b']) if match['b'] else 1.0
-        self.settings.scale_factor = a, b
-        yield from () # Handled by coordinate normalization
+        self.graphics_state.scale_factor = a, b
 
     def _parse_comment(self, match):
-        yield CommentStmt(match["comment"])
+        self.target.comments.append(match["comment"])
 
     def _parse_region_start(self, _match):
-        current_region = RegionGroup()
+        self.current_region = gp.Region(polarity_dark=gp.polarity_dark)
 
     def _parse_region_end(self, _match):
         if self.current_region is None:
             raise SyntaxError('Region end command (G37) outside of region')
         
-        yield self.current_region
+        if self.current_region: # ignore empty regions
+            self.target.objects.append(self.current_region)
         self.current_region = None
 
     def _parse_old_unit(self, match):
-        self.settings.units = 'inch' if match['mode'] == 'G70' else 'mm'
+        self.file_settings.units = 'inch' if match['mode'] == 'G70' else 'mm'
         warnings.warn(f'Deprecated {match["mode"]} unit mode statement found. This deprecated since 2012.',
                     DeprecationWarning)
-        yield CommentStmt(f'Replaced deprecated {match["mode"]} unit mode statement with MO statement')
-        yield UnitStmt()
+        self.target.comments.append('Replaced deprecated {match["mode"]} unit mode statement with MO statement')
 
     def _parse_old_unit(self, match):
         # FIXME make sure we always have FS at end of processing.
         self.settings.notation = 'absolute' if match['mode'] == 'G90' else 'incremental'
         warnings.warn(f'Deprecated {match["mode"]} notation mode statement found. This deprecated since 2012.',
                     DeprecationWarning)
-        yield CommentStmt(f'Replaced deprecated {match["mode"]} notation mode statement with FS statement')
+        self.target.comments.append('Replaced deprecated {match["mode"]} notation mode statement with FS statement')
     
     def _parse_eof(self, _match):
-        yield EofStmt()
+        self.eof_found = True
 
     def _parse_ignored(self, match):
-        yield CommentStmt(f'Ignoring {match{"stmt"]} statement.')
-
-    def _parse_aperture_definition(self, match):
-        modifiers = [ float(mod) for mod in match['modifiers'].split(',') ]
-        if match['shape'] == 'C':
-            aperture = ApertureCircle(*modifiers)
-
-        elif match['shape'] == 'R'
-            aperture = ApertureRectangle(*modifiers)
-
-        elif shape == 'O':
-            aperture = ApertureObround(*modifiers)
-
-        elif shape == 'P':
-            aperture = AperturePolygon(*modifiers)
-
-        else:
-            aperture = self.macros[shape].build(modifiers)
-
-        self.apertures[d] = aperture
-
-
-
-    def evaluate(self, stmt):
-        """ Evaluate Gerber statement and update image accordingly.
-
-        This method is called once for each statement in the file as it
-        is parsed.
+        pass
 
-        Parameters
-        ----------
-        statement : Statement
-            Gerber/Excellon statement to evaluate.
-
-        """
-        if isinstance(stmt, CoordStmt):
-            self._evaluate_coord(stmt)
-
-        elif isinstance(stmt, ParamStmt):
-            self._evaluate_param(stmt)
-
-        elif isinstance(stmt, ApertureStmt):
-            self._evaluate_aperture(stmt)
-
-        elif isinstance(stmt, (RegionModeStmt, QuadrantModeStmt)):
-            self._evaluate_mode(stmt)
-
-        elif isinstance(stmt, (CommentStmt, UnknownStmt, DeprecatedStmt, EofStmt)):
-            return
-
-        else:
-            raise Exception("Invalid statement to evaluate")
-
-    def _evaluate_mode(self, stmt):
-        if stmt.type == 'RegionMode':
-            if self.region_mode == 'on' and stmt.mode == 'off':
-                # Sometimes we have regions that have no points. Skip those
-                if self.current_region:
-                    self.primitives.append(Region(self.current_region,
-                                                  level_polarity=self.level_polarity, units=self.settings.units))
-
-                self.current_region = None
-            self.region_mode = stmt.mode
-        elif stmt.type == 'QuadrantMode':
-            self.quadrant_mode = stmt.mode
-
-    def _evaluate_param(self, stmt):
-        elif stmt.param == "LP":
-            self.level_polarity = stmt.lp
-        elif stmt.param == "AM":
-            self.macros[stmt.name] = stmt
-        elif stmt.param == "AD":
-            self._define_aperture(stmt.d, stmt.shape, stmt.modifiers)
-
-    def _evaluate_coord(self, stmt):
-        x = self.x if stmt.x is None else stmt.x
-        y = self.y if stmt.y is None else stmt.y
-
-        if stmt.function in ("G01", "G1"):
-            self.interpolation = 'linear'
-        elif stmt.function in ('G02', 'G2', 'G03', 'G3'):
-            self.interpolation = 'arc'
-            self.direction = ('clockwise' if stmt.function in
-                              ('G02', 'G2') else 'counterclockwise')
-
-        if stmt.only_function:
-            # Sometimes we get a coordinate statement
-            # that only sets the function. If so, don't
-            # try futher otherwise that might draw/flash something
-            return
-
-        if stmt.op:
-            self.op = stmt.op
-        else:
-            # no implicit op allowed, force here if coord block doesn't have it
-            stmt.op = self.op
-
-        if self.op == "D01" or self.op == "D1":
-            start = (self.x, self.y)
-            end = (x, y)
-
-            if self.interpolation == 'linear':
-                if self.region_mode == 'off':
-                    self.primitives.append(Line(start, end,
-                                                self.apertures[self.aperture],
-                                                level_polarity=self.level_polarity,
-                                                units=self.settings.units))
-                else:
-                    # from gerber spec revision J3, Section 4.5, page 55:
-                    #  The segments are not graphics objects in themselves; segments are part of region which is the graphics object. The segments have no thickness.
-                    # The current aperture is associated with the region.
-                    # This has no graphical effect, but allows all its attributes to
-                    # be applied to the region.
-
-                    if self.current_region is None:
-                        self.current_region = [Line(start, end,
-                                                    self.apertures.get(self.aperture,
-                                                                       Circle((0, 0), 0)),
-                                                    level_polarity=self.level_polarity,
-                                                    units=self.settings.units), ]
-                    else:
-                        self.current_region.append(Line(start, end,
-                                                        self.apertures.get(self.aperture,
-                                                                           Circle((0, 0), 0)),
-                                                        level_polarity=self.level_polarity,
-                                                        units=self.settings.units))
-            else:
-                i = 0 if stmt.i is None else stmt.i
-                j = 0 if stmt.j is None else stmt.j
-                center = self._find_center(start, end, (i, j))
-                if self.region_mode == 'off':
-                    self.primitives.append(Arc(start, end, center, self.direction,
-                                               self.apertures[self.aperture],
-                                               quadrant_mode=self.quadrant_mode,
-                                               level_polarity=self.level_polarity,
-                                               units=self.settings.units))
-                else:
-                    if self.current_region is None:
-                        self.current_region = [Arc(start, end, center, self.direction,
-                                                   self.apertures.get(self.aperture, Circle((0,0), 0)),
-                                                   quadrant_mode=self.quadrant_mode,
-                                                   level_polarity=self.level_polarity,
-                                                   units=self.settings.units),]
-                    else:
-                        self.current_region.append(Arc(start, end, center, self.direction,
-                                                       self.apertures.get(self.aperture, Circle((0,0), 0)),
-                                                       quadrant_mode=self.quadrant_mode,
-                                                       level_polarity=self.level_polarity,
-                                                       units=self.settings.units))
-                    # Gerbv seems to reset interpolation mode in regions..
-                    # TODO: Make sure this is right.
-                    self.interpolation = 'linear'
-
-        elif self.op == "D02" or self.op == "D2":
-
-            if self.region_mode == "on":
-                # D02 in the middle of a region finishes that region and starts a new one
-                if self.current_region and len(self.current_region) > 1:
-                    self.primitives.append(Region(self.current_region,
-                                                  level_polarity=self.level_polarity,
-                                                  units=self.settings.units))
-                self.current_region = None
-
-        elif self.op == "D03" or self.op == "D3":
-            primitive = copy.deepcopy(self.apertures[self.aperture])
-
-            if primitive is not None:
-
-                if not isinstance(primitive, AMParamStmt):
-                    primitive.position = (x, y)
-                    primitive.level_polarity = self.level_polarity
-                    primitive.units = self.settings.units
-                    self.primitives.append(primitive)
-                else:
-                    # Aperture Macro
-                    for am_prim in primitive.primitives:
-                        renderable = am_prim.to_primitive((x, y),
-                                                          self.level_polarity,
-                                                          self.settings.units)
-                        if renderable is not None:
-                            self.primitives.append(renderable)
-        self.x, self.y = x, y
-
-    def _find_center(self, start, end, offsets):
-        """
-        In single quadrant mode, the offsets are always positive, which means
-        there are 4 possible centers. The correct center is the only one that
-        results in an arc with sweep angle of less than or equal to 90 degrees
-        in the specified direction
-        """
-        two_pi = 2 * math.pi
-        if self.quadrant_mode == 'single-quadrant':
-            # The Gerber spec says single quadrant only has one possible center,
-            # and you can detect it based on the angle. But for real files, this
-            # seems to work better - there is usually only one option that makes
-            # sense for the center (since the distance should be the same
-            # from start and end). We select the center with the least error in
-            # radius from all the options with a valid sweep angle.
-
-            sqdist_diff_min = sys.maxsize
-            center = None
-            for factors in [(1, 1), (1, -1), (-1, 1), (-1, -1)]:
-
-                test_center = (start[0] + offsets[0] * factors[0],
-                               start[1] + offsets[1] * factors[1])
-
-                # Find angle from center to start and end points
-                start_angle = math.atan2(*reversed([_start - _center for _start, _center in zip(start, test_center)]))
-                end_angle = math.atan2(*reversed([_end - _center for _end, _center in zip(end, test_center)]))
-
-                # Clamp angles to 0, 2pi
-                theta0 = (start_angle + two_pi) % two_pi
-                theta1 = (end_angle + two_pi) % two_pi
-
-                # Determine sweep angle in the current arc direction
-                if self.direction == 'counterclockwise':
-                    sweep_angle = abs(theta1 - theta0)
-                else:
-                    theta0 += two_pi
-                    sweep_angle = abs(theta0 - theta1) % two_pi
-
-                # Calculate the radius error
-                sqdist_start = sq_distance(start, test_center)
-                sqdist_end = sq_distance(end, test_center)
-                sqdist_diff = abs(sqdist_start - sqdist_end)
-
-                # Take the option with the lowest radius error from the set of
-                # options with a valid sweep angle
-                # In some rare cases, the sweep angle is numerically (10**-14) above pi/2
-                # So it is safer to compare the angles with some tolerance
-                is_lowest_radius_error = sqdist_diff < sqdist_diff_min
-                is_valid_sweep_angle = sweep_angle >= 0 and sweep_angle <= math.pi / 2.0 + 1e-6
-                if is_lowest_radius_error and is_valid_sweep_angle:
-                    center = test_center
-                    sqdist_diff_min = sqdist_diff
-            return center
-        else:
-            return (start[0] + offsets[0], start[1] + offsets[1])
-
-    def _evaluate_aperture(self, stmt):
-        self.aperture = stmt.d
 
 def _match_one(expr, data):
     match = expr.match(data)
@@ -855,132 +625,3 @@ def _match_one_from_many(exprs, data):
 
     return ({}, None)
 
-class GerberContext(FileSettings):
-    TYPE_NONE = 'none'
-    TYPE_AM = 'am'
-    TYPE_AD = 'ad'
-    TYPE_MAIN = 'main'
-    IP_LINEAR = 'linear'
-    IP_ARC = 'arc'
-    DIR_CLOCKWISE = 'cw'
-    DIR_COUNTERCLOCKWISE = 'ccw'
-
-    @classmethod
-    def from_settings(cls, settings):
-        return cls(settings.notation, settings.units, settings.zero_suppression,
-                   settings.format, settings.zeros, settings.angle_units)
-
-    def __init__(self, notation='absolute', units='inch',
-                 zero_suppression=None, format=(2, 5), zeros=None,
-                 angle_units='degrees',
-                 mirror=(False, False), offset=(0., 0.), scale=(1., 1.),
-                 angle=0., axis='xy'):
-        super(GerberContext, self).__init__(notation, units, zero_suppression, 
-                                      format, zeros, angle_units)
-        self.mirror = mirror
-        self.offset = offset
-        self.scale = scale
-        self.angle = angle
-        self.axis = axis
-
-        self.is_negative = False
-        self.no_polarity = True
-        self.in_single_quadrant_mode = False
-        self.op = None
-        self.interpolation = self.IP_LINEAR
-        self.direction = self.DIR_CLOCKWISE
-        self.x, self.y = 0, 0
-
-    def update_from_statement(self, stmt):
-        if isinstance(stmt, MIParamStmt):
-            self.mirror = (stmt.a, stmt.b)
-
-        elif isinstance(stmt, OFParamStmt):
-            self.offset = (stmt.a, stmt.b)
-
-        elif isinstance(stmt, SFParamStmt):
-            self.scale = (stmt.a, stmt.b)
-
-        elif isinstance(stmt, ASParamStmt):
-            self.axis = 'yx' if stmt.mode == 'AYBX' else 'xy'
-
-        elif isinstance(stmt, IRParamStmt):
-            self.angle = stmt.angle
-
-        elif isinstance(stmt, QuadrantModeStmt):
-            self.in_single_quadrant_mode = stmt.mode == 'single-quadrant'
-            stmt.mode = 'multi-quadrant'
-
-        elif isinstance(stmt, IPParamStmt):
-            self.is_negative = stmt.ip == 'negative'
-
-        elif isinstance(stmt, LPParamStmt):
-            self.no_polarity = False
-
-    @property
-    def matrix(self):
-        if self.axis == 'xy':
-            mx = -1 if self.mirror[0] else 1
-            my = -1 if self.mirror[1] else 1
-            return (
-                self.scale[0] * mx, self.offset[0],
-                self.scale[1] * my, self.offset[1],
-                self.scale[0] * mx, self.scale[1] * my)
-        else:
-            mx = -1 if self.mirror[1] else 1
-            my = -1 if self.mirror[0] else 1
-            return (
-                self.scale[1] * mx, self.offset[1],
-                self.scale[0] * my, self.offset[0],
-                self.scale[1] * mx, self.scale[0] * my)
-
-    def normalize_coordinates(self, stmt):
-        if stmt.function == 'G01' or stmt.function == 'G1':
-            self.interpolation = self.IP_LINEAR
-
-        elif stmt.function == 'G02' or stmt.function == 'G2':
-            self.interpolation = self.IP_ARC
-            self.direction = self.DIR_CLOCKWISE
-            if self.mirror[0] != self.mirror[1]:
-                stmt.function = 'G03'
-
-        elif stmt.function == 'G03' or stmt.function == 'G3':
-            self.interpolation = self.IP_ARC
-            self.direction = self.DIR_COUNTERCLOCKWISE
-            if self.mirror[0] != self.mirror[1]:
-                stmt.function = 'G02'
-
-        if stmt.only_function:
-            return
-
-        last_x, last_y = self.x, self.y
-        if self.notation == 'absolute':
-            x = stmt.x if stmt.x is not None else self.x
-            y = stmt.y if stmt.y is not None else self.y
-
-        else:
-            x = self.x + stmt.x if stmt.x is not None else 0
-            y = self.y + stmt.y if stmt.y is not None else 0
-
-        self.x, self.y = x, y
-        self.op = stmt.op if stmt.op is not None else self.op
-
-        stmt.op = self.op
-        stmt.x = self.matrix[0] * x + self.matrix[1]
-        stmt.y = self.matrix[2] * y + self.matrix[3]
-
-        if stmt.op == 'D01' and self.interpolation == self.IP_ARC:
-            qx, qy = 1, 1
-            if self.in_single_quadrant_mode:
-                if self.direction == self.DIR_CLOCKWISE:
-                    qx = 1 if y > last_y else -1
-                    qy = 1 if x < last_x else -1
-                else:
-                    qx = 1 if y < last_y else -1
-                    qy = 1 if x > last_x else -1
-                if last_x == x and last_y == y:
-                    qx, qy = 0, 0
-
-            stmt.i = qx * self.matrix[4] * stmt.i if stmt.i is not None else 0
-            stmt.j = qy * self.matrix[5] * stmt.j if stmt.j is not None else 0
-
diff --git a/gerbonara/gerber/utils.py b/gerbonara/gerber/utils.py
index 492321a..122dd5a 100644
--- a/gerbonara/gerber/utils.py
+++ b/gerbonara/gerber/utils.py
@@ -29,148 +29,6 @@ from math import radians, sin, cos, sqrt, atan2, pi
 MILLIMETERS_PER_INCH = 25.4
 
 
-def parse_gerber_value(value, settings):
-    """ Convert gerber/excellon formatted string to floating-point number
-
-    .. note::
-        Format and zero suppression are configurable. Note that the Excellon
-        and Gerber formats use opposite terminology with respect to leading
-        and trailing zeros. The Gerber format specifies which zeros are
-        suppressed, while the Excellon format specifies which zeros are
-        included. This function uses the Gerber-file convention, so an
-        Excellon file in LZ (leading zeros) mode would use
-        `zero_suppression='trailing'`
-
-
-    Parameters
-    ----------
-    value : string
-        A Gerber/Excellon-formatted string representing a numerical value.
-
-    format :  tuple (int,int)
-        Gerber/Excellon precision format expressed as a tuple containing:
-        (number of integer-part digits, number of decimal-part digits)
-
-    zero_suppression : string
-        Zero-suppression mode. May be 'leading', 'trailing' or 'none'
-
-    Returns
-    -------
-    value : float
-        The specified value as a floating-point number.
-
-    """
-
-    if not value:
-        return None
-
-    # Handle excellon edge case with explicit decimal. "That was easy!"
-    if '.' in value:
-        return float(value)
-
-    # Format precision
-    integer_digits, decimal_digits = settings.format
-    MAX_DIGITS = integer_digits + decimal_digits
-
-    # Absolute maximum number of digits supported. This will handle up to
-    # 6:7 format, which is somewhat supported, even though the gerber spec
-    # only allows up to 6:6
-    if MAX_DIGITS > 13 or integer_digits > 6 or decimal_digits > 7:
-        raise ValueError('Parser only supports precision up to 6:7 format')
-
-    # Remove extraneous information
-    value = value.lstrip('+')
-    negative = '-' in value
-    if negative:
-        value = value.lstrip('-')
-
-    missing_digits = MAX_DIGITS - len(value)
-
-    if settings.zero_suppression == 'trailing':
-        digits = list(value + ('0' * missing_digits))
-    elif settings.zero_suppression == 'leading':
-        digits = list(('0' * missing_digits) + value)
-    else:
-        digits = list(value)
-
-    result = float(
-        ''.join(digits[:integer_digits] + ['.'] + digits[integer_digits:]))
-    return -result if negative else result
-
-
-def write_gerber_value(value, settings):
-    """ Convert a floating point number to a Gerber/Excellon-formatted string.
-
-    .. note::
-        Format and zero suppression are configurable. Note that the Excellon
-        and Gerber formats use opposite terminology with respect to leading
-        and trailing zeros. The Gerber format specifies which zeros are
-        suppressed, while the Excellon format specifies which zeros are
-        included. This function uses the Gerber-file convention, so an
-        Excellon file in LZ (leading zeros) mode would use
-        `zero_suppression='trailing'`
-
-    Parameters
-    ----------
-    value : float
-        A floating point value.
-
-    format :  tuple (n=2)
-        Gerber/Excellon precision format expressed as a tuple containing:
-        (number of integer-part digits, number of decimal-part digits)
-
-    zero_suppression : string
-        Zero-suppression mode. May be 'leading', 'trailing' or 'none'
-
-    Returns
-    -------
-    value : string
-        The specified value as a Gerber/Excellon-formatted string.
-    """
-    
-    if format[0] == float:
-        return "%f" %value
-    
-    # Format precision
-    integer_digits, decimal_digits = settings.format
-    MAX_DIGITS = integer_digits + decimal_digits
-
-    if MAX_DIGITS > 13 or integer_digits > 6 or decimal_digits > 7:
-        raise ValueError('Parser only supports precision up to 6:7 format')
-
-    # Edge case... (per Gerber spec we should return 0 in all cases, see page
-    # 77)
-    if value == 0:
-        return '0'
-
-    # negative sign affects padding, so deal with it at the end...
-    negative = value < 0.0
-    if negative:
-        value = -1.0 * value
-
-    # Format string for padding out in both directions
-    fmtstring = '%%0%d.0%df' % (MAX_DIGITS + 1, decimal_digits)
-    digits = [val for val in fmtstring % value if val != '.']
-
-    # If all the digits are 0, return '0'.
-    digit_sum = sum([int(digit) for digit in digits])
-    if digit_sum == 0:
-        return '0'
-
-    # Suppression...
-    if settings.zero_suppression == 'trailing':
-        while digits and digits[-1] == '0':
-            digits.pop()
-    elif settings.zero_suppression == 'leading':
-        while digits and digits[0] == '0':
-            digits.pop(0)
-
-    if not digits:
-        return '0'
-
-    return ''.join(digits) if not negative else ''.join(['-'] + digits)
-
-
 def decimal_string(value, precision=6, padding=False):
     """ Convert float to string with limited precision
 
@@ -208,32 +66,6 @@ def decimal_string(value, precision=6, padding=False):
     else:
         return int(floatstr)
 
-
-def detect_file_format(data):
-    """ Determine format of a file
-
-    Parameters
-    ----------
-    data : string
-        string containing file data.
-
-    Returns
-    -------
-    format : string
-        File format. 'excellon' or 'rs274x' or 'unknown'
-    """
-    lines = data.split('\n')
-    for line in lines:
-        if 'M48' in line:
-            return 'excellon'
-        elif '%FS' in line:
-            return 'rs274x'
-        elif ((len(line.split()) >= 2) and
-              (line.split()[0] == 'P') and (line.split()[1] == 'JOB')):
-            return 'ipc_d_356'
-    return 'unknown'
-
-
 def validate_coordinates(position):
     if position is not None:
         if len(position) != 2: