Merge pull request #3 from garretfick/merge-curtacircuitos

Merge curtacircuitos

8 files changed, 1366 insertions, 355 deletions

diff --git a/gerber/render/__init__.py b/gerber/render/__init__.py
index b4af4ad..f76d28f 100644
--- a/gerber/render/__init__.py
+++ b/gerber/render/__init__.py
@@ -24,5 +24,4 @@ SVG is the only supported format.
 """
 
 
-from svgwrite_backend import GerberSvgContext
-from cairo_backend import GerberCairoContext
+from .cairo_backend import GerberCairoContext
diff --git a/gerber/render/apertures.py b/gerber/render/apertures.py
deleted file mode 100644
index 52ae50c..0000000
--- a/gerber/render/apertures.py
+++ /dev/null
@@ -1,76 +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.
-"""
-gerber.render.apertures
-============
-**Gerber Aperture base classes**
-
-This module provides base classes for gerber apertures. These are used by
-the rendering engine to draw the gerber file.
-"""
-import math
-
-class Aperture(object):
-    """ Gerber Aperture base class
-    """
-    def draw(self, ctx, x, y):
-        raise NotImplementedError('The draw method must be implemented \
-                                  in an Aperture subclass.')
-
-    def flash(self, ctx, x, y):
-        raise NotImplementedError('The flash method must be implemented \
-                                  in an Aperture subclass.')
-
-    def _arc_params(self, startx,  starty, x, y, i, j):
-        center = (startx + i, starty + j)
-        radius = math.sqrt(math.pow(center[0] - x, 2) +
-                           math.pow(center[1] - y, 2))
-        delta_x0 = startx - center[0]
-        delta_y0 = center[1] - starty
-        delta_x1 = x - center[0]
-        delta_y1 = center[1] - y
-        start_angle = math.atan2(delta_y0, delta_x0)
-        end_angle = math.atan2(delta_y1, delta_x1)
-        return {'center': center, 'radius': radius,
-                'start_angle': start_angle, 'end_angle': end_angle}
-
-
-class Circle(Aperture):
-    """ Circular Aperture base class
-    """
-    def __init__(self, diameter=0.0):
-        self.diameter = diameter
-
-
-class Rect(Aperture):
-    """ Rectangular Aperture base class
-    """
-    def __init__(self, size=(0, 0)):
-        self.size = size
-
-
-class Obround(Aperture):
-    """ Obround Aperture base class
-    """
-    def __init__(self, size=(0, 0)):
-        self.size = size
-
-
-class Polygon(Aperture):
-    """ Polygon Aperture base class
-    """
-    pass
diff --git a/gerber/render/cairo_backend.py b/gerber/render/cairo_backend.py
index df513bb..8c7232f 100644
--- a/gerber/render/cairo_backend.py
+++ b/gerber/render/cairo_backend.py
@@ -12,80 +12,517 @@
 # 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.

+
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:

+    import cairo

+except ImportError:

+    import cairocffi as cairo

+    
+import math

+from operator import mul, div

+import tempfile

 

-from .render import GerberContext

-from operator import mul

 import cairocffi as cairo

-import math

 

-SCALE = 300.

+from ..primitives import *

+from .render import GerberContext, RenderSettings

+from .theme import THEMES

+

+try:

+    from cStringIO import StringIO

+except(ImportError):

+    from io import StringIO

 

 

 class GerberCairoContext(GerberContext):

-    def __init__(self, surface=None, size=(1000, 1000)):

-        GerberContext.__init__(self)

-        if surface is None:

-            self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,

-                                              size[0], size[1])

+

+    def __init__(self, scale=300):

+        super(GerberCairoContext, self).__init__()

+        self.scale = (scale, scale)

+        self.surface = None

+        self.ctx = None

+        self.active_layer = None

+        self.output_ctx = None

+        self.bg = False

+        self.mask = None

+        self.mask_ctx = None

+        self.origin_in_inch = None

+        self.size_in_inch = None

+        self._xform_matrix = None

+

+    @property

+    def origin_in_pixels(self):

+        return (self.scale_point(self.origin_in_inch)

+                if self.origin_in_inch is not None else (0.0, 0.0))

+

+    @property

+    def size_in_pixels(self):

+        return (self.scale_point(self.size_in_inch)

+                if self.size_in_inch is not None else (0.0, 0.0))

+

+    def set_bounds(self, bounds, new_surface=False):

+        origin_in_inch = (bounds[0][0], bounds[1][0])

+        size_in_inch = (abs(bounds[0][1] - bounds[0][0]),

+                        abs(bounds[1][1] - bounds[1][0]))

+        size_in_pixels = self.scale_point(size_in_inch)

+        self.origin_in_inch = origin_in_inch if self.origin_in_inch is None else self.origin_in_inch

+        self.size_in_inch = size_in_inch if self.size_in_inch is None else self.size_in_inch

+        if (self.surface is None) or new_surface:

+            self.surface_buffer = tempfile.NamedTemporaryFile()

+            self.surface = cairo.SVGSurface(

+                self.surface_buffer, size_in_pixels[0], size_in_pixels[1])

+            self.output_ctx = cairo.Context(self.surface)

+            self.output_ctx.set_fill_rule(cairo.FILL_RULE_EVEN_ODD)

+            self.output_ctx.scale(1, -1)

+            self.output_ctx.translate(-(origin_in_inch[0] * self.scale[0]),

+                                      (-origin_in_inch[1] * self.scale[0]) - size_in_pixels[1])

+        self._xform_matrix = cairo.Matrix(xx=1.0, yy=-1.0,

+                                          x0=-self.origin_in_pixels[0],

+                                          y0=self.size_in_pixels[1] + self.origin_in_pixels[1])

+

+    def render_layers(self, layers, filename, theme=THEMES['default']):

+        """ Render a set of layers

+        """

+        self.set_bounds(layers[0].bounds, True)

+        self._paint_background(True)

+

+        for layer in layers:

+            self._render_layer(layer, theme)

+        self.dump(filename)

+

+    def dump(self, filename):

+        """ Save image as `filename`

+        """

+        if filename and filename.lower().endswith(".svg"):

+            self.surface.finish()

+            self.surface_buffer.flush()

+            with open(filename, "w") as f:

+                self.surface_buffer.seek(0)

+                f.write(self.surface_buffer.read())

+                f.flush()

         else:

-            self.surface = surface

-        self.ctx = cairo.Context(self.surface)

-        self.size = size

-        self.ctx.translate(0, self.size[1])

-        self.scale = (SCALE,SCALE)

-        self.ctx.scale(1, -1)

-        self.apertures = {}

-        self.background = False

+            return self.surface.write_to_png(filename)

 

-    def set_bounds(self, bounds):

-        xbounds, ybounds = bounds

-        self.ctx.rectangle(SCALE * xbounds[0], SCALE * ybounds[0], SCALE * (xbounds[1]- xbounds[0]), SCALE * (ybounds[1] - ybounds[0]))

-        self.ctx.set_source_rgb(0,0,0)

-        self.ctx.fill()

+    def dump_str(self):

+        """ Return a string containing the rendered image.

+        """

+        fobj = StringIO()

+        self.surface.write_to_png(fobj)

+        return fobj.getvalue()

+

+    def dump_svg_str(self):

+        """ Return a string containg the rendered SVG.

