#! /usr/bin/env python # -*- coding: utf-8 -*- # copyright 2014 Hamilton Kibbe # Modified from parser.py by Paulo Henrique Silva # # 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. """ This module provides an RS-274-X class and parser. """ import copy import json import re import sys try: from cStringIO import StringIO except(ImportError): from io import StringIO from .gerber_statements import * from .primitives import * from .cam import CamFile, FileSettings from .utils import sq_distance def read(filename): """ Read data from filename and return a GerberFile Parameters ---------- filename : string Filename of file to parse Returns ------- file : :class:`gerber.rs274x.GerberFile` A GerberFile created from the specified file. """ return GerberParser().parse(filename) def loads(data, filename=None): """ Generate a GerberFile object from rs274x data in memory Parameters ---------- data : string string containing gerber file contents filename : string, optional string containing the filename of the data source Returns ------- file : :class:`gerber.rs274x.GerberFile` A GerberFile created from the specified file. """ return GerberParser().parse_raw(data, filename) class GerberFile(CamFile): """ A class representing a single gerber file The GerberFile class represents a single gerber file. Parameters ---------- statements : list list of gerber file statements settings : dict Dictionary of gerber file settings filename : string Filename of the source gerber file Attributes ---------- comments: list of strings List of comments contained in the gerber file. size : tuple, (, ) Size in [self.units] of the layer described by the gerber file. bounds: tuple, ((, ), (, )) boundaries of the layer described by the gerber file. `bounds` is stored as ((min x, max x), (min y, max y)) """ def __init__(self, statements, settings, primitives, apertures, filename=None): super(GerberFile, self).__init__(statements, settings, primitives, filename) self.apertures = apertures @property def comments(self): return [comment.comment for comment in self.statements if isinstance(comment, CommentStmt)] @property def size(self): xbounds, ybounds = self.bounds return (xbounds[1] - xbounds[0], ybounds[1] - ybounds[0]) @property def bounds(self): min_x = min_y = 1000000 max_x = max_y = -1000000 for stmt in [stmt for stmt in self.statements if isinstance(stmt, CoordStmt)]: if stmt.x is not None: min_x = min(stmt.x, min_x) max_x = max(stmt.x, max_x) if stmt.y is not None: min_y = min(stmt.y, min_y) max_y = max(stmt.y, max_y) return ((min_x, max_x), (min_y, max_y)) @property def bounding_box(self): min_x = min_y = 1000000 max_x = max_y = -1000000 for prim in self.primitives: bounds = prim.bounding_box min_x = min(bounds[0][0], min_x) max_x = max(bounds[0][1], max_x) min_y = min(bounds[1][0], min_y) max_y = max(bounds[1][1], max_y) return ((min_x, max_x), (min_y, max_y)) def write(self, filename, settings=None): """ Write data out to a gerber file """ with open(filename, 'w') as f: for statement in self.statements: f.write(statement.to_gerber(settings or self.settings)) f.write("\n") def to_inch(self): if self.units != 'inch': self.units = 'inch' for statement in self.statements: statement.to_inch() for primitive in self.primitives: primitive.to_inch() def to_metric(self): if self.units != 'metric': self.units = 'metric' for statement in self.statements: statement.to_metric() for primitive in self.primitives: primitive.to_metric() def offset(self, x_offset=0, y_offset=0): for statement in self.statements: statement.offset(x_offset, y_offset) for primitive in self.primitives: primitive.offset(x_offset, y_offset) class GerberParser(object): """ GerberParser """ NUMBER = r"[\+-]?\d+" DECIMAL = r"[\+-]?\d+([.]?\d+)?" STRING = r"[a-zA-Z0-9_+\-/!?<>”’(){}.\|&@# :]+" NAME = r"[a-zA-Z_$\.][a-zA-Z_$\.0-9+\-]+" FS = r"(?PFS)(?P(L|T|D))?(?P(A|I))[NG0-9]*X(?P[0-7][0-7])Y(?P[0-7][0-7])[DM0-9]*" MO = r"(?PMO)(?P(MM|IN))" LP = r"(?PLP)(?P(D|C))" AD_CIRCLE = r"(?PAD)D(?P\d+)(?PC)[,]?(?P[^,%]*)" AD_RECT = r"(?PAD)D(?P\d+)(?PR)[,](?P[^,%]*)" AD_OBROUND = r"(?PAD)D(?P\d+)(?PO)[,](?P[^,%]*)" AD_POLY = r"(?PAD)D(?P\d+)(?PP)[,](?P[^,%]*)" AD_MACRO = r"(?PAD)D(?P\d+)(?P{name})[,]?(?P[^,%]*)".format(name=NAME) AM = r"(?PAM)(?P{name})\*(?P[^%]*)".format(name=NAME) # begin deprecated AS = r"(?PAS)(?P(AXBY)|(AYBX))" IN = r"(?PIN)(?P.*)" IP = r"(?PIP)(?P(POS|NEG))" IR = r"(?PIR)(?P{number})".format(number=NUMBER) MI = r"(?PMI)(A(?P0|1))?(B(?P0|1))?" OF = r"(?POF)(A(?P{decimal}))?(B(?P{decimal}))?".format(decimal=DECIMAL) SF = r"(?PSF)(?P.*)" LN = r"(?PLN)(?P.*)" DEPRECATED_UNIT = re.compile(r'(?PG7[01])\*') DEPRECATED_FORMAT = re.compile(r'(?PG9[01])\*') # end deprecated PARAMS = (FS, MO, LP, AD_CIRCLE, AD_RECT, AD_OBROUND, AD_POLY, AD_MACRO, AM, AS, IN, IP, IR, MI, OF, SF, LN) PARAM_STMT = [re.compile(r"%?{0}\*%?".format(p)) for p in PARAMS] COORD_FUNCTION = r"G0?[123]" COORD_OP = r"D0?[123]" COORD_STMT = re.compile(( r"(?P{function})?" r"(X(?P{number}))?(Y(?P{number}))?" r"(I(?P{number}))?(J(?P{number}))?" r"(?P{op})?\*".format(number=NUMBER, function=COORD_FUNCTION, op=COORD_OP))) APERTURE_STMT = re.compile(r"(?P(G54)|(G55))?D(?P\d+)\*") COMMENT_STMT = re.compile(r"G0?4(?P[^*]*)(\*)?") EOF_STMT = re.compile(r"(?PM[0]?[012])\*") REGION_MODE_STMT = re.compile(r'(?PG3[67])\*') QUAD_MODE_STMT = re.compile(r'(?PG7[45])\*') def __init__(self): self.settings = FileSettings() self.statements = [] self.primitives = [] self.apertures = {} self.macros = {} self.current_region = None self.x = 0 self.y = 0 self.op = "D02" self.aperture = 0 self.interpolation = 'linear' self.direction = 'clockwise' self.image_polarity = 'positive' self.level_polarity = 'dark' self.region_mode = 'off' self.quadrant_mode = 'multi-quadrant' self.step_and_repeat = (1, 1, 0, 0) def parse(self, filename): with open(filename, "rU") as fp: data = fp.read() return self.parse_raw(data, filename) def parse_raw(self, data, filename=None): for stmt in self._parse(self._split_commands(data)): self.evaluate(stmt) self.statements.append(stmt) # Initialize statement units for stmt in self.statements: stmt.units = self.settings.units return GerberFile(self.statements, self.settings, self.primitives, self.apertures.values(), filename) def _split_commands(self, data): """ Split the data into commands. Commands end with * (and also newline to help with some badly formatted files) """ length = len(data) start = 0 in_header = True for cur in range(0, length): val = data[cur] if val == '%' and start == cur: in_header = True continue if val == '\r' or val == '\n': if start != cur: yield data[start:cur] start = cur + 1 elif not in_header and val == '*': yield data[start:cur + 1] start = cur + 1 elif in_header and val == '%': yield data[start:cur + 1] start = cur + 1 in_header = False def dump_json(self): stmts = {"statements": [stmt.__dict__ for stmt in self.statements]} return json.dumps(stmts) def dump_str(self): string = "" for stmt in self.statements: string += str(stmt) + "\n" return string def _parse(self, data): oldline = '' for line in data: line = oldline + line.strip() # skip empty lines if not len(line): continue # deal with multi-line parameters if line.startswith("%") and not line.endswith("%") and not "%" in line[1:]: oldline = line continue did_something = True # make sure we do at least one loop while did_something and len(line) > 0: did_something = False # consume empty data blocks if line[0] == '*': line = line[1:] did_something = True continue # coord (coord, r) = _match_one(self.COORD_STMT, line) if coord: yield CoordStmt.from_dict(coord, self.settings) line = r did_something = True continue # aperture selection (aperture, r) = _match_one(self.APERTURE_STMT, line) if aperture: yield ApertureStmt(**aperture) did_something = True line = r continue # parameter (param, r) = _match_one_from_many(self.PARAM_STMT, line) if param: if param["param"] == "FS": stmt = FSParamStmt.from_dict(param) self.settings.zero_suppression = stmt.zero_suppression self.settings.format = stmt.format self.settings.notation = stmt.notation yield stmt elif param["param"] == "MO": stmt = MOParamStmt.from_dict(param) self.settings.units = stmt.mode yield stmt elif param["param"] == "LP": yield LPParamStmt.from_dict(param) elif param["param"] == "AD": yield ADParamStmt.from_dict(param) elif param["param"] == "AM": stmt = AMParamStmt.from_dict(param) stmt.units = self.settings.units yield stmt elif param["param"] == "OF": yield OFParamStmt.from_dict(param) elif param["param"] == "IN": yield INParamStmt.from_dict(param) elif param["param"] == "LN": yield LNParamStmt.from_dict(param) # deprecated commands AS, IN, IP, IR, MI, OF, SF, LN elif param["param"] == "AS": yield ASParamStmt.from_dict(param) elif param["param"] == "IN": yield INParamStmt.from_dict(param) elif param["param"] == "IP": yield IPParamStmt.from_dict(param) elif param["param"] == "IR": yield IRParamStmt.from_dict(param) elif param["param"] == "MI": yield MIParamStmt.from_dict(param) elif param["param"] == "OF": yield OFParamStmt.from_dict(param) elif param["param"] == "SF": yield SFParamStmt.from_dict(param) elif param["param"] == "LN": yield LNParamStmt.from_dict(param) else: yield UnknownStmt(line) did_something = True line = r continue # Region Mode (mode, r) = _match_one(self.REGION_MODE_STMT, line) if mode: yield RegionModeStmt.from_gerber(line) line = r did_something = True continue # Quadrant Mode (mode, r) = _match_one(self.QUAD_MODE_STMT, line) if mode: yield QuadrantModeStmt.from_gerber(line) line = r did_something = True continue # comment (comment, r) = _match_one(self.COMMENT_STMT, line) if comment: yield CommentStmt(comment["comment"]) did_something = True line = r continue # deprecated codes (deprecated_unit, r) = _match_one(self.DEPRECATED_UNIT, line) if deprecated_unit: stmt = MOParamStmt(param="MO", mo="inch" if "G70" in deprecated_unit["mode"] else "metric") self.settings.units = stmt.mode yield stmt line = r did_something = True continue (deprecated_format, r) = _match_one(self.DEPRECATED_FORMAT, line) if deprecated_format: yield DeprecatedStmt.from_gerber(line) line = r did_something = True continue # eof (eof, r) = _match_one(self.EOF_STMT, line) if eof: yield EofStmt() did_something = True line = r continue if line.find('*') > 0: yield UnknownStmt(line) did_something = True line = "" continue oldline = line def evaluate(self, stmt): """ Evaluate Gerber statement and update image accordingly. This method is called once for each statement in the file as it is parsed. Parameters ---------- statement : Statement Gerber/Excellon statement to evaluate. """ if isinstance(stmt, CoordStmt): self._evaluate_coord(stmt) elif isinstance(stmt, ParamStmt): self._evaluate_param(stmt) elif isinstance(stmt, ApertureStmt): self._evaluate_aperture(stmt) elif isinstance(stmt, (RegionModeStmt, QuadrantModeStmt)): self._evaluate_mode(stmt) elif isinstance(stmt, (CommentStmt, UnknownStmt, DeprecatedStmt, EofStmt)): return else: raise Exception("Invalid statement to evaluate") def _define_aperture(self, d, shape, modifiers): aperture = None if shape == 'C': diameter = modifiers[0][0] if len(modifiers[0]) >= 2: hole_diameter = modifiers[0][1] else: hole_diameter = None aperture = Circle(position=None, diameter=diameter, hole_diameter=hole_diameter, units=self.settings.units) elif shape == 'R': width = modifiers[0][0] height = modifiers[0][1] if len(modifiers[0]) >= 3: hole_diameter = modifiers[0][2] else: hole_diameter = None aperture = Rectangle(position=None, width=width, height=height, hole_diameter=hole_diameter, units=self.settings.units) elif shape == 'O': width = modifiers[0][0] height = modifiers[0][1] if len(modifiers[0]) >= 3: hole_diameter = modifiers[0][2] else: hole_diameter = None aperture = Obround(position=None, width=width, height=height, hole_diameter=hole_diameter, units=self.settings.units) elif shape == 'P': outer_diameter = modifiers[0][0] number_vertices = int(modifiers[0][1]) if len(modifiers[0]) > 2: rotation = modifiers[0][2] else: rotation = 0 if len(modifiers[0]) > 3: hole_diameter = modifiers[0][3] else: hole_diameter = None aperture = Polygon(position=None, sides=number_vertices, radius=outer_diameter/2.0, hole_diameter=hole_diameter, rotation=rotation) else: aperture = self.macros[shape].build(modifiers) aperture.units = self.settings.units self.apertures[d] = aperture def _evaluate_mode(self, stmt): if stmt.type == 'RegionMode': if self.region_mode == 'on' and stmt.mode == 'off': # Sometimes we have regions that have no points. Skip those if self.current_region: self.primitives.append(Region(self.current_region, level_polarity=self.level_polarity, units=self.settings.units)) self.current_region = None self.region_mode = stmt.mode elif stmt.type == 'QuadrantMode': self.quadrant_mode = stmt.mode def _evaluate_param(self, stmt): if stmt.param == "FS": self.settings.zero_suppression = stmt.zero_suppression self.settings.format = stmt.format self.settings.notation = stmt.notation elif stmt.param == "MO": self.settings.units = stmt.mode elif stmt.param == "IP": self.image_polarity = stmt.ip elif stmt.param == "LP": self.level_polarity = stmt.lp elif stmt.param == "AM": self.macros[stmt.name] = stmt elif stmt.param == "AD": self._define_aperture(stmt.d, stmt.shape, stmt.modifiers) def _evaluate_coord(self, stmt): x = self.x if stmt.x is None else stmt.x y = self.y if stmt.y is None else stmt.y if stmt.function in ("G01", "G1"): self.interpolation = 'linear' elif stmt.function in ('G02', 'G2', 'G03', 'G3'): self.interpolation = 'arc' self.direction = ('clockwise' if stmt.function in ('G02', 'G2') else 'counterclockwise') if stmt.only_function: # Sometimes we get a coordinate statement # that only sets the function. If so, don't # try futher otherwise that might draw/flash something return if stmt.op: self.op = stmt.op else: # no implicit op allowed, force here if coord block doesn't have it stmt.op = self.op if self.op == "D01" or self.op == "D1": start = (self.x, self.y) end = (x, y) if self.interpolation == 'linear': if self.region_mode == 'off': self.primitives.append(Line(start, end, self.apertures[self.aperture], level_polarity=self.level_polarity, units=self.settings.units)) else: # from gerber spec revision J3, Section 4.5, page 55: # The segments are not graphics objects in themselves; segments are part of region which is the graphics object. The segments have no thickness. # The current aperture is associated with the region. # This has no graphical effect, but allows all its attributes to # be applied to the region. if self.current_region is None: self.current_region = [Line(start, end, self.apertures.get(self.aperture, Circle((0, 0), 0)), level_polarity=self.level_polarity, units=self.settings.units), ] else: self.current_region.append(Line(start, end, self.apertures.get(self.aperture, Circle((0, 0), 0)), level_polarity=self.level_polarity, units=self.settings.units)) else: i = 0 if stmt.i is None else stmt.i j = 0 if stmt.j is None else stmt.j center = self._find_center(start, end, (i, j)) if self.region_mode == 'off': self.primitives.append(Arc(start, end, center, self.direction, self.apertures[self.aperture], quadrant_mode=self.quadrant_mode, level_polarity=self.level_polarity, units=self.settings.units)) else: if self.current_region is None: self.current_region = [Arc(start, end, center, self.direction, self.apertures.get(self.aperture, Circle((0,0), 0)), quadrant_mode=self.quadrant_mode, level_polarity=self.level_polarity, units=self.settings.units),] else: self.current_region.append(Arc(start, end, center, self.direction, self.apertures.get(self.aperture, Circle((0,0), 0)), quadrant_mode=self.quadrant_mode, level_polarity=self.level_polarity, units=self.settings.units)) elif self.op == "D02" or self.op == "D2": if self.region_mode == "on": # D02 in the middle of a region finishes that region and starts a new one if self.current_region and len(self.current_region) > 1: self.primitives.append(Region(self.current_region, level_polarity=self.level_polarity, units=self.settings.units)) self.current_region = None elif self.op == "D03" or self.op == "D3": primitive = copy.deepcopy(self.apertures[self.aperture]) if primitive is not None: if not isinstance(primitive, AMParamStmt): primitive.position = (x, y) primitive.level_polarity = self.level_polarity primitive.units = self.settings.units self.primitives.append(primitive) else: # Aperture Macro for am_prim in primitive.primitives: renderable = am_prim.to_primitive((x, y), self.level_polarity, self.settings.units) if renderable is not None: self.primitives.append(renderable) self.x, self.y = x, y def _find_center(self, start, end, offsets): """ In single quadrant mode, the offsets are always positive, which means there are 4 possible centers. The correct center is the only one that results in an arc with sweep angle of less than or equal to 90 degrees """ if self.quadrant_mode == 'single-quadrant': # The Gerber spec says single quadrant only has one possible center, and you can detect # based on the angle. But for real files, this seems to work better - there is usually # only one option that makes sense for the center (since the distance should be the same # from start and end). Find the center that makes the most sense sqdist_diff_min = sys.maxint center = None for factors in [(1, 1), (1, -1), (-1, 1), (-1, -1)]: test_center = (start[0] + offsets[0] * factors[0], start[1] + offsets[1] * factors[1]) sqdist_start = sq_distance(start, test_center) sqdist_end = sq_distance(end, test_center) if abs(sqdist_start - sqdist_end) < sqdist_diff_min: center = test_center sqdist_diff_min = abs(sqdist_start - sqdist_end) return center else: return (start[0] + offsets[0], start[1] + offsets[1]) def _evaluate_aperture(self, stmt): self.aperture = stmt.d def _match_one(expr, data): match = expr.match(data) if match is None: return ({}, None) else: return (match.groupdict(), data[match.end(0):]) def _match_one_from_many(exprs, data): for expr in exprs: match = expr.match(data) if match: return (match.groupdict(), data[match.end(0):]) return ({}, None)