From a664f21dc1317be5f13b4c82f4b5788642c6e8ac Mon Sep 17 00:00:00 2001 From: Marius Stanciu Date: Wed, 11 Dec 2019 14:32:01 +0200 Subject: [PATCH] - started work in HPGL2 parser --- README.md | 4 + camlib.py | 2 +- flatcamParsers/ParseHPGL2.py | 1249 ++++++++++++++++++++++++++++++++++ 3 files changed, 1254 insertions(+), 1 deletion(-) create mode 100644 flatcamParsers/ParseHPGL2.py diff --git a/README.md b/README.md index cefa4748..95c1c311 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,10 @@ CAD program, and create G-Code for Isolation routing. ================================================= +11.12.2019 + +- started work in HPGL2 parser + 10.12.2019 - small changes in the Geometry UI diff --git a/camlib.py b/camlib.py index 0e86f66a..0ac35ff4 100644 --- a/camlib.py +++ b/camlib.py @@ -459,7 +459,7 @@ class Geometry(object): defaults = { "units": 'in', - "geo_steps_per_circle": 128 + "geo_steps_per_circle": 64 } def __init__(self, geo_steps_per_circle=None): diff --git a/flatcamParsers/ParseHPGL2.py b/flatcamParsers/ParseHPGL2.py new file mode 100644 index 00000000..fc6e315b --- /dev/null +++ b/flatcamParsers/ParseHPGL2.py @@ -0,0 +1,1249 @@ +# ############################################################ +# FlatCAM: 2D Post-processing for Manufacturing # +# http://flatcam.org # +# File Author: Marius Adrina Stanciu (c) # +# Date: 12/11/2019 # +# MIT Licence # +# ############################################################ + +from camlib import Geometry, arc, arc_angle +import FlatCAMApp + +import numpy as np +import re +import logging +import traceback +from copy import deepcopy +import sys + +from shapely.ops import cascaded_union, unary_union +from shapely.geometry import Polygon, MultiPolygon, LineString, Point +import shapely.affinity as affinity +from shapely.geometry import box as shply_box + +import FlatCAMTranslation as fcTranslate +import gettext +import builtins + +if '_' not in builtins.__dict__: + _ = gettext.gettext + +log = logging.getLogger('base') + + +class HPGL2(Geometry): + """ + HPGL2 parsing. + """ + + defaults = { + "steps_per_circle": 64, + "use_buffer_for_union": True + } + + def __init__(self, steps_per_circle=None): + """ + The constructor takes no parameters. + + :return: Geometry object + :rtype: Geometry + """ + + # How to approximate a circle with lines. + self.steps_per_circle = steps_per_circle if steps_per_circle is not None else \ + int(self.app.defaults["geometry_circle_steps"]) + + self.decimals = self.app.decimals + + # Initialize parent + Geometry.__init__(self, geo_steps_per_circle=self.steps_per_circle) + + # Number format + self.coord_mm_factor = 0.040 + + # store the file units here: + self.units = self.app.defaults['gerber_def_units'] + + # will store the geometry's as solids + self.solid_geometry = None + + # will store the geometry's as paths + self.follow_geometry = [] + + self.source_file = '' + + # Attributes to be included in serialization + # Always append to it because it carries contents + # from Geometry. + self.ser_attrs += ['solid_geometry', 'follow_geometry', 'source_file'] + + # ### Parser patterns ## ## + + # comment + self.comment_re = re.compile(r"^CO\s*[\"']([a-zA-Z0-9\s]*)[\"'];?$") + # absolute move to x, y + self.abs_move_re = re.compile(r"^PA\s*(-?\d+\.\d+?),?\s*(-?\d+\.\d+?)*;?$") + # relative move to x, y + self.rel_move_re = re.compile(r"^PR\s*(-?\d+\.\d+?),?\s*(-?\d+\.\d+?)*;?$") + # pen position + self.pen_re = re.compile(r"^(P[U|D]);?$") + # Initialize + self.mode_re = re.compile(r'^(IN);?$') + # select pen + self.sp_re = re.compile(r'SP(\d);?$') + + + self.fmt_re_alt = re.compile(r'%FS([LTD])?([AI])X(\d)(\d)Y\d\d\*MO(IN|MM)\*%$') + self.fmt_re_orcad = re.compile(r'(G\d+)*\**%FS([LTD])?([AI]).*X(\d)(\d)Y\d\d\*%$') + + # G01... - Linear interpolation plus flashes with coordinates + # Operation code (D0x) missing is deprecated... oh well I will support it. + self.lin_re = re.compile(r'^(?:G0?(1))?(?=.*X([+-]?\d+))?(?=.*Y([+-]?\d+))?[XY][^DIJ]*(?:D0?([123]))?\*$') + + # G02/3... - Circular interpolation with coordinates + # 2-clockwise, 3-counterclockwise + # Operation code (D0x) missing is deprecated... oh well I will support it. + # Optional start with G02 or G03, optional end with D01 or D02 with + # optional coordinates but at least one in any order. + self.circ_re = re.compile(r'^(?:G0?([23]))?(?=.*X([+-]?\d+))?(?=.*Y([+-]?\d+))' + + '?(?=.*I([+-]?\d+))?(?=.*J([+-]?\d+))?[XYIJ][^D]*(?:D0([12]))?\*$') + + # G01/2/3 Occurring without coordinates + self.interp_re = re.compile(r'^(?:G0?([123]))\*') + + # Single G74 or multi G75 quadrant for circular interpolation + self.quad_re = re.compile(r'^G7([45]).*\*$') + + # Absolute/Relative G90/1 (OBSOLETE) + self.absrel_re = re.compile(r'^G9([01])\*$') + + # flag to store if a conversion was done. It is needed because multiple units declarations can be found + # in a Gerber file (normal or obsolete ones) + self.conversion_done = False + + self.use_buffer_for_union = self.app.defaults["gerber_use_buffer_for_union"] + + def parse_file(self, filename, follow=False): + """ + Calls Gerber.parse_lines() with generator of lines + read from the given file. Will split the lines if multiple + statements are found in a single original line. + + The following line is split into two:: + + G54D11*G36* + + First is ``G54D11*`` and seconds is ``G36*``. + + :param filename: Gerber file to parse. + :type filename: str + :param follow: If true, will not create polygons, just lines + following the gerber path. + :type follow: bool + :return: None + """ + + with open(filename, 'r') as gfile: + self.parse_lines([line.rstrip('\n') for line in gfile]) + + def parse_lines(self, glines): + """ + Main Gerber parser. Reads Gerber and populates ``self.paths``, ``self.apertures``, + ``self.flashes``, ``self.regions`` and ``self.units``. + + :param glines: Gerber code as list of strings, each element being + one line of the source file. + :type glines: list + :return: None + :rtype: None + """ + + # Coordinates of the current path, each is [x, y] + path = [] + + # this is for temporary storage of solid geometry until it is added to poly_buffer + geo_s = None + + # this is for temporary storage of follow geometry until it is added to follow_buffer + geo_f = None + + # Polygons are stored here until there is a change in polarity. + # Only then they are combined via cascaded_union and added or + # subtracted from solid_geometry. This is ~100 times faster than + # applying a union for every new polygon. + poly_buffer = [] + + # store here the follow geometry + follow_buffer = [] + + last_path_aperture = None + current_aperture = None + + # 1,2 or 3 from "G01", "G02" or "G03" + current_interpolation_mode = None + + # 1 or 2 from "D01" or "D02" + # Note this is to support deprecated Gerber not putting + # an operation code at the end of every coordinate line. + current_operation_code = None + + # Current coordinates + current_x = None + current_y = None + previous_x = None + previous_y = None + + current_d = None + + # Absolute or Relative/Incremental coordinates + # Not implemented + absolute = True + + # How to interpret circular interpolation: SINGLE or MULTI + quadrant_mode = None + + # Indicates we are parsing an aperture macro + current_macro = None + + # Indicates the current polarity: D-Dark, C-Clear + current_polarity = 'D' + + # If a region is being defined + making_region = False + + # ### Parsing starts here ## ## + line_num = 0 + gline = "" + + s_tol = float(self.app.defaults["gerber_simp_tolerance"]) + + self.app.inform.emit('%s %d %s.' % (_("Gerber processing. Parsing"), len(glines), _("lines"))) + try: + for gline in glines: + if self.app.abort_flag: + # graceful abort requested by the user + raise FlatCAMApp.GracefulException + + line_num += 1 + self.source_file += gline + '\n' + + # Cleanup # + gline = gline.strip(' \r\n') + # log.debug("Line=%3s %s" % (line_num, gline)) + + # ################### + # Ignored lines ##### + # Comments ##### + # ################### + match = self.comm_re.search(gline) + if match: + continue + + # ## Mode (IN/MM) + # Example: %MOIN*% + match = self.mode_re.search(gline) + if match: + self.units = match.group(1) + log.debug("Gerber units found = %s" % self.units) + # Changed for issue #80 + # self.convert_units(match.group(1)) + self.conversion_done = True + continue + + # ############################################################# ## + # Absolute/relative coordinates G90/1 OBSOLETE ######## ## + # ##################################################### ## + match = self.absrel_re.search(gline) + if match: + absolute = {'0': "Absolute", '1': "Relative"}[match.group(1)] + log.warning("Gerber obsolete coordinates type found = %s (Absolute or Relative) " % absolute) + continue + + # ## G01 - Linear interpolation plus flashes + # Operation code (D0x) missing is deprecated... oh well I will support it. + # REGEX: r'^(?:G0?(1))?(?:X(-?\d+))?(?:Y(-?\d+))?(?:D0([123]))?\*$' + match = self.lin_re.search(gline) + if match: + # Parse coordinates + if match.group(2) is not None: + linear_x = parse_number(match.group(2), + self.int_digits, self.frac_digits, self.gerber_zeros) + current_x = linear_x + else: + linear_x = current_x + if match.group(3) is not None: + linear_y = parse_number(match.group(3), + self.int_digits, self.frac_digits, self.gerber_zeros) + current_y = linear_y + else: + linear_y = current_y + + # Parse operation code + if match.group(4) is not None: + current_operation_code = int(match.group(4)) + + # Pen down: add segment + if current_operation_code == 1: + # if linear_x or linear_y are None, ignore those + if current_x is not None and current_y is not None: + # only add the point if it's a new one otherwise skip it (harder to process) + if path[-1] != [current_x, current_y]: + path.append([current_x, current_y]) + + if making_region is False: + # if the aperture is rectangle then add a rectangular shape having as parameters the + # coordinates of the start and end point and also the width and height + # of the 'R' aperture + try: + if self.apertures[current_aperture]["type"] == 'R': + width = self.apertures[current_aperture]['width'] + height = self.apertures[current_aperture]['height'] + minx = min(path[0][0], path[1][0]) - width / 2 + maxx = max(path[0][0], path[1][0]) + width / 2 + miny = min(path[0][1], path[1][1]) - height / 2 + maxy = max(path[0][1], path[1][1]) + height / 2 + log.debug("Coords: %s - %s - %s - %s" % (minx, miny, maxx, maxy)) + + geo_dict = dict() + geo_f = Point([current_x, current_y]) + follow_buffer.append(geo_f) + geo_dict['follow'] = geo_f + + geo_s = shply_box(minx, miny, maxx, maxy) + if self.app.defaults['gerber_simplification']: + poly_buffer.append(geo_s.simplify(s_tol)) + else: + poly_buffer.append(geo_s) + + if self.is_lpc is True: + geo_dict['clear'] = geo_s + else: + geo_dict['solid'] = geo_s + + if current_aperture not in self.apertures: + self.apertures[current_aperture] = dict() + if 'geometry' not in self.apertures[current_aperture]: + self.apertures[current_aperture]['geometry'] = [] + self.apertures[current_aperture]['geometry'].append(deepcopy(geo_dict)) + except Exception as e: + pass + last_path_aperture = current_aperture + # we do this for the case that a region is done without having defined any aperture + if last_path_aperture is None: + if '0' not in self.apertures: + self.apertures['0'] = {} + self.apertures['0']['type'] = 'REG' + self.apertures['0']['size'] = 0.0 + self.apertures['0']['geometry'] = [] + last_path_aperture = '0' + else: + self.app.inform.emit('[WARNING] %s: %s' % + (_("Coordinates missing, line ignored"), str(gline))) + self.app.inform.emit('[WARNING_NOTCL] %s' % + _("GERBER file might be CORRUPT. Check the file !!!")) + elif current_operation_code == 2: + if len(path) > 1: + geo_s = None + + geo_dict = dict() + # --- BUFFERED --- + # this treats the case when we are storing geometry as paths only + if making_region: + # we do this for the case that a region is done without having defined any aperture + if last_path_aperture is None: + if '0' not in self.apertures: + self.apertures['0'] = {} + self.apertures['0']['type'] = 'REG' + self.apertures['0']['size'] = 0.0 + self.apertures['0']['geometry'] = [] + last_path_aperture = '0' + geo_f = Polygon() + else: + geo_f = LineString(path) + + try: + if self.apertures[last_path_aperture]["type"] != 'R': + if not geo_f.is_empty: + follow_buffer.append(geo_f) + geo_dict['follow'] = geo_f + except Exception as e: + log.debug("camlib.Gerber.parse_lines() --> %s" % str(e)) + if not geo_f.is_empty: + follow_buffer.append(geo_f) + geo_dict['follow'] = geo_f + + # this treats the case when we are storing geometry as solids + if making_region: + # we do this for the case that a region is done without having defined any aperture + if last_path_aperture is None: + if '0' not in self.apertures: + self.apertures['0'] = {} + self.apertures['0']['type'] = 'REG' + self.apertures['0']['size'] = 0.0 + self.apertures['0']['geometry'] = [] + last_path_aperture = '0' + + try: + geo_s = Polygon(path) + except ValueError: + log.warning("Problem %s %s" % (gline, line_num)) + self.app.inform.emit('[ERROR] %s: %s' % + (_("Region does not have enough points. " + "File will be processed but there are parser errors. " + "Line number"), str(line_num))) + else: + if last_path_aperture is None: + log.warning("No aperture defined for curent path. (%d)" % line_num) + width = self.apertures[last_path_aperture]["size"] # TODO: WARNING this should fail! + geo_s = LineString(path).buffer(width / 1.999, int(self.steps_per_circle / 4)) + + try: + if self.apertures[last_path_aperture]["type"] != 'R': + if not geo_s.is_empty: + if self.app.defaults['gerber_simplification']: + poly_buffer.append(geo_s.simplify(s_tol)) + else: + poly_buffer.append(geo_s) + + if self.is_lpc is True: + geo_dict['clear'] = geo_s + else: + geo_dict['solid'] = geo_s + except Exception as e: + log.debug("camlib.Gerber.parse_lines() --> %s" % str(e)) + if self.app.defaults['gerber_simplification']: + poly_buffer.append(geo_s.simplify(s_tol)) + else: + poly_buffer.append(geo_s) + + if self.is_lpc is True: + geo_dict['clear'] = geo_s + else: + geo_dict['solid'] = geo_s + + if last_path_aperture not in self.apertures: + self.apertures[last_path_aperture] = dict() + if 'geometry' not in self.apertures[last_path_aperture]: + self.apertures[last_path_aperture]['geometry'] = [] + self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict)) + + # if linear_x or linear_y are None, ignore those + if linear_x is not None and linear_y is not None: + path = [[linear_x, linear_y]] # Start new path + else: + self.app.inform.emit('[WARNING] %s: %s' % + (_("Coordinates missing, line ignored"), str(gline))) + self.app.inform.emit('[WARNING_NOTCL] %s' % + _("GERBER file might be CORRUPT. Check the file !!!")) + + # maybe those lines are not exactly needed but it is easier to read the program as those coordinates + # are used in case that circular interpolation is encountered within the Gerber file + current_x = linear_x + current_y = linear_y + + # log.debug("Line_number=%3s X=%s Y=%s (%s)" % (line_num, linear_x, linear_y, gline)) + continue + + # ## G02/3 - Circular interpolation + # 2-clockwise, 3-counterclockwise + # Ex. format: G03 X0 Y50 I-50 J0 where the X, Y coords are the coords of the End Point + match = self.circ_re.search(gline) + if match: + arcdir = [None, None, "cw", "ccw"] + + mode, circular_x, circular_y, i, j, d = match.groups() + + try: + circular_x = parse_number(circular_x, + self.int_digits, self.frac_digits, self.gerber_zeros) + except Exception as e: + circular_x = current_x + + try: + circular_y = parse_number(circular_y, + self.int_digits, self.frac_digits, self.gerber_zeros) + except Exception as e: + circular_y = current_y + + # According to Gerber specification i and j are not modal, which means that when i or j are missing, + # they are to be interpreted as being zero + try: + i = parse_number(i, self.int_digits, self.frac_digits, self.gerber_zeros) + except Exception as e: + i = 0 + + try: + j = parse_number(j, self.int_digits, self.frac_digits, self.gerber_zeros) + except Exception as e: + j = 0 + + if quadrant_mode is None: + log.error("Found arc without preceding quadrant specification G74 or G75. (%d)" % line_num) + log.error(gline) + continue + + if mode is None and current_interpolation_mode not in [2, 3]: + log.error("Found arc without circular interpolation mode defined. (%d)" % line_num) + log.error(gline) + continue + elif mode is not None: + current_interpolation_mode = int(mode) + + # Set operation code if provided + if d is not None: + current_operation_code = int(d) + + # Nothing created! Pen Up. + if current_operation_code == 2: + log.warning("Arc with D2. (%d)" % line_num) + if len(path) > 1: + geo_dict = dict() + + if last_path_aperture is None: + log.warning("No aperture defined for curent path. (%d)" % line_num) + + # --- BUFFERED --- + width = self.apertures[last_path_aperture]["size"] + + # this treats the case when we are storing geometry as paths + geo_f = LineString(path) + if not geo_f.is_empty: + follow_buffer.append(geo_f) + geo_dict['follow'] = geo_f + + # this treats the case when we are storing geometry as solids + buffered = LineString(path).buffer(width / 1.999, int(self.steps_per_circle)) + if not buffered.is_empty: + if self.app.defaults['gerber_simplification']: + poly_buffer.append(buffered.simplify(s_tol)) + else: + poly_buffer.append(buffered) + + if self.is_lpc is True: + geo_dict['clear'] = buffered + else: + geo_dict['solid'] = buffered + + if last_path_aperture not in self.apertures: + self.apertures[last_path_aperture] = dict() + if 'geometry' not in self.apertures[last_path_aperture]: + self.apertures[last_path_aperture]['geometry'] = [] + self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict)) + + current_x = circular_x + current_y = circular_y + path = [[current_x, current_y]] # Start new path + continue + + # Flash should not happen here + if current_operation_code == 3: + log.error("Trying to flash within arc. (%d)" % line_num) + continue + + if quadrant_mode == 'MULTI': + center = [i + current_x, j + current_y] + radius = np.sqrt(i ** 2 + j ** 2) + start = np.arctan2(-j, -i) # Start angle + # Numerical errors might prevent start == stop therefore + # we check ahead of time. This should result in a + # 360 degree arc. + if current_x == circular_x and current_y == circular_y: + stop = start + else: + stop = np.arctan2(-center[1] + circular_y, -center[0] + circular_x) # Stop angle + + this_arc = arc(center, radius, start, stop, + arcdir[current_interpolation_mode], + self.steps_per_circle) + + # The last point in the computed arc can have + # numerical errors. The exact final point is the + # specified (x, y). Replace. + this_arc[-1] = (circular_x, circular_y) + + # Last point in path is current point + # current_x = this_arc[-1][0] + # current_y = this_arc[-1][1] + current_x, current_y = circular_x, circular_y + + # Append + path += this_arc + last_path_aperture = current_aperture + + continue + + if quadrant_mode == 'SINGLE': + + center_candidates = [ + [i + current_x, j + current_y], + [-i + current_x, j + current_y], + [i + current_x, -j + current_y], + [-i + current_x, -j + current_y] + ] + + valid = False + log.debug("I: %f J: %f" % (i, j)) + for center in center_candidates: + radius = np.sqrt(i ** 2 + j ** 2) + + # Make sure radius to start is the same as radius to end. + radius2 = np.sqrt((center[0] - circular_x) ** 2 + (center[1] - circular_y) ** 2) + if radius2 < radius * 0.95 or radius2 > radius * 1.05: + continue # Not a valid center. + + # Correct i and j and continue as with multi-quadrant. + i = center[0] - current_x + j = center[1] - current_y + + start = np.arctan2(-j, -i) # Start angle + stop = np.arctan2(-center[1] + circular_y, -center[0] + circular_x) # Stop angle + angle = abs(arc_angle(start, stop, arcdir[current_interpolation_mode])) + log.debug("ARC START: %f, %f CENTER: %f, %f STOP: %f, %f" % + (current_x, current_y, center[0], center[1], circular_x, circular_y)) + log.debug("START Ang: %f, STOP Ang: %f, DIR: %s, ABS: %.12f <= %.12f: %s" % + (start * 180 / np.pi, stop * 180 / np.pi, arcdir[current_interpolation_mode], + angle * 180 / np.pi, np.pi / 2 * 180 / np.pi, angle <= (np.pi + 1e-6) / 2)) + + if angle <= (np.pi + 1e-6) / 2: + log.debug("########## ACCEPTING ARC ############") + this_arc = arc(center, radius, start, stop, + arcdir[current_interpolation_mode], + self.steps_per_circle) + + # Replace with exact values + this_arc[-1] = (circular_x, circular_y) + + # current_x = this_arc[-1][0] + # current_y = this_arc[-1][1] + current_x, current_y = circular_x, circular_y + + path += this_arc + last_path_aperture = current_aperture + valid = True + break + + if valid: + continue + else: + log.warning("Invalid arc in line %d." % line_num) + + + # ## Line did not match any pattern. Warn user. + log.warning("Line ignored (%d): %s" % (line_num, gline)) + + # --- Apply buffer --- + # this treats the case when we are storing geometry as paths + self.follow_geometry = follow_buffer + + # this treats the case when we are storing geometry as solids + + if len(poly_buffer) == 0 and len(self.solid_geometry) == 0: + log.error("Object is not Gerber file or empty. Aborting Object creation.") + return 'fail' + + log.warning("Joining %d polygons." % len(poly_buffer)) + self.app.inform.emit('%s: %d.' % (_("Gerber processing. Joining polygons"), len(poly_buffer))) + + if self.use_buffer_for_union: + log.debug("Union by buffer...") + + new_poly = MultiPolygon(poly_buffer) + if self.app.defaults["gerber_buffering"] == 'full': + new_poly = new_poly.buffer(0.00000001) + new_poly = new_poly.buffer(-0.00000001) + log.warning("Union(buffer) done.") + else: + log.debug("Union by union()...") + new_poly = cascaded_union(poly_buffer) + new_poly = new_poly.buffer(0, int(self.steps_per_circle / 4)) + log.warning("Union done.") + + if current_polarity == 'D': + self.app.inform.emit('%s' % _("Gerber processing. Applying Gerber polarity.")) + if new_poly.is_valid: + self.solid_geometry = self.solid_geometry.union(new_poly) + else: + # I do this so whenever the parsed geometry of the file is not valid (intersections) it is still + # loaded. Instead of applying a union I add to a list of polygons. + final_poly = [] + try: + for poly in new_poly: + final_poly.append(poly) + except TypeError: + final_poly.append(new_poly) + + try: + for poly in self.solid_geometry: + final_poly.append(poly) + except TypeError: + final_poly.append(self.solid_geometry) + + self.solid_geometry = final_poly + + else: + self.solid_geometry = self.solid_geometry.difference(new_poly) + + # init this for the following operations + self.conversion_done = False + except Exception as err: + ex_type, ex, tb = sys.exc_info() + traceback.print_tb(tb) + # print traceback.format_exc() + + log.error("Gerber PARSING FAILED. Line %d: %s" % (line_num, gline)) + + loc = '%s #%d %s: %s\n' % (_("Gerber Line"), line_num, _("Gerber Line Content"), gline) + repr(err) + self.app.inform.emit('[ERROR] %s\n%s:' % + (_("Gerber Parser ERROR"), loc)) + + def create_geometry(self): + """ + :rtype : None + :return: None + """ + pass + + def get_bounding_box(self, margin=0.0, rounded=False): + """ + Creates and returns a rectangular polygon bounding at a distance of + margin from the object's ``solid_geometry``. If margin > 0, the polygon + can optionally have rounded corners of radius equal to margin. + + :param margin: Distance to enlarge the rectangular bounding + box in both positive and negative, x and y axes. + :type margin: float + :param rounded: Wether or not to have rounded corners. + :type rounded: bool + :return: The bounding box. + :rtype: Shapely.Polygon + """ + + bbox = self.solid_geometry.envelope.buffer(margin) + if not rounded: + bbox = bbox.envelope + return bbox + + def bounds(self): + """ + Returns coordinates of rectangular bounds + of Gerber geometry: (xmin, ymin, xmax, ymax). + """ + # fixed issue of getting bounds only for one level lists of objects + # now it can get bounds for nested lists of objects + + log.debug("parseGerber.Gerber.bounds()") + + if self.solid_geometry is None: + log.debug("solid_geometry is None") + return 0, 0, 0, 0 + + def bounds_rec(obj): + if type(obj) is list and type(obj) is not MultiPolygon: + minx = np.Inf + miny = np.Inf + maxx = -np.Inf + maxy = -np.Inf + + for k in obj: + if type(k) is dict: + for key in k: + minx_, miny_, maxx_, maxy_ = bounds_rec(k[key]) + minx = min(minx, minx_) + miny = min(miny, miny_) + maxx = max(maxx, maxx_) + maxy = max(maxy, maxy_) + else: + if not k.is_empty: + try: + minx_, miny_, maxx_, maxy_ = bounds_rec(k) + except Exception as e: + log.debug("camlib.Gerber.bounds() --> %s" % str(e)) + return + + minx = min(minx, minx_) + miny = min(miny, miny_) + maxx = max(maxx, maxx_) + maxy = max(maxy, maxy_) + return minx, miny, maxx, maxy + else: + # it's a Shapely object, return it's bounds + return obj.bounds + + bounds_coords = bounds_rec(self.solid_geometry) + return bounds_coords + + def convert_units(self, obj_units): + """ + Converts the units of the object to ``units`` by scaling all + the geometry appropriately. This call ``scale()``. Don't call + it again in descendants. + + :param obj_units: "IN" or "MM" + :type obj_units: str + :return: Scaling factor resulting from unit change. + :rtype: float + """ + + if obj_units.upper() == self.units.upper(): + log.debug("parseGerber.Gerber.convert_units() --> Factor: 1") + return 1.0 + + if obj_units.upper() == "MM": + factor = 25.4 + log.debug("parseGerber.Gerber.convert_units() --> Factor: 25.4") + elif obj_units.upper() == "IN": + factor = 1 / 25.4 + log.debug("parseGerber.Gerber.convert_units() --> Factor: %s" % str(1 / 25.4)) + else: + log.error("Unsupported units: %s" % str(obj_units)) + log.debug("parseGerber.Gerber.convert_units() --> Factor: 1") + return 1.0 + + self.units = obj_units + self.file_units_factor = factor + self.scale(factor, factor) + return factor + + def scale(self, xfactor, yfactor=None, point=None): + """ + Scales the objects' geometry on the XY plane by a given factor. + These are: + + * ``buffered_paths`` + * ``flash_geometry`` + * ``solid_geometry`` + * ``regions`` + + NOTE: + Does not modify the data used to create these elements. If these + are recreated, the scaling will be lost. This behavior was modified + because of the complexity reached in this class. + + :param xfactor: Number by which to scale on X axis. + :type xfactor: float + :param yfactor: Number by which to scale on Y axis. + :type yfactor: float + :param point: reference point for scaling operation + :rtype : None + """ + log.debug("parseGerber.Gerber.scale()") + + try: + xfactor = float(xfactor) + except Exception: + self.app.inform.emit('[ERROR_NOTCL] %s' % + _("Scale factor has to be a number: integer or float.")) + return + + if yfactor is None: + yfactor = xfactor + else: + try: + yfactor = float(yfactor) + except Exception: + self.app.inform.emit('[ERROR_NOTCL] %s' % + _("Scale factor has to be a number: integer or float.")) + return + + if xfactor == 0 and yfactor == 0: + return + + if point is None: + px = 0 + py = 0 + else: + px, py = point + + # variables to display the percentage of work done + self.geo_len = 0 + try: + self.geo_len = len(self.solid_geometry) + except TypeError: + self.geo_len = 1 + + self.old_disp_number = 0 + self.el_count = 0 + + def scale_geom(obj): + if type(obj) is list: + new_obj = [] + for g in obj: + new_obj.append(scale_geom(g)) + return new_obj + else: + try: + self.el_count += 1 + disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 99])) + if self.old_disp_number < disp_number <= 100: + self.app.proc_container.update_view_text(' %d%%' % disp_number) + self.old_disp_number = disp_number + + return affinity.scale(obj, xfactor, yfactor, origin=(px, py)) + except AttributeError: + return obj + + self.solid_geometry = scale_geom(self.solid_geometry) + self.follow_geometry = scale_geom(self.follow_geometry) + + # we need to scale the geometry stored in the Gerber apertures, too + try: + for apid in self.apertures: + new_geometry = list() + if 'geometry' in self.apertures[apid]: + for geo_el in self.apertures[apid]['geometry']: + new_geo_el = dict() + if 'solid' in geo_el: + new_geo_el['solid'] = scale_geom(geo_el['solid']) + if 'follow' in geo_el: + new_geo_el['follow'] = scale_geom(geo_el['follow']) + if 'clear' in geo_el: + new_geo_el['clear'] = scale_geom(geo_el['clear']) + new_geometry.append(new_geo_el) + + self.apertures[apid]['geometry'] = deepcopy(new_geometry) + + try: + if str(self.apertures[apid]['type']) == 'R' or str(self.apertures[apid]['type']) == 'O': + self.apertures[apid]['width'] *= xfactor + self.apertures[apid]['height'] *= xfactor + elif str(self.apertures[apid]['type']) == 'P': + self.apertures[apid]['diam'] *= xfactor + self.apertures[apid]['nVertices'] *= xfactor + except KeyError: + pass + + try: + if self.apertures[apid]['size'] is not None: + self.apertures[apid]['size'] = float(self.apertures[apid]['size'] * xfactor) + except KeyError: + pass + + except Exception as e: + log.debug('camlib.Gerber.scale() Exception --> %s' % str(e)) + return 'fail' + + self.app.inform.emit('[success] %s' % _("Gerber Scale done.")) + self.app.proc_container.new_text = '' + + # ## solid_geometry ??? + # It's a cascaded union of objects. + # self.solid_geometry = affinity.scale(self.solid_geometry, factor, + # factor, origin=(0, 0)) + + # # Now buffered_paths, flash_geometry and solid_geometry + # self.create_geometry() + + def offset(self, vect): + """ + Offsets the objects' geometry on the XY plane by a given vector. + These are: + + * ``buffered_paths`` + * ``flash_geometry`` + * ``solid_geometry`` + * ``regions`` + + NOTE: + Does not modify the data used to create these elements. If these + are recreated, the scaling will be lost. This behavior was modified + because of the complexity reached in this class. + + :param vect: (x, y) offset vector. + :type vect: tuple + :return: None + """ + log.debug("parseGerber.Gerber.offset()") + + try: + dx, dy = vect + except TypeError: + self.app.inform.emit('[ERROR_NOTCL] %s' % + _("An (x,y) pair of values are needed. " + "Probable you entered only one value in the Offset field.")) + return + + if dx == 0 and dy == 0: + return + + # variables to display the percentage of work done + self.geo_len = 0 + try: + for __ in self.solid_geometry: + self.geo_len += 1 + except TypeError: + self.geo_len = 1 + + self.old_disp_number = 0 + self.el_count = 0 + + def offset_geom(obj): + if type(obj) is list: + new_obj = [] + for g in obj: + new_obj.append(offset_geom(g)) + return new_obj + else: + try: + self.el_count += 1 + disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 99])) + if self.old_disp_number < disp_number <= 100: + self.app.proc_container.update_view_text(' %d%%' % disp_number) + self.old_disp_number = disp_number + + return affinity.translate(obj, xoff=dx, yoff=dy) + except AttributeError: + return obj + + # ## Solid geometry + self.solid_geometry = offset_geom(self.solid_geometry) + self.follow_geometry = offset_geom(self.follow_geometry) + + # we need to offset the geometry stored in the Gerber apertures, too + try: + for apid in self.apertures: + if 'geometry' in self.apertures[apid]: + for geo_el in self.apertures[apid]['geometry']: + if 'solid' in geo_el: + geo_el['solid'] = offset_geom(geo_el['solid']) + if 'follow' in geo_el: + geo_el['follow'] = offset_geom(geo_el['follow']) + if 'clear' in geo_el: + geo_el['clear'] = offset_geom(geo_el['clear']) + + except Exception as e: + log.debug('camlib.Gerber.offset() Exception --> %s' % str(e)) + return 'fail' + + self.app.inform.emit('[success] %s' % + _("Gerber Offset done.")) + self.app.proc_container.new_text = '' + + def mirror(self, axis, point): + """ + Mirrors the object around a specified axis passing through + the given point. What is affected: + + * ``buffered_paths`` + * ``flash_geometry`` + * ``solid_geometry`` + * ``regions`` + + NOTE: + Does not modify the data used to create these elements. If these + are recreated, the scaling will be lost. This behavior was modified + because of the complexity reached in this class. + + :param axis: "X" or "Y" indicates around which axis to mirror. + :type axis: str + :param point: [x, y] point belonging to the mirror axis. + :type point: list + :return: None + """ + log.debug("parseGerber.Gerber.mirror()") + + px, py = point + xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis] + + # variables to display the percentage of work done + self.geo_len = 0 + try: + for __ in self.solid_geometry: + self.geo_len += 1 + except TypeError: + self.geo_len = 1 + + self.old_disp_number = 0 + self.el_count = 0 + + def mirror_geom(obj): + if type(obj) is list: + new_obj = [] + for g in obj: + new_obj.append(mirror_geom(g)) + return new_obj + else: + try: + self.el_count += 1 + disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 99])) + if self.old_disp_number < disp_number <= 100: + self.app.proc_container.update_view_text(' %d%%' % disp_number) + self.old_disp_number = disp_number + + return affinity.scale(obj, xscale, yscale, origin=(px, py)) + except AttributeError: + return obj + + self.solid_geometry = mirror_geom(self.solid_geometry) + self.follow_geometry = mirror_geom(self.follow_geometry) + + # we need to mirror the geometry stored in the Gerber apertures, too + try: + for apid in self.apertures: + if 'geometry' in self.apertures[apid]: + for geo_el in self.apertures[apid]['geometry']: + if 'solid' in geo_el: + geo_el['solid'] = mirror_geom(geo_el['solid']) + if 'follow' in geo_el: + geo_el['follow'] = mirror_geom(geo_el['follow']) + if 'clear' in geo_el: + geo_el['clear'] = mirror_geom(geo_el['clear']) + except Exception as e: + log.debug('camlib.Gerber.mirror() Exception --> %s' % str(e)) + return 'fail' + + self.app.inform.emit('[success] %s' % + _("Gerber Mirror done.")) + self.app.proc_container.new_text = '' + + def skew(self, angle_x, angle_y, point): + """ + Shear/Skew the geometries of an object by angles along x and y dimensions. + + Parameters + ---------- + angle_x, angle_y : float, float + The shear angle(s) for the x and y axes respectively. These can be + specified in either degrees (default) or radians by setting + use_radians=True. + + See shapely manual for more information: + http://toblerity.org/shapely/manual.html#affine-transformations + :param angle_x: the angle on X axis for skewing + :param angle_y: the angle on Y axis for skewing + :param point: reference point for skewing operation + :return None + """ + log.debug("parseGerber.Gerber.skew()") + + px, py = point + + if angle_x == 0 and angle_y == 0: + return + + # variables to display the percentage of work done + self.geo_len = 0 + try: + self.geo_len = len(self.solid_geometry) + except TypeError: + self.geo_len = 1 + + self.old_disp_number = 0 + self.el_count = 0 + + def skew_geom(obj): + if type(obj) is list: + new_obj = [] + for g in obj: + new_obj.append(skew_geom(g)) + return new_obj + else: + try: + self.el_count += 1 + disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100])) + if self.old_disp_number < disp_number <= 100: + self.app.proc_container.update_view_text(' %d%%' % disp_number) + self.old_disp_number = disp_number + + return affinity.skew(obj, angle_x, angle_y, origin=(px, py)) + except AttributeError: + return obj + + self.solid_geometry = skew_geom(self.solid_geometry) + self.follow_geometry = skew_geom(self.follow_geometry) + + # we need to skew the geometry stored in the Gerber apertures, too + try: + for apid in self.apertures: + if 'geometry' in self.apertures[apid]: + for geo_el in self.apertures[apid]['geometry']: + if 'solid' in geo_el: + geo_el['solid'] = skew_geom(geo_el['solid']) + if 'follow' in geo_el: + geo_el['follow'] = skew_geom(geo_el['follow']) + if 'clear' in geo_el: + geo_el['clear'] = skew_geom(geo_el['clear']) + except Exception as e: + log.debug('camlib.Gerber.skew() Exception --> %s' % str(e)) + return 'fail' + + self.app.inform.emit('[success] %s' % _("Gerber Skew done.")) + self.app.proc_container.new_text = '' + + def rotate(self, angle, point): + """ + Rotate an object by a given angle around given coords (point) + :param angle: + :param point: + :return: + """ + log.debug("parseGerber.Gerber.rotate()") + + px, py = point + + if angle == 0: + return + + # variables to display the percentage of work done + self.geo_len = 0 + try: + for __ in self.solid_geometry: + self.geo_len += 1 + except TypeError: + self.geo_len = 1 + + self.old_disp_number = 0 + self.el_count = 0 + + def rotate_geom(obj): + if type(obj) is list: + new_obj = [] + for g in obj: + new_obj.append(rotate_geom(g)) + return new_obj + else: + try: + self.el_count += 1 + disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100])) + if self.old_disp_number < disp_number <= 100: + self.app.proc_container.update_view_text(' %d%%' % disp_number) + self.old_disp_number = disp_number + + return affinity.rotate(obj, angle, origin=(px, py)) + except AttributeError: + return obj + + self.solid_geometry = rotate_geom(self.solid_geometry) + self.follow_geometry = rotate_geom(self.follow_geometry) + + # we need to rotate the geometry stored in the Gerber apertures, too + try: + for apid in self.apertures: + if 'geometry' in self.apertures[apid]: + for geo_el in self.apertures[apid]['geometry']: + if 'solid' in geo_el: + geo_el['solid'] = rotate_geom(geo_el['solid']) + if 'follow' in geo_el: + geo_el['follow'] = rotate_geom(geo_el['follow']) + if 'clear' in geo_el: + geo_el['clear'] = rotate_geom(geo_el['clear']) + except Exception as e: + log.debug('camlib.Gerber.rotate() Exception --> %s' % str(e)) + return 'fail' + self.app.inform.emit('[success] %s' % + _("Gerber Rotate done.")) + self.app.proc_container.new_text = '' + + +def parse_number(strnumber): + """ + Parse a single number of HPGL2 coordinates. + + :param strnumber: String containing a number + from a coordinate data block, possibly with a leading sign. + :type strnumber: str + :return: The number in floating point. + :rtype: float + """ + + return float(strnumber) * 40.0 # in milimeters +