+        """

+        self.surface.finish()

+        self.surface_buffer.flush()

+        return self.surface_buffer.read()

+

+    def _render_layer(self, layer, theme=THEMES['default']):

+        settings = theme.get(layer.layer_class, RenderSettings())

+        self.color = settings.color

+        self.alpha = settings.alpha

+        self.invert = settings.invert

+

+        # Get a new clean layer to render on

+        self._new_render_layer()

+        if settings.mirror:

+            raise Warning('mirrored layers aren\'t supported yet...')

+        for prim in layer.primitives:

+            self.render(prim)

+        # Add layer to image

+        self._flatten()

 

     def _render_line(self, line, color):

-        start = map(mul, line.start, self.scale)

-        end = map(mul, line.end, self.scale)

-        self.ctx.set_source_rgb (*color)

-        self.ctx.set_line_width(line.width * SCALE)

+        start = [pos * scale for pos, scale in zip(line.start, self.scale)]

+        end = [pos * scale for pos, scale in zip(line.end, self.scale)]

+        if not self.invert:

+<<<<<<< HEAD
+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                             if line.level_polarity == "dark"

+                             else cairo.OPERATOR_CLEAR)
+=======
+            self.ctx.set_source_rgba(*color, alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                                  if line.level_polarity == 'dark'

+                                  else cairo.OPERATOR_CLEAR)

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+        if isinstance(line.aperture, Circle):

+<<<<<<< HEAD
+            width = line.aperture.diameter
+=======
+            width = line.aperture.diameter

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+            self.ctx.set_line_width(width * self.scale[0])

+            self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)

+            self.ctx.move_to(*start)

+            self.ctx.line_to(*end)

+<<<<<<< HEAD
+            self.ctx.stroke()
+=======
+            self.ctx.stroke()

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+        elif isinstance(line.aperture, Rectangle):

+            points = [self.scale_point(x) for x in line.vertices]

+            self.ctx.set_line_width(0)

+            self.ctx.move_to(*points[0])

+            for point in points[1:]:

+                self.ctx.line_to(*point)

+            self.ctx.fill()

+

+    def _render_arc(self, arc, color):

+        center = self.scale_point(arc.center)

+        start = self.scale_point(arc.start)

+        end = self.scale_point(arc.end)

+        radius = self.scale[0] * arc.radius

+        angle1 = arc.start_angle

+        angle2 = arc.end_angle

+        if angle1 == angle2 and arc.quadrant_mode != 'single-quadrant':

+            # Make the angles slightly different otherwise Cario will draw nothing

+            angle2 -= 0.000000001

+        if isinstance(arc.aperture, Circle):

+            width = arc.aperture.diameter if arc.aperture.diameter != 0 else 0.001

+        else:

+            width = max(arc.aperture.width, arc.aperture.height, 0.001)

+        

+        if not self.invert:

+<<<<<<< HEAD
+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                             if arc.level_polarity == "dark"\

+                             else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+                

+=======
+            self.ctx.set_source_rgba(*color, alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                                  if arc.level_polarity == 'dark'

+                                  else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+        self.ctx.set_line_width(width * self.scale[0])

         self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)

-        self.ctx.move_to(*start)

-        self.ctx.line_to(*end)

-        self.ctx.stroke()

+        self.ctx.move_to(*start)  # You actually have to do this...

+        if arc.direction == 'counterclockwise':

+<<<<<<< HEAD
+            self.ctx.arc(center[0], center[1], radius, angle1, angle2)

+        else:

+            self.ctx.arc_negative(center[0], center[1], radius, angle1, angle2)

+=======
+            self.ctx.arc(*center, radius=radius, angle1=angle1, angle2=angle2)

+        else:

+            self.ctx.arc_negative(*center, radius=radius,

+                                  angle1=angle1, angle2=angle2)

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+        self.ctx.move_to(*end)  # ...lame

 

     def _render_region(self, region, color):

-        points = [tuple(map(mul, point, self.scale)) for point in region.points]

-        self.ctx.set_source_rgb (*color)

+        if not self.invert:

+<<<<<<< HEAD
+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                                  if region.level_polarity == "dark"

+=======
+            self.ctx.set_source_rgba(*color, alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                                  if region.level_polarity == 'dark'

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+                                  else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+<<<<<<< HEAD
+

+=======
+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+        self.ctx.set_line_width(0)

+        self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)

+        self.ctx.move_to(*self.scale_point(region.primitives[0].start))

+        for prim in region.primitives:

+            if isinstance(prim, Line):

+                self.ctx.line_to(*self.scale_point(prim.end))

+            else:

+                center = self.scale_point(prim.center)

+                radius = self.scale[0] * prim.radius

+                angle1 = prim.start_angle

+                angle2 = prim.end_angle

+                if prim.direction == 'counterclockwise':

+                    self.ctx.arc(*center, radius=radius,

+                                 angle1=angle1, angle2=angle2)

+                else:

+                    self.ctx.arc_negative(*center, radius=radius,

+                                          angle1=angle1, angle2=angle2)

+<<<<<<< HEAD
+        self.ctx.fill()


+    def _render_circle(self, circle, color):

+        center = self.scale_point(circle.position)

+        if not self.invert:

+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                                  if circle.level_polarity == "dark"

+                                  else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+            

+        if circle.hole_diameter > 0:

+            self.ctx.push_group()

+

         self.ctx.set_line_width(0)

-        self.ctx.move_to(*points[0])

-        for point in points[1:]:

-            self.ctx.move_to(*point)

+        self.ctx.arc(center[0], center[1], radius=circle.radius * self.scale[0], angle1=0, angle2=2 * math.pi)

+        self.ctx.fill()

+        

+        if circle.hole_diameter > 0:

+            # Render the center clear

+

+            self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)        

+            self.ctx.arc(center[0], center[1], radius=circle.hole_radius * self.scale[0], angle1=0, angle2=2 * math.pi)

+            self.ctx.fill()

+            

+            self.ctx.pop_group_to_source()

+            self.ctx.paint_with_alpha(1)
+=======
         self.ctx.fill()

 

     def _render_circle(self, circle, color):

-        center = map(mul, circle.position, self.scale)

-        self.ctx.set_source_rgb (*color)

+        center = self.scale_point(circle.position)

+        if not self.invert:

+            self.ctx.set_source_rgba(*color, alpha=self.alpha)

+            self.ctx.set_operator(

+                cairo.OPERATOR_OVER if circle.level_polarity == 'dark' else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

         self.ctx.set_line_width(0)

-        self.ctx.arc(*center, radius=circle.radius * SCALE, angle1=0, angle2=2 * math.pi)

+        self.ctx.arc(*center, radius=circle.radius *

+                     self.scale[0], angle1=0, angle2=2 * math.pi)

         self.ctx.fill()

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
 

     def _render_rectangle(self, rectangle, color):

-        ll = map(mul, rectangle.lower_left, self.scale)

-        width, height = tuple(map(mul, (rectangle.width, rectangle.height), map(abs, self.scale)))

-        self.ctx.set_source_rgb (*color)

+        lower_left = self.scale_point(rectangle.lower_left)

+        width, height = tuple([abs(coord) for coord in self.scale_point((rectangle.width, rectangle.height))])

+<<<<<<< HEAD
+        

+        if not self.invert:

+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER

+                             if rectangle.level_polarity == "dark"

+                             else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+            

+        if rectangle.rotation != 0:

+            self.ctx.save()

+            

+            center = map(mul, rectangle.position, self.scale)

+            matrix = cairo.Matrix()

+            matrix.translate(center[0], center[1])

+            # For drawing, we already handles the translation

+            lower_left[0] = lower_left[0] - center[0]

+            lower_left[1] = lower_left[1] - center[1]

+            matrix.rotate(rectangle.rotation)

+            self.ctx.transform(matrix)

+            

+        if rectangle.hole_diameter > 0:

+            self.ctx.push_group()

+

+        self.ctx.set_line_width(0)

+        self.ctx.rectangle(lower_left[0], lower_left[1], width, height)

+        self.ctx.fill()

+        

+        if rectangle.hole_diameter > 0:

+            # Render the center clear

+            self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+            center = map(mul, rectangle.position, self.scale)

+            self.ctx.arc(center[0], center[1], radius=rectangle.hole_radius * self.scale[0], angle1=0, angle2=2 * math.pi)

+            self.ctx.fill()

+            

+            self.ctx.pop_group_to_source()

+            self.ctx.paint_with_alpha(1)

+        

+        if rectangle.rotation != 0:

+            self.ctx.restore()
+=======
+

+        if not self.invert:

+            self.ctx.set_source_rgba(*color, alpha=self.alpha)

+            self.ctx.set_operator(

+                cairo.OPERATOR_OVER if rectangle.level_polarity == 'dark' else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

         self.ctx.set_line_width(0)

-        self.ctx.rectangle(*ll,width=width, height=height)

+        self.ctx.rectangle(*lower_left, width=width, height=height)

         self.ctx.fill()

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
 

     def _render_obround(self, obround, color):

+        

+        if not self.invert:

+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER if obround.level_polarity == "dark" else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+            

+        if obround.hole_diameter > 0:

+            self.ctx.push_group()

+

         self._render_circle(obround.subshapes['circle1'], color)

         self._render_circle(obround.subshapes['circle2'], color)

         self._render_rectangle(obround.subshapes['rectangle'], color)

+        

+        if obround.hole_diameter > 0:

+            # Render the center clear

+            self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+            center = map(mul, obround.position, self.scale)

+            self.ctx.arc(center[0], center[1], radius=obround.hole_radius * self.scale[0], angle1=0, angle2=2 * math.pi)

+            self.ctx.fill()

+            

+            self.ctx.pop_group_to_source()

+            self.ctx.paint_with_alpha(1)

+

+    def _render_polygon(self, polygon, color):

+        

+        # TODO Ths does not handle rotation of a polygon

+        if not self.invert:

+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER if polygon.level_polarity == "dark" else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

+            

+        if polygon.hole_radius > 0:

+            self.ctx.push_group()

+        

+        vertices = polygon.vertices 

+

+        self.ctx.set_line_width(0)

+        self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)

+        

+        # Start from before the end so it is easy to iterate and make sure it is closed

+        self.ctx.move_to(*map(mul, vertices[-1], self.scale))

+        for v in vertices:

+            self.ctx.line_to(*map(mul, v, self.scale))

+

+        self.ctx.fill()

+        

+        if polygon.hole_radius > 0:

+            # Render the center clear

+            center = tuple(map(mul, polygon.position, self.scale))

+            self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)        

+            self.ctx.set_line_width(0)

+            self.ctx.arc(center[0], center[1], polygon.hole_radius * self.scale[0], 0, 2 * math.pi)

+            self.ctx.fill()

+            

+            self.ctx.pop_group_to_source()

+            self.ctx.paint_with_alpha(1)

 

-    def _render_drill(self, circle, color):

+    def _render_drill(self, circle, color=None):

+        color = color if color is not None else self.drill_color

         self._render_circle(circle, color)

+        

+    def _render_slot(self, slot, color):

+        start = map(mul, slot.start, self.scale)

+        end = map(mul, slot.end, self.scale)

+        

+        width = slot.diameter

+        

+        if not self.invert:

+            self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)

+            self.ctx.set_operator(cairo.OPERATOR_OVER if slot.level_polarity == "dark" else cairo.OPERATOR_CLEAR)

+        else:

+            self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR)

 

-    def dump(self, filename):

-        self.surface.write_to_png(filename)

+        self.ctx.set_line_width(width * self.scale[0])

+        self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)

+        self.ctx.move_to(*start)

+        self.ctx.line_to(*end)

+        self.ctx.stroke()

+        

+    def _render_amgroup(self, amgroup, color):

+        self.ctx.push_group()

+        for primitive in amgroup.primitives:

+            self.render(primitive)

+        self.ctx.pop_group_to_source()

+        self.ctx.paint_with_alpha(1)

+

+    def _render_test_record(self, primitive, color):

+        position = [pos + origin for pos, origin in zip(primitive.position, self.origin_in_inch)]

+        self.ctx.set_operator(cairo.OPERATOR_OVER)

+        self.ctx.select_font_face(

+            'monospace', cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)

+        self.ctx.set_font_size(13)

+        self._render_circle(Circle(position, 0.015), color)

+        self.ctx.set_source_rgba(*color, alpha=self.alpha)

+        self.ctx.set_operator(

+            cairo.OPERATOR_OVER if primitive.level_polarity == 'dark' else cairo.OPERATOR_CLEAR)

+        self.ctx.move_to(*[self.scale[0] * (coord + 0.015)

+                           for coord in position])

+        self.ctx.scale(1, -1)

+        self.ctx.show_text(primitive.net_name)

+        self.ctx.scale(1, -1)
+

+    def _new_render_layer(self, color=None):

+        size_in_pixels = self.scale_point(self.size_in_inch)

+        layer = cairo.SVGSurface(None, size_in_pixels[0], size_in_pixels[1])

+        ctx = cairo.Context(layer)

+        ctx.set_fill_rule(cairo.FILL_RULE_EVEN_ODD)

+        ctx.scale(1, -1)

+        ctx.translate(-(self.origin_in_inch[0] * self.scale[0]),

+                           (-self.origin_in_inch[1] * self.scale[0])

+                           - size_in_pixels[1])

+        if self.invert:

+            ctx.set_operator(cairo.OPERATOR_OVER)

+            ctx.set_source_rgba(*self.color, alpha=self.alpha)

+            ctx.paint()

+        self.ctx = ctx

+        self.active_layer = layer

+

+    def _flatten(self):

+        self.output_ctx.set_operator(cairo.OPERATOR_OVER)

+<<<<<<< HEAD
+        ptn = cairo.SurfacePattern(self.active_layer)
+=======
+        ptn = cairo.SurfacePattern(self.active_layer)

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
+        ptn.set_matrix(self._xform_matrix)

+        self.output_ctx.set_source(ptn)

+        self.output_ctx.paint()

+        self.ctx = None

+        self.active_layer = None

+

+    def _paint_background(self, force=False):

+        if (not self.bg) or force:
+            self.bg = True

+            self.output_ctx.set_operator(cairo.OPERATOR_OVER)

+<<<<<<< HEAD
+            self.output_ctx.set_source_rgba(self.background_color[0], self.background_color[1], self.background_color[2], alpha=1.0)

+            self.output_ctx.paint()

+

+    def scale_point(self, point):

+        return tuple([coord * scale for coord, scale in zip(point, self.scale)])

+=======
+            self.output_ctx.set_source_rgba(*self.background_color, alpha=1.0)

+            self.output_ctx.paint()

+

+    def scale_point(self, point):

+        return tuple([coord * scale for coord, scale in zip(point, self.scale)])

+>>>>>>> 5476da8... Fix a bunch of rendering bugs.
diff --git a/gerber/render/excellon_backend.py b/gerber/render/excellon_backend.py
new file mode 100644
index 0000000..da5b22b
--- /dev/null
+++ b/gerber/render/excellon_backend.py
@@ -0,0 +1,189 @@
+
+from .render import GerberContext
+from ..excellon import DrillSlot
+from ..excellon_statements import *
+
+class ExcellonContext(GerberContext):
+    
+    MODE_DRILL = 1
+    MODE_SLOT =2 
+    
+    def __init__(self, settings):
+        GerberContext.__init__(self)
+        
+        # Statements that we write
+        self.comments = []
+        self.header = []
+        self.tool_def = []
+        self.body_start = [RewindStopStmt()]
+        self.body = []
+        self.start = [HeaderBeginStmt()]
+        
+        # Current tool and position
+        self.handled_tools = set()
+        self.cur_tool = None
+        self.drill_mode = ExcellonContext.MODE_DRILL
+        self.drill_down = False
+        self._pos = (None, None)
+        
+        self.settings = settings
+
+        self._start_header()
+        self._start_comments()
+        
+    def _start_header(self):
+        """Create the header from the settings"""
+        
+        self.header.append(UnitStmt.from_settings(self.settings))
+        
+        if self.settings.notation == 'incremental':
+            raise NotImplementedError('Incremental mode is not implemented')
+        else:
+            self.body.append(AbsoluteModeStmt())
+        
+    def _start_comments(self):
+        
+        # Write the digits used - this isn't valid Excellon statement, so we write as a comment
+        self.comments.append(CommentStmt('FILE_FORMAT=%d:%d' % (self.settings.format[0], self.settings.format[1])))
+        
+    def _get_end(self):
+        """How we end depends on our mode"""
+        
+        end = []
+        
+        if self.drill_down:
+            end.append(RetractWithClampingStmt())
+            end.append(RetractWithoutClampingStmt())
+            
+        end.append(EndOfProgramStmt())
+        
+        return end
+        
+    @property
+    def statements(self):
+        return self.start + self.comments + self.header + self.body_start + self.body + self._get_end()
+        
+    def set_bounds(self, bounds):
+        pass
+    
+    def _paint_background(self):
+        pass
+        
+    def _render_line(self, line, color):
+        raise ValueError('Invalid Excellon object')
+    def _render_arc(self, arc, color):
+        raise ValueError('Invalid Excellon object')
+
+    def _render_region(self, region, color):
+        raise ValueError('Invalid Excellon object')
+        
+    def _render_level_polarity(self, region):
+        raise ValueError('Invalid Excellon object')
+
+    def _render_circle(self, circle, color):
+        raise ValueError('Invalid Excellon object')
+
+    def _render_rectangle(self, rectangle, color):
+        raise ValueError('Invalid Excellon object')
+        
+    def _render_obround(self, obround, color):
+        raise ValueError('Invalid Excellon object')
+        
+    def _render_polygon(self, polygon, color):
+        raise ValueError('Invalid Excellon object')
+    
+    def _simplify_point(self, point):
+        return (point[0] if point[0] != self._pos[0] else None, point[1] if point[1] != self._pos[1] else None)
+
+    def _render_drill(self, drill, color):
+        
+        if self.drill_mode != ExcellonContext.MODE_DRILL:
+            self._start_drill_mode()
+        
+        tool = drill.hit.tool
+        if not tool in self.handled_tools:
+            self.handled_tools.add(tool)
+            self.header.append(ExcellonTool.from_tool(tool))
+    
+        if tool != self.cur_tool:
+            self.body.append(ToolSelectionStmt(tool.number))
+            self.cur_tool = tool
+            
+        point = self._simplify_point(drill.position)
+        self._pos = drill.position
+        self.body.append(CoordinateStmt.from_point(point))
+        
+    def _start_drill_mode(self):
+        """
+        If we are not in drill mode, then end the ROUT so we can do basic drilling
+        """
+        
+        if self.drill_mode == ExcellonContext.MODE_SLOT:
+            
+            # Make sure we are retracted before changing modes
+            last_cmd = self.body[-1]
+            if self.drill_down:
+                self.body.append(RetractWithClampingStmt())
+                self.body.append(RetractWithoutClampingStmt())
+                self.drill_down = False
+            
+            # Switch to drill mode
+            self.body.append(DrillModeStmt())
+            self.drill_mode = ExcellonContext.MODE_DRILL
+            
+        else:
+            raise ValueError('Should be in slot mode')
+        
+    def _render_slot(self, slot, color):
+        
+        # Set the tool first, before we might go into drill mode
+        tool = slot.hit.tool
+        if not tool in self.handled_tools:
+            self.handled_tools.add(tool)
+            self.header.append(ExcellonTool.from_tool(tool))
+            
+        if tool != self.cur_tool:
+            self.body.append(ToolSelectionStmt(tool.number))
+            self.cur_tool = tool
+        
+        # Two types of drilling - normal drill and slots
+        if slot.hit.slot_type == DrillSlot.TYPE_ROUT:
+
+            # For ROUT, setting the mode is part of the actual command.
+            
+            # Are we in the right position?
+            if slot.start != self._pos:
+                if self.drill_down:
+                    # We need to move into the right position, so retract
+                    self.body.append(RetractWithClampingStmt())
+                    self.drill_down = False
+                    
+                # Move to the right spot
+                point = self._simplify_point(slot.start)
+                self._pos = slot.start
+                self.body.append(CoordinateStmt.from_point(point, mode="ROUT"))
+                
+            # Now we are in the right spot, so drill down
+            if not self.drill_down:
+                self.body.append(ZAxisRoutPositionStmt())
+                self.drill_down = True
+                
+            # Do a linear move from our current position to the end position
+            point = self._simplify_point(slot.end)
+            self._pos = slot.end
+            self.body.append(CoordinateStmt.from_point(point, mode="LINEAR"))
+
+            self.drill_mode = ExcellonContext.MODE_SLOT
+                
+        else:
+            # This is a G85 slot, so do this in normally drilling mode
+            if self.drill_mode != ExcellonContext.MODE_DRILL:
+                self._start_drill_mode()
+        
+            # Slots don't use simplified points
+            self._pos = slot.end
+            self.body.append(SlotStmt.from_points(slot.start, slot.end))
+
+    def _render_inverted_layer(self):
+        pass
+        
\ No newline at end of file
diff --git a/gerber/render/render.py b/gerber/render/render.py
index f5c58d8..b319648 100644
--- a/gerber/render/render.py
+++ b/gerber/render/render.py
@@ -23,12 +23,13 @@ Rendering
 Render Gerber and Excellon files to a variety of formats. The render module
 currently supports SVG rendering using the `svgwrite` library.
 """
