summaryrefslogtreecommitdiff
path: root/gerber/render
diff options
context:
space:
mode:
authorHamilton Kibbe <hamilton.kibbe@gmail.com>2016-11-05 21:11:09 -0400
committerGitHub <noreply@github.com>2016-11-05 21:11:09 -0400
commitd2fe4441662435e55f2dc481bf94a2729b9d6a48 (patch)
treedd60a0b21e1d1ca7258b9f978ce973354d96062c /gerber/render
parent318a81382e074a5897489299a58e029815d23492 (diff)
parent5af19af190c1fb0f0c5be029d46d63e657dde4d9 (diff)
downloadgerbonara-d2fe4441662435e55f2dc481bf94a2729b9d6a48.tar.gz
gerbonara-d2fe4441662435e55f2dc481bf94a2729b9d6a48.tar.bz2
gerbonara-d2fe4441662435e55f2dc481bf94a2729b9d6a48.zip
Merge pull request #3 from garretfick/merge-curtacircuitos
Merge curtacircuitos
Diffstat (limited to 'gerber/render')
-rw-r--r--gerber/render/__init__.py3
-rw-r--r--gerber/render/apertures.py76
-rw-r--r--gerber/render/cairo_backend.py529
-rw-r--r--gerber/render/excellon_backend.py189
-rw-r--r--gerber/render/render.py204
-rw-r--r--gerber/render/rs274x_backend.py495
-rw-r--r--gerber/render/svgwrite_backend.py155
-rw-r--r--gerber/render/theme.py70
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)),
+}