From acde19f205898188c03a46e5d8a7a6a4d4637a2d Mon Sep 17 00:00:00 2001 From: Garret Fick Date: Sat, 26 Mar 2016 15:59:42 +0800 Subject: Support for the G85 slot statement --- gerber/excellon.py | 136 ++++++++++++++++++++++++++++++-------- gerber/excellon_statements.py | 130 +++++++++++++++++++++++++++++++++++- gerber/primitives.py | 36 ++++++++++ gerber/render/cairo_backend.py | 14 ++++ gerber/render/excellon_backend.py | 33 +++++++-- gerber/render/render.py | 5 ++ 6 files changed, 322 insertions(+), 32 deletions(-) (limited to 'gerber') diff --git a/gerber/excellon.py b/gerber/excellon.py index 0637b23..f9bb18a 100755 --- a/gerber/excellon.py +++ b/gerber/excellon.py @@ -34,7 +34,7 @@ except(ImportError): from .excellon_statements import * from .excellon_tool import ExcellonToolDefinitionParser from .cam import CamFile, FileSettings -from .primitives import Drill +from .primitives import Drill, Slot from .utils import inch, metric @@ -93,6 +93,51 @@ class DrillHit(object): if self.tool.units == 'inch': self.tool.to_metric() self.position = tuple(map(metric, self.position)) + + @property + def bounding_box(self): + position = self.position + radius = self.tool.diameter / 2. + + min_x = position[0] - radius + max_x = position[0] + radius + min_y = position[1] - radius + max_y = position[1] + radius + return ((min_x, max_x), (min_y, max_y)) + + +class DrillSlot(object): + """ + A slot is created between two points. The way the slot is created depends on the statement used to create it + """ + + def __init__(self, tool, start, end): + self.tool = tool + self.start = start + self.end = end + + def to_inch(self): + if self.tool.units == 'metric': + self.tool.to_inch() + self.start = tuple(map(inch, self.start)) + self.end = tuple(map(inch, self.end)) + + def to_metric(self): + if self.tool.units == 'inch': + self.tool.to_metric() + self.start = tuple(map(metric, self.start)) + self.end = tuple(map(metric, self.end)) + + @property + def bounding_box(self): + start = self.start + end = self.end + radius = self.tool.diameter / 2. + min_x = min(start[0], end[0]) - radius + max_x = max(start[0], end[0]) + radius + min_y = min(start[1], end[1]) - radius + max_y = max(start[1], end[1]) + radius + return ((min_x, max_x), (min_y, max_y)) class ExcellonFile(CamFile): @@ -131,7 +176,17 @@ class ExcellonFile(CamFile): @property def primitives(self): - return [Drill(hit.position, hit.tool.diameter, hit, units=self.settings.units) for hit in self.hits] + + primitives = [] + for hit in self.hits: + if isinstance(hit, DrillHit): + primitives.append(Drill(hit.position, hit.tool.diameter, hit, units=self.settings.units)) + elif isinstance(hit, DrillSlot): + primitives.append(Slot(hit.start, hit.end, hit.tool.diameter, hit, units=self.settings.units)) + else: + raise ValueError('Unknown hit type') + + return primitives @property @@ -139,12 +194,11 @@ class ExcellonFile(CamFile): xmin = ymin = 100000000000 xmax = ymax = -100000000000 for hit in self.hits: - radius = hit.tool.diameter / 2. - x, y = hit.position - xmin = min(x - radius, xmin) - xmax = max(x + radius, xmax) - ymin = min(y - radius, ymin) - ymax = max(y + radius, ymax) + bbox = hit.bounding_box + xmin = min(bbox[0][0], xmin) + xmax = max(bbox[0][1], xmax) + ymin = min(bbox[1][0], ymin) + ymax = max(bbox[1][1], ymax) return ((xmin, xmax), (ymin, ymax)) def report(self, filename=None): @@ -545,26 +599,54 @@ class ExcellonParser(object): self.active_tool._hit() elif line[0] in ['X', 'Y']: - stmt = CoordinateStmt.from_excellon(line, self._settings()) - x = stmt.x - y = stmt.y - self.statements.append(stmt) - if self.notation == 'absolute': - if x is not None: - self.pos[0] = x - if y is not None: - self.pos[1] = y - else: - if x is not None: - self.pos[0] += x - if y is not None: - self.pos[1] += y - if self.state == 'DRILL': - if not self.active_tool: - self.active_tool = self._get_tool(1) + if 'G85' in line: + stmt = SlotStmt.from_excellon(line, self._settings()) - self.hits.append(DrillHit(self.active_tool, tuple(self.pos))) - self.active_tool._hit() + # I don't know if this is actually correct, but it makes sense that this is where the tool would end + x = stmt.x_end + y = stmt.y_end + + self.statements.append(stmt) + + if self.notation == 'absolute': + if x is not None: + self.pos[0] = x + if y is not None: + self.pos[1] = y + else: + if x is not None: + self.pos[0] += x + if y is not None: + self.pos[1] += y + + if self.state == 'DRILL': + if not self.active_tool: + self.active_tool = self._get_tool(1) + + self.hits.append(DrillSlot(self.active_tool, (stmt.x_start, stmt.y_start), (stmt.x_end, stmt.y_end))) + self.active_tool._hit() + else: + stmt = CoordinateStmt.from_excellon(line, self._settings()) + x = stmt.x + y = stmt.y + self.statements.append(stmt) + if self.notation == 'absolute': + if x is not None: + self.pos[0] = x + if y is not None: + self.pos[1] = y + else: + if x is not None: + self.pos[0] += x + if y is not None: + self.pos[1] += y + + if self.state == 'DRILL': + if not self.active_tool: + self.active_tool = self._get_tool(1) + + self.hits.append(DrillHit(self.active_tool, tuple(self.pos))) + self.active_tool._hit() else: self.statements.append(UnknownStmt.from_excellon(line)) diff --git a/gerber/excellon_statements.py b/gerber/excellon_statements.py index cabdf6c..a6a5a5e 100644 --- a/gerber/excellon_statements.py +++ b/gerber/excellon_statements.py @@ -37,7 +37,7 @@ __all__ = ['ExcellonTool', 'ToolSelectionStmt', 'CoordinateStmt', 'RetractWithClampingStmt', 'RetractWithoutClampingStmt', 'CutterCompensationOffStmt', 'CutterCompensationLeftStmt', 'CutterCompensationRightStmt', 'ZAxisInfeedRateStmt', - 'NextToolSelectionStmt'] + 'NextToolSelectionStmt', 'SlotStmt'] class ExcellonStatement(object): @@ -645,6 +645,12 @@ class EndOfProgramStmt(ExcellonStatement): self.y += y_offset class UnitStmt(ExcellonStatement): + + @classmethod + def from_settings(cls, settings): + """Create the unit statement from the FileSettings""" + + return cls(settings.units, settings.zeros) @classmethod def from_excellon(cls, line, **kwargs): @@ -827,6 +833,128 @@ class UnknownStmt(ExcellonStatement): return "" % self.stmt +class SlotStmt(ExcellonStatement): + """ + G85 statement. Defines a slot created by multiple drills between two specified points. + + Format is two coordinates, split by G85in the middle, for example, XnY0nG85XnYn + """ + + @classmethod + def from_points(cls, start, end): + + return cls(start[0], start[1], end[0], end[1]) + + @classmethod + def from_excellon(cls, line, settings, **kwargs): + # Split the line based on the G85 separator + sub_coords = line.split('G85') + (x_start_coord, y_start_coord) = SlotStmt.parse_sub_coords(sub_coords[0], settings) + (x_end_coord, y_end_coord) = SlotStmt.parse_sub_coords(sub_coords[1], settings) + + + c = cls(x_start_coord, y_start_coord, x_end_coord, y_end_coord, **kwargs) + c.units = settings.units + return c + + @staticmethod + def parse_sub_coords(line, settings): + + x_coord = None + y_coord = None + + if line[0] == 'X': + splitline = line.strip('X').split('Y') + x_coord = parse_gerber_value(splitline[0], settings.format, + settings.zero_suppression) + if len(splitline) == 2: + y_coord = parse_gerber_value(splitline[1], settings.format, + settings.zero_suppression) + else: + y_coord = parse_gerber_value(line.strip(' Y'), settings.format, + settings.zero_suppression) + + return (x_coord, y_coord) + + + def __init__(self, x_start=None, y_start=None, x_end=None, y_end=None, **kwargs): + super(SlotStmt, self).__init__(**kwargs) + self.x_start = x_start + self.y_start = y_start + self.x_end = x_end + self.y_end = y_end + self.mode = None + + def to_excellon(self, settings): + stmt = '' + + if self.x_start is not None: + stmt += 'X%s' % write_gerber_value(self.x_start, settings.format, + settings.zero_suppression) + if self.y_start is not None: + stmt += 'Y%s' % write_gerber_value(self.y_start, settings.format, + settings.zero_suppression) + + stmt += 'G85' + + if self.x_end is not None: + stmt += 'X%s' % write_gerber_value(self.x_end, settings.format, + settings.zero_suppression) + if self.y_end is not None: + stmt += 'Y%s' % write_gerber_value(self.y_end, settings.format, + settings.zero_suppression) + + return stmt + + def to_inch(self): + if self.units == 'metric': + self.units = 'inch' + if self.x_start is not None: + self.x_start = inch(self.x_start) + if self.y_start is not None: + self.y_start = inch(self.y_start) + if self.x_end is not None: + self.x_end = inch(self.x_end) + if self.y_end is not None: + self.y_end = inch(self.y_end) + + def to_metric(self): + if self.units == 'inch': + self.units = 'metric' + if self.x_start is not None: + self.x_start = metric(self.x_start) + if self.y_start is not None: + self.y_start = metric(self.y_start) + if self.x_end is not None: + self.x_end = metric(self.x_end) + if self.y_end is not None: + self.y_end = metric(self.y_end) + + def offset(self, x_offset=0, y_offset=0): + if self.x_start is not None: + self.x_start += x_offset + if self.y_start is not None: + self.y_start += y_offset + if self.x_end is not None: + self.x_end += x_offset + if self.y_end is not None: + self.y_end += y_offset + + def __str__(self): + start_str = '' + if self.x_start is not None: + start_str += 'X: %g ' % self.x_start + if self.y_start is not None: + start_str += 'Y: %g ' % self.y_start + + end_str = '' + if self.x_end is not None: + end_str += 'X: %g ' % self.x_end + if self.y_end is not None: + end_str += 'Y: %g ' % self.y_end + + return '' % (start_str, end_str) + def pairwise(iterator): """ Iterate over list taking two elements at a time. diff --git a/gerber/primitives.py b/gerber/primitives.py index e5ff35f..3ecf0db 100644 --- a/gerber/primitives.py +++ b/gerber/primitives.py @@ -1109,6 +1109,42 @@ class Drill(Primitive): def offset(self, x_offset=0, y_offset=0): self.position = tuple(map(add, self.position, (x_offset, y_offset))) + + +class Slot(Primitive): + """ A drilled slot + """ + def __init__(self, start, end, diameter, hit, **kwargs): + super(Slot, self).__init__('dark', **kwargs) + validate_coordinates(start) + validate_coordinates(end) + self.start = start + self.end = end + self.diameter = diameter + self.hit = hit + self._to_convert = ['start', 'end', 'diameter'] + + @property + def flashed(self): + return False + + @property + def radius(self): + return self.diameter / 2. + + @property + def bounding_box(self): + radius = self.radius + min_x = min(self.start[0], self.end[0]) - radius + max_x = max(self.start[0], self.end[0]) + radius + min_y = min(self.start[1], self.end[1]) - radius + max_y = max(self.start[1], self.end[1]) + radius + return ((min_x, max_x), (min_y, max_y)) + + 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))) + class TestRecord(Primitive): """ Netlist Test record diff --git a/gerber/render/cairo_backend.py b/gerber/render/cairo_backend.py index 7be7e6a..d895e5c 100644 --- a/gerber/render/cairo_backend.py +++ b/gerber/render/cairo_backend.py @@ -173,6 +173,20 @@ class GerberCairoContext(GerberContext): def _render_drill(self, circle, 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 + + self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha) + self.ctx.set_operator(cairo.OPERATOR_OVER if (slot.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR) + self.ctx.set_line_width(width * self.scale[0]) + self.ctx.set_line_cap(cairo.LINE_CAP_ROUND) + self.ctx.move_to(*start) + self.ctx.line_to(*end) + self.ctx.stroke() + def _render_amgroup(self, amgroup, color): for primitive in amgroup.primitives: self.render(primitive) diff --git a/gerber/render/excellon_backend.py b/gerber/render/excellon_backend.py index f5cec1a..eb79f1b 100644 --- a/gerber/render/excellon_backend.py +++ b/gerber/render/excellon_backend.py @@ -9,6 +9,7 @@ class ExcellonContext(GerberContext): self.comments = [] self.header = [] self.tool_def = [] + self.body_start = [RewindStopStmt()] self.body = [] self.start = [HeaderBeginStmt()] self.end = [EndOfProgramStmt()] @@ -19,14 +20,22 @@ class ExcellonContext(GerberContext): self.settings = settings - self._start_header(settings) + self._start_header() + self._start_comments() - def _start_header(self, settings): - pass + def _start_header(self): + """Create the header from the settings""" + + self.header.append(UnitStmt.from_settings(self.settings)) + + 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]))) @property def statements(self): - return self.start + self.comments + self.header + self.body + self.end + return self.start + self.comments + self.header + self.body_start + self.body + self.end def set_bounds(self, bounds): pass @@ -69,10 +78,26 @@ class ExcellonContext(GerberContext): 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 _render_slot(self, slot, color): + + 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 + + # 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 diff --git a/gerber/render/render.py b/gerber/render/render.py index b518385..a5ae38e 100644 --- a/gerber/render/render.py +++ b/gerber/render/render.py @@ -150,6 +150,8 @@ class GerberContext(object): self._render_polygon(primitive, color) elif isinstance(primitive, Drill): self._render_drill(primitive, self.drill_color) + elif isinstance(primitive, Slot): + self._render_slot(primitive, self.drill_color) elif isinstance(primitive, AMGroup): self._render_amgroup(primitive, color) elif isinstance(primitive, Outline): @@ -183,6 +185,9 @@ class GerberContext(object): def _render_drill(self, primitive, color): pass + def _render_slot(self, primitive, color): + pass + def _render_amgroup(self, primitive, color): pass -- cgit