+
+
+from ..primitives import *
 from ..gerber_statements import (CommentStmt, UnknownStmt, EofStmt, ParamStmt,
                                  CoordStmt, ApertureStmt, RegionModeStmt,
-                                 QuadrantModeStmt,
-)
+                                 QuadrantModeStmt,)
 
-from ..primitives import *
 
 class GerberContext(object):
     """ Gerber rendering context base class
@@ -41,7 +42,7 @@ class GerberContext(object):
     Attributes
     ----------
     units : string
-        Measurement units
+        Measurement units. 'inch' or 'metric'
 
     color : tuple (<float>, <float>, <float>)
         Color used for rendering as a tuple of normalized (red, green, blue) values.
@@ -56,79 +57,89 @@ class GerberContext(object):
     alpha : float
         Rendering opacity. Between 0.0 (transparent) and 1.0 (opaque.)
     """
+
     def __init__(self, units='inch'):
-        self.units = units
-        self.color = (0.7215, 0.451, 0.200)
-        self.drill_color = (0.25, 0.25, 0.25)
-        self.background_color = (0.0, 0.0, 0.0)
-        self.alpha = 1.0
-
-    def set_units(self, units):
-        """ Set context measurement units
-
-        Parameters
-        ----------
-        unit : string
-            Measurement units. may be 'inch' or 'metric'
-
-        Raises
-        ------
-        ValueError
-            If `unit` is not 'inch' or 'metric'
-        """
+        self._units = units
+        self._color = (0.7215, 0.451, 0.200)
+        self._background_color = (0.0, 0.0, 0.0)
+        self._alpha = 1.0
+        self._invert = False
+        self.ctx = None
+
+    @property
+    def units(self):
+        return self._units
+
+    @units.setter
+    def units(self, units):
         if units not in ('inch', 'metric'):
             raise ValueError('Units may be "inch" or "metric"')
