Merge pull request #5 from hamiltonkibbe/merge-curtacircuitos

Merge curtacircuitos

5 files changed, 316 insertions, 392 deletions

diff --git a/gerber/render/__init__.py b/gerber/render/__init__.py
index f76d28f..3598c4d 100644
--- a/gerber/render/__init__.py
+++ b/gerber/render/__init__.py
@@ -25,3 +25,4 @@ SVG is the only supported format.
 
 
 from .cairo_backend import GerberCairoContext
+from .render import RenderSettings
diff --git a/gerber/render/cairo_backend.py b/gerber/render/cairo_backend.py
index 8c7232f..31a1e77 100644
--- a/gerber/render/cairo_backend.py
+++ b/gerber/render/cairo_backend.py
@@ -12,29 +12,25 @@
 # 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

 

-import cairocffi as cairo

+from operator import mul

+import tempfile

+import copy

+import os

 

-from ..primitives import *

 from .render import GerberContext, RenderSettings

 from .theme import THEMES

+from ..primitives import *

 

-try:

-    from cStringIO import StringIO

-except(ImportError):

-    from io import StringIO

+from io import BytesIO

 

 

 class GerberCairoContext(GerberContext):

@@ -43,15 +39,16 @@ class GerberCairoContext(GerberContext):
         super(GerberCairoContext, self).__init__()

         self.scale = (scale, scale)

         self.surface = None

+        self.surface_buffer = None

         self.ctx = None

         self.active_layer = None

+        self.active_matrix = None

         self.output_ctx = None

-        self.bg = False

-        self.mask = None

-        self.mask_ctx = None

+        self.has_bg = False

         self.origin_in_inch = None

         self.size_in_inch = None

         self._xform_matrix = None

+        self._render_count = 0

 

     @property

     def origin_in_pixels(self):

@@ -72,10 +69,8 @@ class GerberCairoContext(GerberContext):
         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.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])

@@ -83,20 +78,48 @@ class GerberCairoContext(GerberContext):
                                           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']):

+    def render_layer(self, layer, filename=None, settings=None, bgsettings=None,

+                     verbose=False):

+        if settings is None:

+            settings = THEMES['default'].get(layer.layer_class, RenderSettings())

+        if bgsettings is None:

+            bgsettings = THEMES['default'].get('background', RenderSettings())

+

+        if self._render_count == 0:

+            if verbose:

+                print('[Render]: Rendering Background.')

+            self.clear()

+            self.set_bounds(layer.bounds)

+            self._paint_background(bgsettings)

+        if verbose:

+            print('[Render]: Rendering {} Layer.'.format(layer.layer_class))

+        self._render_count += 1

+        self._render_layer(layer, settings)

+        if filename is not None:

+            self.dump(filename, verbose)

+

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

+                      verbose=False):

         """ Render a set of layers

         """

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

-        self._paint_background(True)

-

+        self.clear()

+        bgsettings = theme['background']

         for layer in layers:

-            self._render_layer(layer, theme)

-        self.dump(filename)

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

+            self.render_layer(layer, settings=settings, bgsettings=bgsettings,

+                              verbose=verbose)

+        self.dump(filename, verbose)

 

-    def dump(self, filename):

+    def dump(self, filename=None, verbose=False):

         """ Save image as `filename`

         """

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

+        try:

+            is_svg = os.path.splitext(filename.lower())[1] == '.svg'

+        except:

+            is_svg = False

+        if verbose:

+            print('[Render]: Writing image to {}'.format(filename))

+        if is_svg:

             self.surface.finish()

             self.surface_buffer.flush()

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

