From 29c0d82bf53907030d11df9eb09471b716a0be2e Mon Sep 17 00:00:00 2001 From: Garret Fick Date: Sat, 27 Feb 2016 15:24:36 +0800 Subject: RS274X backend for rendering. Incompelte still --- gerber/gerber_statements.py | 65 ++++++++- gerber/primitives.py | 46 ++++++- gerber/render/rs274x_backend.py | 290 ++++++++++++++++++++++++++++++++++++++++ gerber/utils.py | 6 + 4 files changed, 403 insertions(+), 4 deletions(-) create mode 100644 gerber/render/rs274x_backend.py (limited to 'gerber') diff --git a/gerber/gerber_statements.py b/gerber/gerber_statements.py index 14a431b..bb190f4 100644 --- a/gerber/gerber_statements.py +++ b/gerber/gerber_statements.py @@ -226,6 +226,11 @@ class LPParamStmt(ParamStmt): param = stmt_dict['param'] lp = 'clear' if stmt_dict.get('lp') == 'C' else 'dark' return cls(param, lp) + + @classmethod + def from_region(cls, region): + #todo what is the first param? + return cls(None, region.level_polarity) def __init__(self, param, lp): """ Initialize LPParamStmt class @@ -258,7 +263,21 @@ class LPParamStmt(ParamStmt): class ADParamStmt(ParamStmt): """ AD - Gerber Aperture Definition Statement """ - + + @classmethod + def rect(cls, dcode, width, height): + '''Create a rectangular aperture definition statement''' + return cls('AD', dcode, 'R', ([width, height],)) + + @classmethod + def circle(cls, dcode, diameter): + '''Create a circular aperture definition statement''' + return cls('AD', dcode, 'C', ([diameter],)) + + @classmethod + def macro(cls, dcode, name): + return cls('AD', dcode, name, '') + @classmethod def from_dict(cls, stmt_dict): param = stmt_dict.get('param') @@ -293,7 +312,9 @@ class ADParamStmt(ParamStmt): ParamStmt.__init__(self, param) self.d = d self.shape = shape - if modifiers: + if isinstance(modifiers, tuple): + self.modifiers = modifiers + elif modifiers: self.modifiers = [tuple([float(x) for x in m.split("X") if len(x)]) for m in modifiers.split(",") if len(m)] else: self.modifiers = [tuple()] @@ -817,6 +838,14 @@ class CoordStmt(Statement): """ Coordinate Data Block """ + OP_DRAW = 'D01' + OP_MOVE = 'D02' + OP_FLASH = 'D03' + + FUNC_LINEAR = 'G01' + FUNC_ARC_CW = 'G02' + FUNC_ARC_CCW = 'G03' + @classmethod def from_dict(cls, stmt_dict, settings): function = stmt_dict['function'] @@ -835,6 +864,22 @@ class CoordStmt(Statement): if j is not None: j = parse_gerber_value(stmt_dict.get('j'), settings.format, settings.zero_suppression) return cls(function, x, y, i, j, op, settings) + + @classmethod + def move(cls, func, point): + return cls(func, point[0], point[1], None, None, CoordStmt.OP_MOVE, None) + + @classmethod + def line(cls, func, point): + return cls(func, point[0], point[1], None, None, CoordStmt.OP_DRAW, None) + + @classmethod + def arc(cls, func, point, center): + return cls(func, point[0], point[1], center[0], center[1], CoordStmt.OP_DRAW, None) + + @classmethod + def flash(cls, point): + return cls(None, point[0], point[1], None, None, CoordStmt.OP_FLASH, None) def __init__(self, function, x, y, i, j, op, settings): """ Initialize CoordStmt class @@ -1003,6 +1048,14 @@ class EofStmt(Statement): class QuadrantModeStmt(Statement): + + @classmethod + def single(cls): + return cls('single-quadrant') + + @classmethod + def multi(cls): + return cls('multi-quadrant') @classmethod def from_gerber(cls, line): @@ -1031,6 +1084,14 @@ class RegionModeStmt(Statement): if 'G36' not in line and 'G37' not in line: raise ValueError('%s is not a valid region mode statement' % line) return (cls('on') if line[:3] == 'G36' else cls('off')) + + @classmethod + def on(cls): + return cls('on') + + @classmethod + def off(cls): + return cls('off') def __init__(self, mode): super(RegionModeStmt, self).__init__('RegionMode') diff --git a/gerber/primitives.py b/gerber/primitives.py index 84115a6..21efb55 100644 --- a/gerber/primitives.py +++ b/gerber/primitives.py @@ -17,8 +17,9 @@ import math from operator import add, sub -from .utils import validate_coordinates, inch, metric, rotate_point +from .utils import validate_coordinates, inch, metric, rotate_point, nearly_equal from jsonpickle.util import PRIMITIVES +from __builtin__ import False class Primitive(object): @@ -120,6 +121,9 @@ class Primitive(object): def __eq__(self, other): return self.__dict__ == other.__dict__ + + def to_statement(self): + pass class Line(Primitive): @@ -216,7 +220,16 @@ class Line(Primitive): def offset(self, x_offset=0, y_offset=0): self.start = tuple(map(add, self.start, (x_offset, y_offset))) self.end = tuple(map(add, self.end, (x_offset, y_offset))) + + def equivalent(self, other, offset): + + if not isinstance(other, Line): + return False + + equiv_start = tuple(map(add, other.start, offset)) + equiv_end = tuple(map(add, other.end, offset)) + return nearly_equal(self.start, equiv_start) and nearly_equal(self.end, equiv_end) class Arc(Primitive): """ @@ -736,7 +749,7 @@ class AMGroup(Primitive): elif prim: self.primitives.append(prim) self._position = None - self._to_convert = ['arimitives'] + self._to_convert = ['primitives'] @property def flashed(self): @@ -776,6 +789,21 @@ class AMGroup(Primitive): self._position = new_pos + def equivalent(self, other, offset): + ''' + Is this the macro group the same as the other, ignoring the position offset? + ''' + + if len(self.primitives) != len(other.primitives): + return False + + # We know they have the same number of primitives, so now check them all + for i in range(0, len(self.primitives)): + if not self.primitives[i].equivalent(other.primitives[i], offset): + return False + + # If we didn't find any differences, then they are the same + return True class Outline(Primitive): """ @@ -816,6 +844,20 @@ class Outline(Primitive): bounding_box = self.bounding_box() return bounding_box[1][1] - bounding_box[1][0] + def equivalent(self, other, offset): + ''' + Is this the outline the same as the other, ignoring the position offset? + ''' + + # Quick check if it even makes sense to compare them + if type(self) != type(other) or len(self.primitives) != len(other.primitives): + return False + + for i in range(0, len(self.primitives)): + if not self.primitives[i].equivalent(other.primitives[i], offset): + return False + + return True class Region(Primitive): """ diff --git a/gerber/render/rs274x_backend.py b/gerber/render/rs274x_backend.py new file mode 100644 index 0000000..0094192 --- /dev/null +++ b/gerber/render/rs274x_backend.py @@ -0,0 +1,290 @@ + +from .render import GerberContext +from ..gerber_statements import * +from ..primitives import AMGroup, Arc, Circle, Line, Rectangle + +class Rs274xContext(GerberContext): + + def __init__(self, settings): + GerberContext.__init__(self) + 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 + + self._next_dcode = 10 + self._rects = {} + self._circles = {} + self._macros = {} + + self._i_none = 0 + self._j_none = 0 + + self._define_dcodes() + + + def _define_dcodes(self): + + self._get_circle(.1575, 10) + self._get_circle(.035, 17) + self._get_rectangle(0.1575, 0.1181, 15) + self._get_rectangle(0.0492, 0.0118, 16) + self._get_circle(.0197, 11) + self._get_rectangle(0.0236, 0.0591, 12) + self._get_circle(.005, 18) + self._get_circle(.008, 19) + self._get_circle(.009, 20) + self._get_circle(.01, 21) + self._get_circle(.02, 22) + self._get_circle(.006, 23) + self._get_circle(.015, 24) + self._get_rectangle(0.1678, 0.1284, 26) + self._get_rectangle(0.0338, 0.0694, 25) + + 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.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) + elif isinstance(aperture, Rectangle): + aper = self._get_rectangle(aperture.width, aperture.height) + else: + raise NotImplementedError('Line with invalid aperture type') + + if aper.d != self._dcode: + self.body.append(ApertureStmt(aper.d)) + self._dcode = aper.d + + def _render_line(self, line, color): + + self._select_aperture(line.aperture) + + # 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 + + self.body.append(CoordStmt.line(func, self._simplify_point(line.end))) + self._pos = line.end + + 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) + + # 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) + + + 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): + + if aperture.d != self._dcode: + self.body.append(ApertureStmt(aperture.d)) + self._dcode = aperture.d + + self.body.append(CoordStmt.flash( self._simplify_point(primitive.position))) + self._pos = primitive.position + + def _get_circle(self, diameter, dcode = None): + '''Define a circlar aperture''' + + aper = self._circles.get(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) + self._circles[diameter] = aper + self.header.append(aper) + + return aper + + def _render_circle(self, circle, color): + + aper = self._get_circle(circle.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 _render_obround(self, obround, color): + pass + + def _render_polygon(self, polygon, color): + pass + + def _render_drill(self, circle, color): + pass + + def _hash_amacro(self, amgroup): + '''Calculate a very quick hash code for deciding if we should even check AM groups for comparision''' + + hash = '' + for primitive in amgroup.primitives: + + hash += primitive.__class__.__name__[0] + if hasattr(primitive, 'primitives'): + hash += str(len(primitive.primitives)) + + 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 = self._macros.get(hash, None) + + 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 + statements = [] + aperdef = ADParamStmt.macro(dcode, hash) + + # Store the dcode and the original so we can check if it really is the same + macro = (aperdef, amgroup) + self._macros[hash] = macro + + else: + # We hae a definition, but check that the groups actually are the same + offset = (amgroup.position[0] - macro[1].position[0], amgroup.position[1] - macro[1].position[1]) + if not amgroup.equivalent(macro[1], offset): + raise ValueError('Two AMGroup have the same hash but are not equivalent') + + 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 post_render_primitives(self): + '''No more primitives, so set the end marker''' + + self.body.append() \ No newline at end of file diff --git a/gerber/utils.py b/gerber/utils.py index 1c0af52..16323d6 100644 --- a/gerber/utils.py +++ b/gerber/utils.py @@ -288,3 +288,9 @@ def rotate_point(point, angle, center=(0.0, 0.0)): x = center[0] + (cos(angle) * xdelta) - (sin(angle) * ydelta) y = center[1] + (sin(angle) * xdelta) - (cos(angle) * ydelta) return (x, y) + + +def nearly_equal(point1, point2, ndigits = 6): + '''Are the points nearly equal''' + + return round(point1[0] - point2[0], ndigits) == 0 and round(point1[1] - point2[1], ndigits) == 0 -- cgit