-        self.units = units
-
-    def set_color(self, color):
-        """ Set rendering color.
-
-        Parameters
-        ----------
-        color : tuple (<float>, <float>, <float>)
-            Color as a tuple of (red, green, blue) values. Each channel is
-            represented as a float value in (0, 1)
-        """
-        self.color = color
-
-    def set_drill_color(self, color):
-        """ Set color used for rendering drill hits.
-
-        Parameters
-        ----------
-        color : tuple (<float>, <float>, <float>)
-            Color as a tuple of (red, green, blue) values. Each channel is
-            represented as a float value in (0, 1)
-        """
-        self.drill_color = color
-
-    def set_background_color(self, color):
-        """ Set rendering background color
-
-        Parameters
-        ----------
-        color : tuple (<float>, <float>, <float>)
-            Color as a tuple of (red, green, blue) values. Each channel is
-            represented as a float value in (0, 1)
-        """
-        self.background_color = color
-
-    def set_alpha(self, alpha):
-        """ Set layer rendering opacity
-
-        .. note::
-            Not all backends/rendering devices support this parameter.
-
-        Parameters
-        ----------
-        alpha : float
-            Rendering opacity. must be between 0.0 (transparent) and 1.0 (opaque)
-        """
-        self.alpha = alpha
+        self._units = units
+
+    @property
+    def color(self):
+        return self._color
+
+    @color.setter
+    def color(self, color):
+        if len(color) != 3:
+            raise TypeError('Color must be a tuple of R, G, and B values')
+        for c in color:
+            if c < 0 or c > 1:
+                raise ValueError('Channel values must be between 0.0 and 1.0')
+        self._color = color
+
+    @property
+    def drill_color(self):
+        return self._drill_color
+
+    @drill_color.setter
+    def drill_color(self, color):
+        if len(color) != 3:
+            raise TypeError('Drill color must be a tuple of R, G, and B values')
+        for c in color:
+            if c < 0 or c > 1:
+                raise ValueError('Channel values must be between 0.0 and 1.0')
+        self._drill_color = color
+
+    @property
+    def background_color(self):
+        return self._background_color
+
+    @background_color.setter
+    def background_color(self, color):
+        if len(color) != 3:
+            raise TypeError('Background color must be a tuple of R, G, and B values')
+        for c in color:
+            if c < 0 or c > 1:
+                raise ValueError('Channel values must be between 0.0 and 1.0')
+        self._background_color = color
+
+    @property
+    def alpha(self):
+        return self._alpha
+
+    @alpha.setter
+    def alpha(self, alpha):
+        if alpha < 0 or alpha > 1:
+            raise ValueError('Alpha must be between 0.0 and 1.0')
+        self._alpha = alpha
+
+    @property
+    def invert(self):
+        return self._invert
+
+    @invert.setter
+    def invert(self, invert):
+        self._invert = invert
 
     def render(self, primitive):