@@ -107,9 +130,9 @@ class GerberCairoContext(GerberContext):
             return self.surface.write_to_png(filename)

 

     def dump_str(self):

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

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

         """

-        fobj = StringIO()

+        fobj = BytesIO()

         self.surface.write_to_png(fobj)

         return fobj.getvalue()

 

@@ -120,54 +143,40 @@ class GerberCairoContext(GerberContext):
         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

+    def clear(self):

+        self.surface = None

+        self.output_ctx = None

+        self.has_bg = False

+        self.origin_in_inch = None

+        self.size_in_inch = None

+        self._xform_matrix = None

+        self._render_count = 0

+        if hasattr(self.surface_buffer, 'close'):

+            self.surface_buffer.close()

+            self.surface_buffer = None

 

+    def _render_layer(self, layer, settings):

+        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...')

+        self._new_render_layer(mirror=settings.mirror)

         for prim in layer.primitives:

             self.render(prim)

         # Add layer to image

-        self._flatten()

+        self._flatten(settings.color, settings.alpha)

 

     def _render_line(self, line, color):

         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)

+        self.ctx.set_operator(cairo.OPERATOR_SOURCE

+                              if line.level_polarity == 'dark' and

+                              (not self.invert) else 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)

@@ -190,61 +199,24 @@ class GerberCairoContext(GerberContext):
             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_operator(cairo.OPERATOR_SOURCE

+                              if arc.level_polarity == 'dark' and

+                                 (not self.invert) else cairo.OPERATOR_CLEAR)

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

         self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)

         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):

-        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_operator(cairo.OPERATOR_SOURCE

+                              if region.level_polarity == 'dark' and

+                              (not self.invert) else cairo.OPERATOR_CLEAR)

         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))

@@ -262,71 +234,41 @@ class GerberCairoContext(GerberContext):
                 else:

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

                                           angle1=angle1, angle2=angle2)

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


+        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_operator(cairo.OPERATOR_SOURCE

+                              if circle.level_polarity == 'dark' and

+                                 (not self.invert) else cairo.OPERATOR_CLEAR)

         self.ctx.set_line_width(0)

-        self.ctx.arc(center[0], center[1], radius=circle.radius * self.scale[0], 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()

-        

+

         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.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 = 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 *

-                     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):

         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)

-            

+        width, height = tuple([abs(coord) for coord in

+                               self.scale_point((rectangle.width,

+                                                 rectangle.height))])

+        self.ctx.set_operator(cairo.OPERATOR_SOURCE

+                              if rectangle.level_polarity == 'dark' and

+                              (not self.invert) else 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])

@@ -335,128 +277,107 @@ class GerberCairoContext(GerberContext):
             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.rectangle(*lower_left, width=width, height=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)

+            self.ctx.set_operator(cairo.OPERATOR_CLEAR

+                                  if rectangle.level_polarity == 'dark'

+                                     and (not self.invert)

+                                  else cairo.OPERATOR_SOURCE)

             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.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(*lower_left, width=width, height=height)

-        self.ctx.fill()

->>>>>>> 5476da8... Fix a bunch of rendering bugs.
+        if rectangle.rotation != 0:

+            self.ctx.restore()

 

     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.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)

-            

+        self.ctx.set_operator(cairo.OPERATOR_SOURCE

+                              if polygon.level_polarity == 'dark' and

+                                 (not self.invert) else cairo.OPERATOR_CLEAR)

         if polygon.hole_radius > 0:

             self.ctx.push_group()

-        

-        vertices = polygon.vertices 

+

+        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_operator(cairo.OPERATOR_CLEAR

+                                  if polygon.level_polarity == 'dark'

+                                     and (not self.invert)

+                                  else cairo.OPERATOR_SOURCE)

             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.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=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)

+

+        self.ctx.set_operator(cairo.OPERATOR_SOURCE

+                              if slot.level_polarity == 'dark' and

+                                 (not self.invert) else cairo.OPERATOR_CLEAR)

 

         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:

@@ -465,64 +386,56 @@ class GerberCairoContext(GerberContext):
         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)

+        position = [pos + origin for pos, origin in

+                    zip(primitive.position, self.origin_in_inch)]

         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.set_operator(cairo.OPERATOR_SOURCE

+                              if primitive.level_polarity == 'dark' and

+                              (not self.invert) 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)
+        self.ctx.scale(1, -1)

 

-    def _new_render_layer(self, color=None):

+    def _new_render_layer(self, color=None, mirror=False):

         size_in_pixels = self.scale_point(self.size_in_inch)

+        matrix = copy.copy(self._xform_matrix)

         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])

+                      (-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()

+        if mirror:

+            matrix.xx = -1.0

+            matrix.x0 = self.origin_in_pixels[0] + self.size_in_pixels[0]

         self.ctx = ctx

         self.active_layer = layer

+        self.active_matrix = matrix

 

-    def _flatten(self):

-        self.output_ctx.set_operator(cairo.OPERATOR_OVER)

-<<<<<<< HEAD
-        ptn = cairo.SurfacePattern(self.active_layer)
-=======
+    def _flatten(self, color=None, alpha=None):

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

+        alpha = alpha if alpha is not None else self.alpha

         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()

+        ptn.set_matrix(self.active_matrix)

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

+        self.output_ctx.mask(ptn)

         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.active_matrix = None

+

+    def _paint_background(self, settings=None):

+        color = settings.color if settings is not None else self.background_color

+        alpha = settings.alpha if settings is not None else 1.0

+        if not self.has_bg:

+            self.has_bg = True

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

             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/render.py b/gerber/render/render.py
index b319648..79f43d6 100644
--- a/gerber/render/render.py
+++ b/gerber/render/render.py
@@ -45,7 +45,8 @@ class GerberContext(object):
         Measurement units. 'inch' or 'metric'
 
     color : tuple (<float>, <float>, <float>)
-        Color used for rendering as a tuple of normalized (red, green, blue) values.
+        Color used for rendering as a tuple of normalized (red, green, blue)
+        values.
 
     drill_color : tuple (<float>, <float>, <float>)
         Color used for rendering drill hits. Format is the same as for `color`.
@@ -62,6 +63,7 @@ class GerberContext(object):
         self._units = units
         self._color = (0.7215, 0.451, 0.200)
         self._background_color = (0.0, 0.0, 0.0)
+        self._drill_color = (0.0, 0.0, 0.0)
         self._alpha = 1.0
         self._invert = False
         self.ctx = None
@@ -136,9 +138,9 @@ class GerberContext(object):
     def render(self, primitive):
         if not primitive:
             return
-        
+
         self._pre_render_primitive(primitive)
-        
+
         color = self.color
         if isinstance(primitive, Line):
             self._render_line(primitive, color)
@@ -164,16 +166,16 @@ class GerberContext(object):
             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
@@ -182,7 +184,6 @@ class GerberContext(object):
         return
 
 
-
     def _render_line(self, primitive, color):
         pass
 
@@ -206,10 +207,10 @@ class GerberContext(object):
 
     def _render_drill(self, primitive, color):
         pass
-    
+
     def _render_slot(self, primitive, color):
         pass
-    
+
     def _render_amgroup(self, primitive, color):
         pass
 
@@ -218,8 +219,8 @@ class GerberContext(object):
 
 
 class RenderSettings(object):
-
-    def __init__(self, color=(0.0, 0.0, 0.0), alpha=1.0, invert=False, mirror=False):
+    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
diff --git a/gerber/render/rs274x_backend.py b/gerber/render/rs274x_backend.py
index b4b4612..13e871c 100644
--- a/gerber/render/rs274x_backend.py
+++ b/gerber/render/rs274x_backend.py
@@ -6,7 +6,7 @@ try:
     from cStringIO import StringIO
 except(ImportError):
     from io import StringIO
-    
+
 from .render import GerberContext
 from ..am_statements import *
 from ..gerber_statements import *
@@ -15,27 +15,27 @@ from ..primitives import AMGroup, Arc, Circle, Line, Obround, Outline, Polygon,
 
 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):
@@ -50,46 +50,46 @@ class AMGroupContext(object):
                     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
@@ -97,65 +97,65 @@ class Rs274xContext(GerberContext):
         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):
@@ -168,61 +168,61 @@ class Rs274xContext(GerberContext):
                 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':
@@ -233,59 +233,59 @@ class Rs274xContext(GerberContext):
             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:
@@ -294,13 +294,13 @@ class Rs274xContext(GerberContext):
                 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)
@@ -308,122 +308,122 @@ class Rs274xContext(GerberContext):
 
     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:
@@ -435,7 +435,7 @@ class Rs274xContext(GerberContext):
                 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
@@ -444,52 +444,51 @@ class Rs274xContext(GerberContext):
                 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]                
-            
+                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/theme.py b/gerber/render/theme.py
index 6135ccb..2887216 100644
--- a/gerber/render/theme.py
+++ b/gerber/render/theme.py
@@ -25,12 +25,12 @@ COLORS = {
     '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),
+    'green soldermask': (0.0, 0.412, 0.278),
     '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),
+    'enig copper': (0.694, 0.533, 0.514),
     'hasl copper': (0.871, 0.851, 0.839)
 }
 
@@ -39,13 +39,13 @@ 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.background = kwargs.get('background', RenderSettings(COLORS['fr-4']))
         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.bottomsilk = kwargs.get('bottomsilk', RenderSettings(COLORS['white'], mirror=True))
+        self.topmask = kwargs.get('topmask', RenderSettings(COLORS['green soldermask'], alpha=0.85, invert=True))
+        self.bottommask = kwargs.get('bottommask', RenderSettings(COLORS['green soldermask'], alpha=0.85, invert=True, mirror=True))
         self.top = kwargs.get('top', RenderSettings(COLORS['hasl copper']))
-        self.bottom = kwargs.get('top', RenderSettings(COLORS['hasl copper']))
+        self.bottom = kwargs.get('bottom', RenderSettings(COLORS['hasl copper'], mirror=True))
         self.drill = kwargs.get('drill', RenderSettings(COLORS['black']))
         self.ipc_netlist = kwargs.get('ipc_netlist', RenderSettings(COLORS['red']))
 
@@ -53,18 +53,28 @@ class Theme(object):
         return getattr(self, key)
 
     def get(self, key, noneval=None):
-        val = getattr(self, key)
+        val = getattr(self, key, None)
         return val if val is not None else noneval
 
 
 THEMES = {
     'default': Theme(),
     'OSH Park': Theme(name='OSH Park',
+                      background=RenderSettings(COLORS['purple soldermask']),
                       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)),
+                      bottom=RenderSettings(COLORS['enig copper'], mirror=True),
+                      topmask=RenderSettings(COLORS['purple soldermask'], alpha=0.85, invert=True),
+                      bottommask=RenderSettings(COLORS['purple soldermask'], alpha=0.85, invert=True, mirror=True),
+                      topsilk=RenderSettings(COLORS['white'], alpha=0.8),
+                      bottomsilk=RenderSettings(COLORS['white'], alpha=0.8, mirror=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)),
+
+    'Transparent Copper': Theme(name='Transparent',
+                                background=RenderSettings((0.9, 0.9, 0.9)),
+                                top=RenderSettings(COLORS['red'], alpha=0.5),
+                                bottom=RenderSettings(COLORS['blue'], alpha=0.5),
+                                drill=RenderSettings((0.3, 0.3, 0.3))),
 }