diff options
Diffstat (limited to 'gerber/render')
| -rw-r--r-- | gerber/render/__init__.py | 1 | ||||
| -rw-r--r-- | gerber/render/cairo_backend.py | 279 | ||||
| -rw-r--r-- | gerber/render/render.py | 23 | ||||
| -rw-r--r-- | gerber/render/rs274x_backend.py | 233 | ||||
| -rw-r--r-- | gerber/render/theme.py | 32 |
5 files changed, 289 insertions, 279 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 77d413e..2ba022f 100644 --- a/gerber/render/cairo_backend.py +++ b/gerber/render/cairo_backend.py @@ -24,16 +24,16 @@ except ImportError: import math
from operator import mul, div
import tempfile
+import copy
+import os
-import cairocffi as cairo
-
-from ..primitives import *
from .render import GerberContext, RenderSettings
from .theme import THEMES
+from ..primitives import *
try:
from cStringIO import StringIO
-except(ImportError):
+except (ImportError):
from io import StringIO
@@ -43,15 +43,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 +73,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 +82,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:
@@ -104,6 +131,7 @@ class GerberCairoContext(GerberContext): f.write(self.surface_buffer.read())
f.flush()
else:
+ print("Wriitng To Png: filename: {}".format(filename))
return self.surface.write_to_png(filename)
def dump_str(self):
@@ -120,32 +148,33 @@ 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:
- 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)
- 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):
width = line.aperture.diameter
self.ctx.set_line_width(width * self.scale[0])
@@ -176,34 +205,23 @@ class GerberCairoContext(GerberContext): else:
width = max(arc.aperture.width, arc.aperture.height, 0.001)
- 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 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_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':
- self.ctx.arc(center[0], center[1], radius, angle1, angle2)
+ self.ctx.arc(*center, radius=radius, angle1=angle1, angle2=angle2)
else:
- self.ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
+ self.ctx.arc_negative(*center, radius=radius,
+ angle1=angle1, angle2=angle2)
self.ctx.move_to(*end) # ...lame
def _render_region(self, region, 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 region.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 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))
@@ -221,25 +239,16 @@ class GerberCairoContext(GerberContext): else:
self.ctx.arc_negative(*center, radius=radius,
angle1=angle1, angle2=angle2)
-
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:
@@ -247,25 +256,20 @@ class GerberCairoContext(GerberContext): 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.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)
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))])
-
-
- 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()
@@ -283,33 +287,26 @@ class GerberCairoContext(GerberContext): 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()
-
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()
@@ -322,22 +319,21 @@ class GerberCairoContext(GerberContext): 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()
@@ -357,14 +353,16 @@ class GerberCairoContext(GerberContext): # 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)
@@ -375,12 +373,9 @@ class GerberCairoContext(GerberContext): 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)
@@ -396,51 +391,55 @@ 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)
- 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)
+ 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)
- 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)
- self.output_ctx.set_source_rgba(self.background_color[0], self.background_color[1], self.background_color[2], 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):
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))), } |