-        color = (self.color if primitive.level_polarity == 'dark'
-                 else self.background_color)
+        if not primitive:
+            return
+        
+        self._pre_render_primitive(primitive)
+        
+        color = self.color
         if isinstance(primitive, Line):
             self._render_line(primitive, color)
         elif isinstance(primitive, Arc):
@@ -142,11 +153,35 @@ class GerberContext(object):
         elif isinstance(primitive, Obround):
             self._render_obround(primitive, color)
         elif isinstance(primitive, Polygon):
-            self._render_polygon(Polygon, color)
+            self._render_polygon(primitive, color)
         elif isinstance(primitive, Drill):
-            self._render_drill(primitive, self.drill_color)
-        else:
-            return
+            self._render_drill(primitive, self.color)
+        elif isinstance(primitive, Slot):
+            self._render_slot(primitive, self.color)
+        elif isinstance(primitive, AMGroup):
+            self._render_amgroup(primitive, color)
+        elif isinstance(primitive, Outline):
+            self._render_region(primitive, color)
+        elif isinstance(primitive, TestRecord):
+            self._render_test_record(primitive, color)
+        
+        self._post_render_primitive(primitive)
+        
+    def _pre_render_primitive(self, primitive):
+        """
+        Called before rendering a primitive. Use the callback to perform some action before rendering
+        a primitive, for example adding a comment.
+        """
+        return
+    
+    def _post_render_primitive(self, primitive):
+        """
+        Called after rendering a primitive. Use the callback to perform some action after rendering
+        a primitive
+        """
+        return
+
+
 
     def _render_line(self, primitive, color):
         pass
@@ -171,4 +206,21 @@ class GerberContext(object):
 
     def _render_drill(self, primitive, color):
         pass
+    
+    def _render_slot(self, primitive, color):
+        pass
+    
+    def _render_amgroup(self, primitive, color):
+        pass
+
+    def _render_test_record(self, primitive, color):
+        pass
 
+
+class RenderSettings(object):
+
+    def __init__(self, color=(0.0, 0.0, 0.0), alpha=1.0, invert=False, mirror=False):
+        self.color = color
+        self.alpha = alpha
+        self.invert = invert
+        self.mirror = mirror
diff --git a/gerber/render/rs274x_backend.py b/gerber/render/rs274x_backend.py
new file mode 100644
index 0000000..b4b4612
--- /dev/null
+++ b/gerber/render/rs274x_backend.py
@@ -0,0 +1,495 @@
+"""Renders an in-memory Gerber file to statements which can be written to a string
+"""
+from copy import deepcopy
+
+try:
+    from cStringIO import StringIO
+except(ImportError):
+    from io import StringIO
+    
+from .render import GerberContext
+from ..am_statements import *
+from ..gerber_statements import *
+from ..primitives import AMGroup, Arc, Circle, Line, Obround, Outline, Polygon, Rectangle
+
+
+class AMGroupContext(object):
+    '''A special renderer to generate aperature macros from an AMGroup'''
+    
+    def __init__(self):
+        self.statements = []
+    
+    def render(self, amgroup, name):
+        
+        if amgroup.stmt:
+            # We know the statement it was generated from, so use that to create the AMParamStmt
+            # It will give a much better result
+            
+            stmt = deepcopy(amgroup.stmt)
+            stmt.name = name
+            
+            return stmt
+        
+        else:
+            # Clone ourselves, then offset by the psotion so that
+            # our render doesn't have to consider offset. Just makes things simpler
+            nooffset_group = deepcopy(amgroup)
+            nooffset_group.position = (0, 0)
+            
+            # Now draw the shapes
+            for primitive in nooffset_group.primitives:
+                if isinstance(primitive, Outline):
+                    self._render_outline(primitive)
+                elif isinstance(primitive, Circle):
+                    self._render_circle(primitive)
+                elif isinstance(primitive, Rectangle):
+                    self._render_rectangle(primitive)
+                elif isinstance(primitive, Line):
+                    self._render_line(primitive)
+                elif isinstance(primitive, Polygon):
+                    self._render_polygon(primitive)
+                else:
+                    raise ValueError('amgroup')
+    
+            statement = AMParamStmt('AM', name, self._statements_to_string())
+            return statement
+    
+    def _statements_to_string(self):
+        macro = ''
+
+        for statement in self.statements:
+            macro += statement.to_gerber()
+            
+        return macro
+    
+    def _render_circle(self, circle):
+        self.statements.append(AMCirclePrimitive.from_primitive(circle))
+        
+    def _render_rectangle(self, rectangle):
+        self.statements.append(AMCenterLinePrimitive.from_primitive(rectangle))
+        
+    def _render_line(self, line):
+        self.statements.append(AMVectorLinePrimitive.from_primitive(line))
+     
+    def _render_outline(self, outline):
+        self.statements.append(AMOutlinePrimitive.from_primitive(outline))
+        
+    def _render_polygon(self, polygon):
+        self.statements.append(AMPolygonPrimitive.from_primitive(polygon))
+    
+    def _render_thermal(self, thermal):
+        pass
+    
+
+class Rs274xContext(GerberContext):
+    
+    def __init__(self, settings):
+        GerberContext.__init__(self)
+        self.comments = []
+        self.header = []
+        self.body = []
+        self.end = [EofStmt()]
+        
+        # Current values so we know if we have to execute
+        # moves, levey changes before anything else
+        self._level_polarity = None
+        self._pos = (None, None)
+        self._func = None
+        self._quadrant_mode = None
+        self._dcode = None
+        
+        # Primarily for testing and comarison to files, should we write
+        # flashes as a single statement or a move plus flash? Set to true
+        # to do in a single statement. Normally this can be false
+        self.condensed_flash = True
+        
+        # When closing a region, force a D02 staement to close a region.
+        # This is normally not necessary because regions are closed with a G37
+        # staement, but this will add an extra statement for doubly close
+        # the region
+        self.explicit_region_move_end = False
+        
+        self._next_dcode = 10
+        self._rects = {}
+        self._circles = {}
+        self._obrounds = {}
+        self._polygons = {}
+        self._macros = {}
+        
+        self._i_none = 0
+        self._j_none = 0
+        
+        self.settings = settings
+
+        self._start_header(settings)
+        
+    def _start_header(self, settings):
+        self.header.append(FSParamStmt.from_settings(settings))
+        self.header.append(MOParamStmt.from_units(settings.units))
+        
+    def _simplify_point(self, point):
+        return (point[0] if point[0] != self._pos[0] else None, point[1] if point[1] != self._pos[1] else None)
+    
+    def _simplify_offset(self, point, offset):
+        
+        if point[0] != offset[0]:
+            xoffset = point[0] - offset[0]
+        else:
+            xoffset = self._i_none
+            
+        if point[1] != offset[1]:
+            yoffset = point[1] - offset[1]
+        else:
+            yoffset = self._j_none
+        
+        return (xoffset, yoffset)
+        
+    @property
+    def statements(self):
+        return self.comments + self.header + self.body + self.end
+        
+    def set_bounds(self, bounds):
+        pass
+    
+    def _paint_background(self):
+        pass
+    
+    def _select_aperture(self, aperture):
+        
+        # Select the right aperture if not already selected
+        if aperture:
+            if isinstance(aperture, Circle):
+                aper = self._get_circle(aperture.diameter, aperture.hole_diameter)
+            elif isinstance(aperture, Rectangle):
+                aper = self._get_rectangle(aperture.width, aperture.height)
+            elif isinstance(aperture, Obround):
+                aper = self._get_obround(aperture.width, aperture.height)
+            elif isinstance(aperture, AMGroup):
+                aper = self._get_amacro(aperture)
+            else:
+                raise NotImplementedError('Line with invalid aperture type')
+                
+            if aper.d != self._dcode:
+                self.body.append(ApertureStmt(aper.d))
+                self._dcode = aper.d
+                
+    def _pre_render_primitive(self, primitive):
+        
+        if hasattr(primitive, 'comment'):
+            self.body.append(CommentStmt(primitive.comment))
+        
+    def _render_line(self, line, color):
+        
+        self._select_aperture(line.aperture)
+        
+        self._render_level_polarity(line)
+            
+        # Get the right function
+        if self._func != CoordStmt.FUNC_LINEAR:
+            func = CoordStmt.FUNC_LINEAR
+        else:
+            func = None
+        self._func = CoordStmt.FUNC_LINEAR
+        
+        if self._pos != line.start:
+            self.body.append(CoordStmt.move(func, self._simplify_point(line.start)))
+            self._pos = line.start
+            # We already set the function, so the next command doesn't require that
+            func = None
+        
+        point = self._simplify_point(line.end)
+        
+        # In some files, we see a lot of duplicated ponts, so omit those
+        if point[0] != None or point[1] != None:
+            self.body.append(CoordStmt.line(func, self._simplify_point(line.end)))
+            self._pos = line.end
+        elif func:
+            self.body.append(CoordStmt.mode(func))
+        
+    def _render_arc(self, arc, color):
+        
+        # Optionally set the quadrant mode if it has changed:
+        if arc.quadrant_mode != self._quadrant_mode:
+            
+            if arc.quadrant_mode != 'multi-quadrant':
+                self.body.append(QuadrantModeStmt.single())
+            else:
+                self.body.append(QuadrantModeStmt.multi())
+            
+            self._quadrant_mode = arc.quadrant_mode
+            
+        # Select the right aperture if not already selected
+        self._select_aperture(arc.aperture)
+        
+        self._render_level_polarity(arc)
+        
+        # Find the right movement mode. Always set to be sure it is really right
+        dir = arc.direction
+        if dir == 'clockwise':
+            func = CoordStmt.FUNC_ARC_CW
+            self._func = CoordStmt.FUNC_ARC_CW
+        elif dir == 'counterclockwise':
+            func = CoordStmt.FUNC_ARC_CCW
+            self._func = CoordStmt.FUNC_ARC_CCW
+        else:
+            raise ValueError('Invalid circular interpolation mode')
+            
+        if self._pos != arc.start:
+            # TODO I'm not sure if this is right
+            self.body.append(CoordStmt.move(CoordStmt.FUNC_LINEAR, self._simplify_point(arc.start)))
+            self._pos = arc.start
+            
+        center = self._simplify_offset(arc.center, arc.start)
+        end = self._simplify_point(arc.end)
+        self.body.append(CoordStmt.arc(func, end, center))
+        self._pos = arc.end
+
+    def _render_region(self, region, color):
+        
+        self._render_level_polarity(region)
+        
+        self.body.append(RegionModeStmt.on())
+        
+        for p in region.primitives:
+            
+            if isinstance(p, Line):
+                self._render_line(p, color)
+            else:
+                self._render_arc(p, color)
+                
+        if self.explicit_region_move_end:
+            self.body.append(CoordStmt.move(None, None))
+
+        self.body.append(RegionModeStmt.off())
+        
+    def _render_level_polarity(self, region):
+        if region.level_polarity != self._level_polarity:
+            self._level_polarity = region.level_polarity
+            self.body.append(LPParamStmt.from_region(region))
+            
+    def _render_flash(self, primitive, aperture):
+        
+        self._render_level_polarity(primitive)
+        
+        if aperture.d != self._dcode:
+            self.body.append(ApertureStmt(aperture.d))
+            self._dcode = aperture.d
+        
+        if self.condensed_flash:
+            self.body.append(CoordStmt.flash(self._simplify_point(primitive.position)))
+        else:
+            self.body.append(CoordStmt.move(None, self._simplify_point(primitive.position)))
+            self.body.append(CoordStmt.flash(None))
+            
+        self._pos = primitive.position
+            
+    def _get_circle(self, diameter, hole_diameter, dcode = None):
+        '''Define a circlar aperture'''
+        
+        aper = self._circles.get((diameter, hole_diameter), None)
+
+        if not aper:
+            if not dcode:
+                dcode = self._next_dcode
+                self._next_dcode += 1
+            else:
+                self._next_dcode = max(dcode + 1, self._next_dcode)
+                
+            aper = ADParamStmt.circle(dcode, diameter, hole_diameter)
+            self._circles[(diameter, hole_diameter)] = aper
+            self.header.append(aper)
+
+        return aper
+        
+    def _render_circle(self, circle, color):
+
+        aper = self._get_circle(circle.diameter, circle.hole_diameter)
+        self._render_flash(circle, aper)
+
+    def _get_rectangle(self, width, height, dcode = None):
+        '''Get a rectanglar aperture. If it isn't defined, create it'''
+        
+        key = (width, height)
+        aper = self._rects.get(key, None)
+        
+        if not aper:
+            if not dcode:
+                dcode = self._next_dcode
+                self._next_dcode += 1
+            else:
+                self._next_dcode = max(dcode + 1, self._next_dcode)
+            
+            aper = ADParamStmt.rect(dcode, width, height)
+            self._rects[(width, height)] = aper
+            self.header.append(aper)
+    
+        return aper
+
+    def _render_rectangle(self, rectangle, color):
+        
+        aper = self._get_rectangle(rectangle.width, rectangle.height)
+        self._render_flash(rectangle, aper)
+        
+    def _get_obround(self, width, height, dcode = None):
+        
+        key = (width, height)
+        aper = self._obrounds.get(key, None)
+        
+        if not aper:
+            if not dcode:
+                dcode = self._next_dcode
+                self._next_dcode += 1
+            else:
+                self._next_dcode = max(dcode + 1, self._next_dcode)
+            
+            aper = ADParamStmt.obround(dcode, width, height)
+            self._obrounds[key] = aper
+            self.header.append(aper)
+    
+        return aper
+        
+    def _render_obround(self, obround, color):
+        
+        aper = self._get_obround(obround.width, obround.height)
+        self._render_flash(obround, aper)
+        
+    def _render_polygon(self, polygon, color):
+        
+        aper = self._get_polygon(polygon.radius, polygon.sides, polygon.rotation, polygon.hole_radius)
+        self._render_flash(polygon, aper)
+        
+    def _get_polygon(self, radius, num_vertices, rotation, hole_radius, dcode = None):
+        
+        key = (radius, num_vertices, rotation, hole_radius)
+        aper = self._polygons.get(key, None)
+        
+        if not aper:
+            if not dcode:
+                dcode = self._next_dcode
+                self._next_dcode += 1
+            else:
+                self._next_dcode = max(dcode + 1, self._next_dcode)
+                
+            aper = ADParamStmt.polygon(dcode, radius * 2, num_vertices, rotation, hole_radius * 2)
+            self._polygons[key] = aper
+            self.header.append(aper)
+            
+        return aper
+        
+    def _render_drill(self, drill, color):
+        raise ValueError('Drills are not valid in RS274X files')
+    
+    def _hash_amacro(self, amgroup):
+        '''Calculate a very quick hash code for deciding if we should even check AM groups for comparision'''
+        
+        # We always start with an X because this forms part of the name
+        # Basically, in some cases, the name might start with a C, R, etc. That can appear
+        # to conflict with normal aperture definitions. Technically, it shouldn't because normal
+        # aperture definitions should have a comma, but in some cases the commit is omitted
+        hash = 'X'
+        for primitive in amgroup.primitives:
+            
+            hash += primitive.__class__.__name__[0]
+            
+            bbox = primitive.bounding_box
+            hash += str((bbox[0][1] - bbox[0][0]) * 100000)[0:2]
+            hash += str((bbox[1][1] - bbox[1][0]) * 100000)[0:2]
+            
+            if hasattr(primitive, 'primitives'):
+                hash += str(len(primitive.primitives))
+                
+            if isinstance(primitive, Rectangle):
+                hash += str(primitive.width * 1000000)[0:2]
+                hash += str(primitive.height * 1000000)[0:2]
+            elif isinstance(primitive, Circle):
+                hash += str(primitive.diameter * 1000000)[0:2]
+                
+            if len(hash) > 20:
+                # The hash might actually get quite complex, so stop before
+                # it gets too long
+                break
+            
+        return hash
+
+    def _get_amacro(self, amgroup, dcode = None):
+        # Macros are a little special since we don't have a good way to compare them quickly
+        # but in most cases, this should work
+        
+        hash = self._hash_amacro(amgroup)
+        macro = None
+        macroinfo = self._macros.get(hash, None)
+        
+        if macroinfo:
+            
+            # We have a definition, but check that the groups actually are the same
+            for macro in macroinfo:
+                
+                # Macros should have positions, right? But if the macro is selected for non-flashes
+                # then it won't have a position. This is of course a bad gerber, but they do exist
+                if amgroup.position:
+                    position = amgroup.position
+                else:
+                    position = (0, 0)
+
+                offset = (position[0] - macro[1].position[0], position[1] - macro[1].position[1])
+                if amgroup.equivalent(macro[1], offset):
+                    break
+                macro = None
+                
+        # Did we find one in the group0
+        if not macro:
+            # This is a new macro, so define it
+            if not dcode:
+                dcode = self._next_dcode
+                self._next_dcode += 1
+            else:
+                self._next_dcode = max(dcode + 1, self._next_dcode)
+            
+            # Create the statements
+            # TODO
+            amrenderer = AMGroupContext()
+            statement = amrenderer.render(amgroup, hash)
+            
+            self.header.append(statement)
+            
+            aperdef = ADParamStmt.macro(dcode, hash)
+            self.header.append(aperdef)
+            
+            # Store the dcode and the original so we can check if it really is the same
+            # If it didn't have a postition, set it to 0, 0
+            if amgroup.position == None:
+                amgroup.position = (0, 0)
+            macro = (aperdef, amgroup)
+            
+            if macroinfo:
+                macroinfo.append(macro)
+            else:
+                self._macros[hash] = [macro]                
+            
+        return macro[0]
+        
+    def _render_amgroup(self, amgroup, color):
+        
+        aper = self._get_amacro(amgroup)
+        self._render_flash(amgroup, aper)
+
+    def _render_inverted_layer(self):
+        pass
+    
+    def _new_render_layer(self):
+        # TODO Might need to implement this
+        pass
+    
+    def _flatten(self):
+        # TODO Might need to implement this
+        pass
+    
+    def dump(self):
+        """Write the rendered file to a StringIO steam"""
+        statements = map(lambda stmt: stmt.to_gerber(self.settings), self.statements)
+        stream = StringIO()
+        for statement in statements:
+            stream.write(statement + '\n')
+        
+        return stream
+        
\ No newline at end of file
diff --git a/gerber/render/svgwrite_backend.py b/gerber/render/svgwrite_backend.py
deleted file mode 100644
index 2df87b3..0000000
--- a/gerber/render/svgwrite_backend.py
+++ /dev/null
@@ -1,155 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be>
-# Based on render_svg.py by Paulo Henrique Silva <ph.silva@gmail.com>
-
-# 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 .render import GerberContext
-from operator import mul
-import svgwrite
-
-SCALE = 300
-
-
-def svg_color(color):
-    color = tuple([int(ch * 255) for ch in color])
-    return  'rgb(%d, %d, %d)' % color
-
-
-class GerberSvgContext(GerberContext):
-    def __init__(self):
-        GerberContext.__init__(self)
-        self.scale = (SCALE, -SCALE)
-        self.dwg = svgwrite.Drawing()
-        self.background = False
-
-    def dump(self, filename):
-        self.dwg.saveas(filename)
-
-    def set_bounds(self, bounds):
-        xbounds, ybounds = bounds
-        size = (SCALE * (xbounds[1] - xbounds[0]),
-                SCALE * (ybounds[1] - ybounds[0]))
-        if not self.background:
-            vbox = '%f, %f, %f, %f' % (SCALE * xbounds[0], -SCALE * ybounds[1],
-                                       size[0], size[1])
-            self.dwg = svgwrite.Drawing(viewBox=vbox)
-            rect = self.dwg.rect(insert=(SCALE * xbounds[0],
-                                         -SCALE * ybounds[1]),
-                                 size=size,
-                                 fill=svg_color(self.background_color))
-            self.dwg.add(rect)
-            self.background = True
-
-    def _render_line(self, line, color):
-        start = map(mul, line.start, self.scale)
-        end = map(mul, line.end, self.scale)
-        aline = self.dwg.line(start=start, end=end,
-                              stroke=svg_color(color),
-                              stroke_width=SCALE * line.width,
-                              stroke_linecap='round')
-        aline.stroke(opacity=self.alpha)
-        self.dwg.add(aline)
-
-    def _render_region(self, region, color):
-        points = [tuple(map(mul, point, self.scale)) for point in region.points]
-        region_path = self.dwg.path(d='M %f, %f' % points[0],
-                                    fill=svg_color(color),
-                                    stroke='none')
-        region_path.fill(opacity=self.alpha)
-        for point in points[1:]:
-            region_path.push('L %f, %f' % point)
-        self.dwg.add(region_path)
-
-    def _render_circle(self, circle, color):
-        center = map(mul, circle.position, self.scale)
-        acircle = self.dwg.circle(center=center,
-                                  r = SCALE * circle.radius,
-                                  fill=svg_color(color))
-        acircle.fill(opacity=self.alpha)
-        self.dwg.add(acircle)
-
-    def _render_rectangle(self, rectangle, color):
-        center = map(mul, rectangle.position, self.scale)
-        size = tuple(map(mul, (rectangle.width, rectangle.height), map(abs, self.scale)))
-        insert = center[0] - size[0] / 2., center[1] - size[1] / 2.
-        arect = self.dwg.rect(insert=insert, size=size,
-                              fill=svg_color(color))
-        arect.fill(opacity=self.alpha)
-        self.dwg.add(arect)
-
-    def _render_obround(self, obround, color):
-        x, y = tuple(map(mul, obround.position, self.scale))
-        xsize, ysize = tuple(map(mul, (obround.width, obround.height),
-                                 self.scale))
-        xscale, yscale = self.scale
-
-        # Corner case...
-        if xsize == ysize:
-            circle = self.dwg.circle(center=(x, y),
-                                   r = (xsize / 2.0),
-                                   fill=svg_color(color))
-            circle.fill(opacity=self.alpha)
-            self.dwg.add(circle)
-
-        # Horizontal obround
-        elif xsize > ysize:
-            rectx = xsize - ysize
-            recty = ysize
-            c1 = self.dwg.circle(center=(x - (rectx / 2.0), y),
-                                 r = (ysize / 2.0),
-                                 fill=svg_color(color))
-
-            c2 = self.dwg.circle(center=(x + (rectx / 2.0), y),
-                                 r = (ysize / 2.0),
-                                 fill=svg_color(color))
-
-            rect = self.dwg.rect(insert=(x, y),
-                                 size=(xsize, ysize),
-                                 fill=svg_color(color))
-            c1.fill(opacity=self.alpha)
-            c2.fill(opacity=self.alpha)
-            rect.fill(opacity=self.alpha)
-            self.dwg.add(c1)
-            self.dwg.add(c2)
-            self.dwg.add(rect)
-
-        # Vertical obround
-        else:
-            rectx = xsize
-            recty = ysize - xsize
-            c1 = self.dwg.circle(center=(x, y - (recty / 2.)),
-                                 r = (xsize / 2.),
-                                 fill=svg_color(color))
-
-            c2 = self.dwg.circle(center=(x, y + (recty / 2.)),
-                                 r = (xsize / 2.),
-                                 fill=svg_color(color))
-
-            rect = self.dwg.rect(insert=(x, y),
-                                size=(xsize, ysize),
-                                fill=svg_color(color))
-            c1.fill(opacity=self.alpha)
-            c2.fill(opacity=self.alpha)
-            rect.fill(opacity=self.alpha)
-            self.dwg.add(c1)
-            self.dwg.add(c2)
-            self.dwg.add(rect)
-
-    def _render_drill(self, circle, color):
-        center = map(mul, circle.position, self.scale)
-        hit = self.dwg.circle(center=center, r=SCALE * circle.radius,
-                              fill=svg_color(color))
-        self.dwg.add(hit)
diff --git a/gerber/render/theme.py b/gerber/render/theme.py
new file mode 100644
index 0000000..6135ccb
--- /dev/null
+++ b/gerber/render/theme.py
@@ -0,0 +1,70 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2013-2014 Paulo Henrique Silva <ph.silva@gmail.com>
+
+# 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 .render import RenderSettings
+
+COLORS = {
+    'black': (0.0, 0.0, 0.0),
+    'white': (1.0, 1.0, 1.0),
+    'red': (1.0, 0.0, 0.0),
+    'green': (0.0, 1.0, 0.0),
+    'blue': (0.0, 0.0, 1.0),
+    'fr-4': (0.290, 0.345, 0.0),
+    'green soldermask': (0.0, 0.612, 0.396),
+    'blue soldermask': (0.059, 0.478, 0.651),
+    'red soldermask': (0.968, 0.169, 0.165),
+    'black soldermask': (0.298, 0.275, 0.282),
+    'purple soldermask': (0.2, 0.0, 0.334),
+    'enig copper': (0.686, 0.525, 0.510),
+    'hasl copper': (0.871, 0.851, 0.839)
+}
+
+
+class Theme(object):
+
+    def __init__(self, name=None, **kwargs):
+        self.name = 'Default' if name is None else name
+        self.background = kwargs.get('background', RenderSettings(COLORS['black'], alpha=0.0))
+        self.topsilk = kwargs.get('topsilk', RenderSettings(COLORS['white']))
+        self.bottomsilk = kwargs.get('bottomsilk', RenderSettings(COLORS['white']))
+        self.topmask = kwargs.get('topmask', RenderSettings(COLORS['green soldermask'], alpha=0.8, invert=True))
+        self.bottommask = kwargs.get('bottommask', RenderSettings(COLORS['green soldermask'], alpha=0.8, invert=True))
+        self.top = kwargs.get('top', RenderSettings(COLORS['hasl copper']))
+        self.bottom = kwargs.get('top', RenderSettings(COLORS['hasl copper']))
+        self.drill = kwargs.get('drill', RenderSettings(COLORS['black']))
+        self.ipc_netlist = kwargs.get('ipc_netlist', RenderSettings(COLORS['red']))
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def get(self, key, noneval=None):
+        val = getattr(self, key)
+        return val if val is not None else noneval
+
+
+THEMES = {
+    'default': Theme(),
+    'OSH Park': Theme(name='OSH Park',
+                      top=RenderSettings(COLORS['enig copper']),
+                      bottom=RenderSettings(COLORS['enig copper']),
+                      topmask=RenderSettings(COLORS['purple soldermask'], alpha=0.8, invert=True),
+                      bottommask=RenderSettings(COLORS['purple soldermask'], alpha=0.8, invert=True)),
+    'Blue': Theme(name='Blue',
+                  topmask=RenderSettings(COLORS['blue soldermask'], alpha=0.8, invert=True),
+                  bottommask=RenderSettings(COLORS['blue soldermask'], alpha=0.8, invert=True)),
+}