# ########################################################## ## # FlatCAM: 2D Post-processing for Manufacturing # # http://flatcam.org # # Author: Juan Pablo Caram (c) # # Date: 2/5/2014 # # MIT Licence # # ########################################################## ## from camlib import Geometry, grace import shapely.affinity as affinity from shapely.geometry import Point, LineString import numpy as np import re import logging import traceback from copy import deepcopy # import AppTranslation as fcTranslate import gettext import builtins if '_' not in builtins.__dict__: _ = gettext.gettext log = logging.getLogger('base') class Excellon(Geometry): """ Here it is done all the Excellon parsing. *ATTRIBUTES* * ``tools`` (dict): The key is the tool name and the value is a dictionary specifying the tool: ================ ==================================== Key Value ================ ==================================== tooldia Diameter of the tool drills List that store the Shapely Points for drill points slots List that store the Shapely Points for slots. Each is a tuple: (start_point, stop_point) data dictionary which holds the options for each tool solid_geometry Geometry list for each tool ================ ==================================== """ defaults = { "zeros": "L", "excellon_format_upper_mm": '3', "excellon_format_lower_mm": '3', "excellon_format_upper_in": '2', "excellon_format_lower_in": '4', "excellon_units": 'INCH', "geo_steps_per_circle": '64' } def __init__(self, zeros=None, excellon_format_upper_mm=None, excellon_format_lower_mm=None, excellon_format_upper_in=None, excellon_format_lower_in=None, excellon_units=None, geo_steps_per_circle=None): """ The constructor takes no parameters. :return: Excellon object. :rtype: Excellon """ self.decimals = self.app.decimals if geo_steps_per_circle is None: geo_steps_per_circle = int(Excellon.defaults['geo_steps_per_circle']) self.geo_steps_per_circle = int(geo_steps_per_circle) Geometry.__init__(self, geo_steps_per_circle=int(geo_steps_per_circle)) # dictionary to store tools, see above for description self.tools = {} self.source_file = '' # it serve to flag if a start routing or a stop routing was encountered # if a stop is encounter and this flag is still 0 (so there is no stop for a previous start) issue error self.routing_flag = 1 self.match_routing_start = None self.match_routing_stop = None # ## IN|MM -> Units are inherited from Geometry self.units = self.app.defaults['units'] self.units_found = self.app.defaults['units'] # Trailing "T" or leading "L" (default) # self.zeros = "T" self.zeros = zeros or self.defaults["zeros"] self.zeros_found = deepcopy(self.zeros) # this will serve as a default if the Excellon file has no info regarding of tool diameters (this info may be # in another file like for PCB WIzard ECAD software self.toolless_diam = 1.0 # signal that the Excellon file has no tool diameter informations and the tools have bogus (random) diameter self.diameterless = False # Excellon format self.excellon_format_upper_in = excellon_format_upper_in or self.defaults["excellon_format_upper_in"] self.excellon_format_lower_in = excellon_format_lower_in or self.defaults["excellon_format_lower_in"] self.excellon_format_upper_mm = excellon_format_upper_mm or self.defaults["excellon_format_upper_mm"] self.excellon_format_lower_mm = excellon_format_lower_mm or self.defaults["excellon_format_lower_mm"] self.excellon_units = excellon_units or self.defaults["excellon_units"] self.excellon_units_found = None # detected Excellon format is stored here: self.excellon_format = None # Attributes to be included in serialization # Always append to it because it carries contents # from Geometry. self.ser_attrs += ['zeros', 'excellon_format_upper_mm', 'excellon_format_lower_mm', 'excellon_format_upper_in', 'excellon_format_lower_in', 'excellon_units', 'source_file'] # ### Patterns #### # Regex basics: # ^ - beginning # $ - end # *: 0 or more, +: 1 or more, ?: 0 or 1 # M48 - Beginning of Part Program Header self.hbegin_re = re.compile(r'^M48$') # ;HEADER - Beginning of Allegro Program Header self.allegro_hbegin_re = re.compile(r'\;\s*(HEADER)') # M95 or % - End of Part Program Header # NOTE: % has different meaning in the body self.hend_re = re.compile(r'^(?:M95|%)$') # FMAT Excellon format # Ignored in the parser # self.fmat_re = re.compile(r'^FMAT,([12])$') # Uunits and possible Excellon zeros and possible Excellon format # INCH uses 6 digits # METRIC uses 5/6 self.units_re = re.compile(r'^(INCH|METRIC)(?:,([TL])Z)?,?(\d*\.\d+)?.*$') # Tool definition/parameters (?= is look-ahead # NOTE: This might be an overkill! # self.toolset_re = re.compile(r'^T(0?\d|\d\d)(?=.*C(\d*\.?\d*))?' + # r'(?=.*F(\d*\.?\d*))?(?=.*S(\d*\.?\d*))?' + # r'(?=.*B(\d*\.?\d*))?(?=.*H(\d*\.?\d*))?' + # r'(?=.*Z([-\+]?\d*\.?\d*))?[CFSBHT]') self.toolset_re = re.compile(r'^T(\d+)(?=.*C,?(\d*\.?\d*))?' + r'(?=.*F(\d*\.?\d*))?(?=.*S(\d*\.?\d*))?' + r'(?=.*B(\d*\.?\d*))?(?=.*H(\d*\.?\d*))?' + r'(?=.*Z([-\+]?\d*\.?\d*))?[CFSBHT]') self.detect_gcode_re = re.compile(r'^G2([01])$') # Tool select # Can have additional data after tool number but # is ignored if present in the header. # Warning: This will match toolset_re too. # self.toolsel_re = re.compile(r'^T((?:\d\d)|(?:\d))') self.toolsel_re = re.compile(r'^T(\d+)') # Headerless toolset # self.toolset_hl_re = re.compile(r'^T(\d+)(?=.*C(\d*\.?\d*))') self.toolset_hl_re = re.compile(r'^T(\d+)(?:.?C(\d+\.?\d*))?') # Comment self.comm_re = re.compile(r'^;(.*)$') # Absolute/Incremental G90/G91 self.absinc_re = re.compile(r'^G9([01])$') # Modes of operation # 1-linear, 2-circCW, 3-cirCCW, 4-vardwell, 5-Drill self.modes_re = re.compile(r'^G0([012345])') # Measuring mode # 1-metric, 2-inch self.meas_re = re.compile(r'^M7([12])$') # Coordinates # self.xcoord_re = re.compile(r'^X(\d*\.?\d*)(?:Y\d*\.?\d*)?$') # self.ycoord_re = re.compile(r'^(?:X\d*\.?\d*)?Y(\d*\.?\d*)$') coordsperiod_re_string = r'(?=.*X([-\+]?\d*\.\d*))?(?=.*Y([-\+]?\d*\.\d*))?[XY]' self.coordsperiod_re = re.compile(coordsperiod_re_string) coordsnoperiod_re_string = r'(?!.*\.)(?=.*X([-\+]?\d*))?(?=.*Y([-\+]?\d*))?[XY]' self.coordsnoperiod_re = re.compile(coordsnoperiod_re_string) # Slots parsing slots_re_string = r'^([^G]+)G85(.*)$' self.slots_re = re.compile(slots_re_string) # R - Repeat hole (# times, X offset, Y offset) self.rep_re = re.compile(r'^R(\d+)(?=.*[XY])+(?:X([-\+]?\d*\.?\d*))?(?:Y([-\+]?\d*\.?\d*))?$') # Various stop/pause commands self.stop_re = re.compile(r'^((G04)|(M09)|(M06)|(M00)|(M30))') # Allegro Excellon format support self.tool_units_re = re.compile(r'(\;\s*Holesize \d+.\s*\=\s*(\d+.\d+).*(MILS|MM))') # Altium Excellon format support # it's a comment like this: ";FILE_FORMAT=2:5" self.altium_format = re.compile(r'^;\s*(?:FILE_FORMAT)?(?:Format)?[=|:]\s*(\d+)[:|.](\d+).*$') # Parse coordinates self.leadingzeros_re = re.compile(r'^[-\+]?(0*)(\d*)') # Repeating command self.repeat_re = re.compile(r'R(\d+)') def parse_file(self, filename=None, file_obj=None): """ Reads the specified file as array of lines as passes it to ``parse_lines()``. :param filename: The file to be read and parsed. :param file_obj: :type filename: str :return: None """ if file_obj: estr = file_obj else: if filename is None: return "fail" efile = open(filename, 'r') estr = efile.readlines() efile.close() try: self.parse_lines(estr) except Exception: return "fail" def parse_lines(self, elines): """ Main Excellon parser. :param elines: List of strings, each being a line of Excellon code. :type elines: list :return: None """ # State variables current_tool = "" in_header = False headerless = False current_x = None current_y = None slot_current_x = None slot_current_y = None name_tool = 0 allegro_warning = False line_units_found = False repeating_x = 0 repeating_y = 0 repeat = 0 line_units = '' # ## Parsing starts here ## ## line_num = 0 # Line number eline = "" try: for eline in elines: if self.app.abort_flag: # graceful abort requested by the user raise grace line_num += 1 # log.debug("%3d %s" % (line_num, str(eline))) self.source_file += eline # Cleanup lines eline = eline.strip(' \r\n') # Excellon files and Gcode share some extensions therefore if we detect G20 or G21 it's GCODe # and we need to exit from here if self.detect_gcode_re.search(eline): log.warning("This is GCODE mark: %s" % eline) self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_('This is GCODE mark'), eline)) return # Header Begin (M48) # if self.hbegin_re.search(eline): in_header = True headerless = False log.warning("Found start of the header: %s" % eline) continue # Allegro Header Begin (;HEADER) # if self.allegro_hbegin_re.search(eline): in_header = True allegro_warning = True log.warning("Found ALLEGRO start of the header: %s" % eline) continue # Search for Header End # # Since there might be comments in the header that include header end char (% or M95) # we ignore the lines starting with ';' that contains such header end chars because it is not a # real header end. if self.comm_re.search(eline): match = self.tool_units_re.search(eline) if match: if line_units_found is False: line_units_found = True line_units = match.group(3) self.convert_units({"MILS": "IN", "MM": "MM"}[line_units]) log.warning("Type of Allegro UNITS found inline in comments: %s" % line_units) if match.group(2): name_tool += 1 # ---------- add a TOOL ------------ # if name_tool not in self.tools: self.tools[name_tool] = {} if line_units == 'MILS': spec = { 'tooldia': (float(match.group(2)) / 1000) } self.tools[name_tool]['tooldia'] = (float(match.group(2)) / 1000) log.debug("Tool definition: %d %s" % (name_tool, spec)) else: spec = { 'tooldia': float(match.group(2)) } self.tools[name_tool]['tooldia'] = float(match.group(2)) log.debug("Tool definition: %d %s" % (name_tool, spec)) spec['solid_geometry'] = [] continue # search for Altium Excellon Format / Sprint Layout who is included as a comment match = self.altium_format.search(eline) if match: self.excellon_format_upper_mm = match.group(1) self.excellon_format_lower_mm = match.group(2) self.excellon_format_upper_in = match.group(1) self.excellon_format_lower_in = match.group(2) log.warning("Excellon format preset found in comments: %s:%s" % (match.group(1), match.group(2))) continue else: log.warning("Line ignored, it's a comment: %s" % eline) else: if self.hend_re.search(eline): if in_header is False or bool(self.tools) is False: log.warning("Found end of the header but there is no header: %s" % eline) log.warning("The only useful data in header are tools, units and format.") log.warning("Therefore we will create units and format based on defaults.") headerless = True try: self.convert_units({"INCH": "IN", "METRIC": "MM"}[self.excellon_units]) except Exception as e: log.warning("Units could not be converted: %s" % str(e)) in_header = False # for Allegro type of Excellons we reset name_tool variable so we can reuse it for toolchange if allegro_warning is True: name_tool = 0 log.warning("Found end of the header: %s" % eline) ''' In case that the units were not found in the header, we have two choices: - one is to use the default value in the App Preferences - the other is to make an evaluation based on a threshold we process here the self.tools list and make a list with tools with diameter less or equal with 0.1 and a list with tools with value greater than 0.1, 0.1 being the threshold value. Most tools in Excellon are greater than 0.1mm therefore if most of the tools are under this value it is safe to assume that the units are in INCH ''' greater_tools = set() lower_tools = set() if not self.excellon_units_found and self.tools: for tool in self.tools: tool_dia = float(self.tools[tool]['tooldia']) lower_tools.add(tool_dia) if tool_dia <= 0.1 else greater_tools.add(tool_dia) assumed_units = "IN" if len(lower_tools) > len(greater_tools) else "MM" self.units = assumed_units continue # ## Alternative units format M71/M72 # Supposed to be just in the body (yes, the body) # but some put it in the header (PADS for example). # Will detect anywhere. Occurrence will change the # object's units. match = self.meas_re.match(eline) if match: self.units = {"1": "MM", "2": "IN"}[match.group(1)] # Modified for issue #80 log.debug("ALternative M71/M72 units found, before conversion: %s" % self.units) self.convert_units(self.units) log.debug("ALternative M71/M72 units found, after conversion: %s" % self.units) if self.units == 'MM': log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_mm), str(self.excellon_format_lower_mm))) else: log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_in), str(self.excellon_format_lower_in))) continue # ### Body #### if not in_header: # ## Tool change ### match = self.toolsel_re.search(eline) if match: current_tool = int(match.group(1)) log.debug("Tool change: %s" % current_tool) if bool(headerless): match = self.toolset_hl_re.search(eline) if match: name = int(match.group(1)) try: diam = float(match.group(2)) except Exception: # it's possible that tool definition has only tool number and no diameter info # (those could be in another file like PCB Wizard do) # then match.group(2) = None and float(None) will create the exception # the below construction is so each tool will have a slightly different diameter # starting with a default value, to allow Excellon editing after that self.diameterless = True self.app.inform.emit('[WARNING] %s%s %s' % (_("No tool diameter info's. See shell.\n" "A tool change event: T"), str(current_tool), _("was found but the Excellon file " "have no informations regarding the tool " "diameters therefore the application will try to load it " "by using some 'fake' diameters.\n" "The user needs to edit the resulting Excellon object and " "change the diameters to reflect the real diameters.") ) ) if self.excellon_units == 'MM': diam = self.toolless_diam + (int(current_tool) - 1) / 100 else: diam = (self.toolless_diam + (int(current_tool) - 1) / 100) / 25.4 # ---------- add a TOOL ------------ # spec = {"tooldia": diam, 'solid_geometry': []} if name not in self.tools: self.tools[name] = {} self.tools[name]['tooldia'] = diam self.tools[name]['solid_geometry'] = [] log.debug("Tool definition out of header: %s %s" % (name, spec)) continue # ## Allegro Type Tool change ### if allegro_warning is True: match = self.absinc_re.search(eline) match1 = self.stop_re.search(eline) if match or match1: name_tool += 1 current_tool = name_tool log.debug("Tool change for Allegro type of Excellon: %d" % current_tool) continue # ## Slots parsing for drilled slots (contain G85) # a Excellon drilled slot line may look like this: # X01125Y0022244G85Y0027756 match = self.slots_re.search(eline) if match: # signal that there are milling slots operations self.defaults['excellon_drills'] = False # the slot start coordinates group is to the left of G85 command (group(1) ) # the slot stop coordinates group is to the right of G85 command (group(2) ) start_coords_match = match.group(1) stop_coords_match = match.group(2) # Slot coordinates without period # ## # get the coordinates for slot start and for slot stop into variables start_coords_noperiod = self.coordsnoperiod_re.search(start_coords_match) stop_coords_noperiod = self.coordsnoperiod_re.search(stop_coords_match) if start_coords_noperiod: try: slot_start_x = self.parse_number(start_coords_noperiod.group(1)) slot_current_x = slot_start_x except TypeError: slot_start_x = slot_current_x except Exception: return try: slot_start_y = self.parse_number(start_coords_noperiod.group(2)) slot_current_y = slot_start_y except TypeError: slot_start_y = slot_current_y except Exception: return try: slot_stop_x = self.parse_number(stop_coords_noperiod.group(1)) slot_current_x = slot_stop_x except TypeError: slot_stop_x = slot_current_x except Exception: return try: slot_stop_y = self.parse_number(stop_coords_noperiod.group(2)) slot_current_y = slot_stop_y except TypeError: slot_stop_y = slot_current_y except Exception: return if (slot_start_x is None or slot_start_y is None or slot_stop_x is None or slot_stop_y is None): log.error("Slots are missing some or all coordinates.") continue # we have a slot log.debug('Parsed a slot with coordinates: ' + str([slot_start_x, slot_start_y, slot_stop_x, slot_stop_y])) # store current tool diameter as slot diameter slot_dia = 0.05 try: slot_dia = float(self.tools[current_tool]['tooldia']) except Exception: pass log.debug( 'Milling/Drilling slot with tool %s, diam=%f' % ( current_tool, slot_dia ) ) # ---------- add a slot ------------ # slot = ( Point(slot_start_x, slot_start_y), Point(slot_stop_x, slot_stop_y) ) if current_tool not in self.tools: self.tools[current_tool] = {} if 'slots' in self.tools[current_tool]: self.tools[current_tool]['slots'].append(slot) else: self.tools[current_tool]['slots'] = [slot] continue # Slot coordinates with period: Use literally. ### # get the coordinates for slot start and for slot stop into variables start_coords_period = self.coordsperiod_re.search(start_coords_match) stop_coords_period = self.coordsperiod_re.search(stop_coords_match) if start_coords_period: try: slot_start_x = float(start_coords_period.group(1)) slot_current_x = slot_start_x except TypeError: slot_start_x = slot_current_x except Exception: return try: slot_start_y = float(start_coords_period.group(2)) slot_current_y = slot_start_y except TypeError: slot_start_y = slot_current_y except Exception: return try: slot_stop_x = float(stop_coords_period.group(1)) slot_current_x = slot_stop_x except TypeError: slot_stop_x = slot_current_x except Exception: return try: slot_stop_y = float(stop_coords_period.group(2)) slot_current_y = slot_stop_y except TypeError: slot_stop_y = slot_current_y except Exception: return if (slot_start_x is None or slot_start_y is None or slot_stop_x is None or slot_stop_y is None): log.error("Slots are missing some or all coordinates.") continue # we have a slot log.debug('Parsed a slot with coordinates: ' + str([slot_start_x, slot_start_y, slot_stop_x, slot_stop_y])) # store current tool diameter as slot diameter slot_dia = 0.05 try: slot_dia = float(self.tools[current_tool]['tooldia']) except Exception: pass log.debug( 'Milling/Drilling slot with tool %s, diam=%f' % ( current_tool, slot_dia ) ) # ---------- add a Slot ------------ # slot = ( Point(slot_start_x, slot_start_y), Point(slot_stop_x, slot_stop_y) ) if current_tool not in self.tools: self.tools[current_tool] = {} if 'slots' in self.tools[current_tool]: self.tools[current_tool]['slots'].append(slot) else: self.tools[current_tool]['slots'] = [slot] continue # ## Coordinates without period # ## match = self.coordsnoperiod_re.search(eline) if match: matchr = self.repeat_re.search(eline) if matchr: # if we have a repeat command repeat = int(matchr.group(1)) if match.group(1): repeating_x = self.parse_number(match.group(1)) else: repeating_x = 0 if match.group(2): repeating_y = self.parse_number(match.group(2)) else: repeating_y = 0 coordx = current_x coordy = current_y while repeat > 0: if repeating_x: coordx += repeating_x if repeating_y: coordy += repeating_y # ---------- add a Drill ------------ # if current_tool not in self.tools: self.tools[current_tool] = {} if 'drills' in self.tools[current_tool]: self.tools[current_tool]['drills'].append(Point((coordx, coordy))) else: self.tools[current_tool]['drills'] = [Point((coordx, coordy))] repeat -= 1 current_x = coordx current_y = coordy continue else: # those are normal coordinates try: x = self.parse_number(match.group(1)) current_x = x except TypeError: x = current_x except Exception: return try: y = self.parse_number(match.group(2)) current_y = y except TypeError: y = current_y except Exception: return if x is None or y is None: log.error("Missing coordinates") continue # ## Excellon Routing parse if len(re.findall("G00", eline)) > 0: self.match_routing_start = 'G00' # signal that there are milling slots operations self.defaults['excellon_drills'] = False self.routing_flag = 0 slot_start_x = x slot_start_y = y continue if self.routing_flag == 0: if len(re.findall("G01", eline)) > 0: self.match_routing_stop = 'G01' # signal that there are milling slots operations self.defaults['excellon_drills'] = False self.routing_flag = 1 slot_stop_x = x slot_stop_y = y # ---------- add a Slot ------------ # slot = ( Point(slot_start_x, slot_start_y), Point(slot_stop_x, slot_stop_y) ) if current_tool not in self.tools: self.tools[current_tool] = {} if 'slots' in self.tools[current_tool]: self.tools[current_tool]['slots'].append(slot) else: self.tools[current_tool]['slots'] = [slot] continue if self.match_routing_start is None and self.match_routing_stop is None: # signal that there are drill operations self.defaults['excellon_drills'] = True # ---------- add a Drill ------------ # if current_tool not in self.tools: self.tools[current_tool] = {} if 'drills' in self.tools[current_tool]: self.tools[current_tool]['drills'].append(Point((x, y))) else: self.tools[current_tool]['drills'] = [Point((x, y))] # log.debug("{:15} {:8} {:8}".format(eline, x, y)) continue # ## Coordinates with period: Use literally. # ## match = self.coordsperiod_re.search(eline) if match: matchr = self.repeat_re.search(eline) if matchr: repeat = int(matchr.group(1)) if match: # signal that there are drill operations self.defaults['excellon_drills'] = True try: x = float(match.group(1)) repeating_x = current_x current_x = x except TypeError: x = current_x repeating_x = 0 try: y = float(match.group(2)) repeating_y = current_y current_y = y except TypeError: y = current_y repeating_y = 0 if x is None or y is None: log.error("Missing coordinates") continue # ## Excellon Routing parse if len(re.findall("G00", eline)) > 0: self.match_routing_start = 'G00' # signal that there are milling slots operations self.defaults['excellon_drills'] = False self.routing_flag = 0 slot_start_x = x slot_start_y = y continue if self.routing_flag == 0: if len(re.findall("G01", eline)) > 0: self.match_routing_stop = 'G01' # signal that there are milling slots operations self.defaults['excellon_drills'] = False self.routing_flag = 1 slot_stop_x = x slot_stop_y = y # ---------- add a Slot ------------ # slot = ( Point(slot_start_x, slot_start_y), Point(slot_stop_x, slot_stop_y) ) if current_tool not in self.tools: self.tools[current_tool] = {} if 'slots' in self.tools[current_tool]: self.tools[current_tool]['slots'].append(slot) else: self.tools[current_tool]['slots'] = [slot] continue if self.match_routing_start is None and self.match_routing_stop is None: # signal that there are drill operations if repeat == 0: # signal that there are drill operations self.defaults['excellon_drills'] = True # ---------- add a Drill ------------ # if current_tool not in self.tools: self.tools[current_tool] = {} if 'drills' in self.tools[current_tool]: self.tools[current_tool]['drills'].append(Point((x, y))) else: self.tools[current_tool]['drills'] = [Point((x, y))] else: coordx = x coordy = y while repeat > 0: if repeating_x: coordx = (repeat * x) + repeating_x if repeating_y: coordy = (repeat * y) + repeating_y # ---------- add a Drill ------------ # if current_tool not in self.tools: self.tools[current_tool] = {} if 'drills' in self.tools[current_tool]: self.tools[current_tool]['drills'].append(Point((coordx, coordy))) else: self.tools[current_tool]['drills'] = [Point((coordx, coordy))] repeat -= 1 repeating_x = repeating_y = 0 # log.debug("{:15} {:8} {:8}".format(eline, x, y)) continue # ### Header #### if in_header: # ## Tool definitions # ## match = self.toolset_re.search(eline) if match: # ---------- add a TOOL ------------ # name = int(match.group(1)) spec = {"C": float(match.group(2)), 'solid_geometry': []} if name not in self.tools: self.tools[name] = {} self.tools[name]['tooldia'] = float(match.group(2)) self.tools[name]['solid_geometry'] = [] log.debug("Tool definition: %s %s" % (name, spec)) continue # ## Units and number format # ## match = self.units_re.match(eline) if match: self.units = {"METRIC": "MM", "INCH": "IN"}[match.group(1)] self.excellon_units_found = self.units self.zeros = match.group(2) # "T" or "L". Might be empty self.excellon_format = match.group(3) if self.excellon_format: upper = len(self.excellon_format.partition('.')[0]) lower = len(self.excellon_format.partition('.')[2]) if self.units == 'MM': self.excellon_format_upper_mm = upper self.excellon_format_lower_mm = lower else: self.excellon_format_upper_in = upper self.excellon_format_lower_in = lower # Modified for issue #80 log.warning("UNITS found inline - Value before conversion: %s" % self.units) self.convert_units(self.units) log.warning("UNITS found inline - Value after conversion: %s" % self.units) if self.units == 'MM': log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_mm), str(self.excellon_format_lower_mm))) else: log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_in), str(self.excellon_format_lower_in))) log.warning("Type of ZEROS found inline, in header: %s" % self.zeros) continue # Search for units type again it might be alone on the line if "INCH" in eline: line_units = "IN" # Modified for issue #80 log.warning("Type of UNITS found inline, in header, before conversion: %s" % line_units) self.convert_units(line_units) log.warning("Type of UNITS found inline, in header, after conversion: %s" % self.units) log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_in), str(self.excellon_format_lower_in))) self.excellon_units_found = "IN" continue elif "METRIC" in eline: line_units = "MM" # Modified for issue #80 log.warning("Type of UNITS found inline, in header, before conversion: %s" % line_units) self.convert_units(line_units) log.warning("Type of UNITS found inline, in header, after conversion: %s" % self.units) log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_mm), str(self.excellon_format_lower_mm))) self.excellon_units_found = "MM" continue # Search for zeros type again because it might be alone on the line match = re.search(r'[LT]Z', eline) if match: self.zeros = match.group() log.warning("Type of ZEROS found: %s" % self.zeros) continue # ## Units and number format outside header# ## match = self.units_re.match(eline) if match: self.units = {"METRIC": "MM", "INCH": "IN"}[match.group(1)] self.excellon_units_found = self.units self.zeros = match.group(2) # "T" or "L". Might be empty self.excellon_format = match.group(3) if self.excellon_format: upper = len(self.excellon_format.partition('.')[0]) lower = len(self.excellon_format.partition('.')[2]) if self.units == 'MM': self.excellon_format_upper_mm = upper self.excellon_format_lower_mm = lower else: self.excellon_format_upper_in = upper self.excellon_format_lower_in = lower # Modified for issue #80 log.warning("Type of UNITS found outside header, inline before conversion: %s" % self.units) self.convert_units(self.units) log.warning("Type of UNITS found outside header, inline after conversion: %s" % self.units) if self.units == 'MM': log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_mm), str(self.excellon_format_lower_mm))) else: log.warning("Excellon format preset is: %s:%s" % (str(self.excellon_format_upper_in), str(self.excellon_format_lower_in))) log.warning("Type of ZEROS found outside header, inline: %s" % self.zeros) continue log.warning("Line ignored: %s" % eline) # make sure that since we are in headerless mode, we convert the tools only after the file parsing # is finished since the tools definitions are spread in the Excellon body. We use as units the value # from self.defaults['excellon_units'] # the data structure of the Excellon object has to include bot the 'drills' and the 'slots' keys otherwise # I will need to test for them everywhere. # Even if there are not drills or slots I just add the storage there with an empty list for tool in self.tools: if 'drills' not in self.tools[tool]: self.tools[tool]['drills'] = [] if 'slots' not in self.tools[tool]: self.tools[tool]['slots'] = [] log.info("Zeros: %s, Units %s." % (self.zeros, self.units)) except Exception: log.error("Excellon PARSING FAILED. Line %d: %s" % (line_num, eline)) msg = '[ERROR_NOTCL] %s' % _("An internal error has occurred. See shell.\n") msg += '{e_code} {tx} {l_nr}: {line}\n'.format( e_code='[ERROR]', tx=_("Excellon Parser error.\nParsing Failed. Line"), l_nr=line_num, line=eline) msg += traceback.format_exc() self.app.inform.emit(msg) return "fail" def parse_number(self, number_str): """ Parses coordinate numbers without period. :param number_str: String representing the numerical value. :type number_str: str :return: Floating point representation of the number :rtype: float """ match = self.leadingzeros_re.search(number_str) nr_length = len(match.group(1)) + len(match.group(2)) try: if self.zeros == "L" or self.zeros == "LZ": # Leading # With leading zeros, when you type in a coordinate, # the leading zeros must always be included. Trailing zeros # are unneeded and may be left off. The CNC-7 will automatically add them. # r'^[-\+]?(0*)(\d*)' # 6 digits are divided by 10^4 # If less than size digits, they are automatically added, # 5 digits then are divided by 10^3 and so on. if self.units.lower() == "in": result = float(number_str) / (10 ** (float(nr_length) - float(self.excellon_format_upper_in))) else: result = float(number_str) / (10 ** (float(nr_length) - float(self.excellon_format_upper_mm))) return result else: # Trailing # You must show all zeros to the right of the number and can omit # all zeros to the left of the number. The CNC-7 will count the number # of digits you typed and automatically fill in the missing zeros. # ## flatCAM expects 6digits # flatCAM expects the number of digits entered into the defaults if self.units.lower() == "in": # Inches is 00.0000 result = float(number_str) / (10 ** (float(self.excellon_format_lower_in))) else: # Metric is 000.000 result = float(number_str) / (10 ** (float(self.excellon_format_lower_mm))) return result except Exception as e: log.error("Aborted. Operation could not be completed due of %s" % str(e)) return def create_geometry(self): """ Creates circles of the tool diameter at every point specified in self.tools[tool]['drills']. Also creates geometries (polygons) for the slots as specified in self.tools[tool]['slots'] All the resulting geometry is stored into self.solid_geometry list. The list self.solid_geometry has 2 elements: first is a dict with the drills geometry, and second element is another similar dict that contain the slots geometry. Each dict has as keys the tool diameters and as values lists with Shapely objects, the geometries ================ ==================================== Key Value ================ ==================================== tool_diameter list of (Shapely.Point) Where to drill ================ ==================================== :return: None """ log.debug("appParsers.ParseExcellon.Excellon.create_geometry()") self.solid_geometry = [] try: # clear the solid_geometry in self.tools for tool in self.tools: self.tools[tool]['solid_geometry'] = [] self.tools[tool]['data'] = {} for tool in self.tools: tooldia = self.tools[tool]['tooldia'] if 'drills' in self.tools[tool]: for drill in self.tools[tool]['drills']: poly = drill.buffer(tooldia / 2.0, int(int(self.geo_steps_per_circle) / 4)) # add poly in the tools geometry self.tools[tool]['solid_geometry'].append(poly) self.tools[tool]['data'] = deepcopy(self.default_data) # add poly to the total solid geometry self.solid_geometry.append(poly) if 'slots' in self.tools[tool]: for slot in self.tools[tool]['slots']: start = slot[0] stop = slot[1] lines_string = LineString([start, stop]) poly = lines_string.buffer(tooldia / 2.0, int(int(self.geo_steps_per_circle) / 4)) # add poly in the tools geometry self.tools[tool]['solid_geometry'].append(poly) self.tools[tool]['data'] = deepcopy(self.default_data) # add poly to the total solid geometry self.solid_geometry.append(poly) except Exception as e: log.debug("appParsers.ParseExcellon.Excellon.create_geometry() -> " "Excellon geometry creation failed due of ERROR: %s" % str(e)) return "fail" def bounds(self, flatten=None): """ Returns coordinates of rectangular bounds of Excellon geometry: (xmin, ymin, xmax, ymax). :param flatten: No used """ log.debug("appParsers.ParseExcellon.Excellon.bounds()") if self.solid_geometry is None or not self.tools: log.debug("appParsers.ParseExcellon.Excellon -> solid_geometry is None") return 0, 0, 0, 0 def bounds_rec(obj): if type(obj) is list: 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: minx_, miny_, maxx_, maxy_ = bounds_rec(k) 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 minx_list = [] miny_list = [] maxx_list = [] maxy_list = [] for tool in self.tools: eminx, eminy, emaxx, emaxy = bounds_rec(self.tools[tool]['solid_geometry']) minx_list.append(eminx) miny_list.append(eminy) maxx_list.append(emaxx) maxy_list.append(emaxy) return min(minx_list), min(miny_list), max(maxx_list), max(maxy_list) def convert_units(self, units): """ This function first convert to the the units found in the Excellon file but it converts tools that are not there yet so it has no effect other than it signal that the units are the ones in the file. On object creation, in app_obj.new_object(), true conversion is done because this is done at the end of the Excellon file parsing, the tools are inside and self.tools is really converted from the units found inside the file to the FlatCAM units. Kind of convolute way to make the conversion and it is based on the assumption that the Excellon file will have detected the units before the tools are parsed and stored in self.tools :param units: 'IN' or 'MM'. String :return: """ # factor = Geometry.convert_units(self, units) obj_units = units if obj_units.upper() == self.units.upper(): factor = 1.0 elif obj_units.upper() == "MM": factor = 25.4 elif obj_units.upper() == "IN": factor = 1 / 25.4 else: log.error("Unsupported units: %s" % str(obj_units)) factor = 1.0 log.debug("appParsers.ParseExcellon.Excellon.convert_units() --> Factor: %s" % str(factor)) self.units = obj_units self.scale(factor, factor) self.file_units_factor = factor # Tools for tname in self.tools: self.tools[tname]["tooldia"] *= factor self.create_geometry() return factor def scale(self, xfactor, yfactor=None, point=None): """ Scales geometry on the XY plane in the object by a given factor. Tool sizes, feedrates an Z-plane dimensions are untouched. :param xfactor: Number by which to scale the object. :type xfactor: float :param yfactor: Number by which to scale the object. :type yfactor: float :param point: Origin point for scale :return: None :rtype: None """ log.debug("appParsers.ParseExcellon.Excellon.scale()") if yfactor is None: yfactor = xfactor if point is None: px = 0 py = 0 else: px, py = point if xfactor == 0 and yfactor == 0: return 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: return affinity.scale(obj, xfactor, yfactor, origin=(px, py)) except AttributeError: return obj # variables to display the percentage of work done self.geo_len = 0 try: self.geo_len = len(self.tools) except TypeError: self.geo_len = 1 self.old_disp_number = 0 self.el_count = 0 for tool in self.tools: # Scale Drills if 'drills' in self.tools[tool]: new_drills = [] for drill in self.tools[tool]['drills']: new_drills.append(affinity.scale(drill, xfactor, yfactor, origin=(px, py))) self.tools[tool]['drills'] = new_drills # Scale Slots if 'slots' in self.tools[tool]: new_slots = [] for slot in self.tools[tool]['slots']: new_start = affinity.scale(slot[0], xfactor, yfactor, origin=(px, py)) new_stop = affinity.scale(slot[1], xfactor, yfactor, origin=(px, py)) new_slot = (new_start, new_stop) new_slots.append(new_slot) self.tools[tool]['slots'] = new_slots # Scale solid_geometry self.tools[tool]['solid_geometry'] = scale_geom(self.tools[tool]['solid_geometry']) # update status display 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 self.create_geometry() self.app.proc_container.new_text = '' def offset(self, vect): """ Offsets geometry on the XY plane in the object by a given vector. :param vect: (x, y) offset vector. :type vect: tuple :return: None """ log.debug("appParsers.ParseExcellon.Excellon.offset()") dx, dy = vect if dx == 0 and dy == 0: return def offset_geom(obj): try: new_obj = [] for geo in obj: new_obj.append(offset_geom(geo)) return new_obj except TypeError: try: return affinity.translate(obj, xoff=dx, yoff=dy) except AttributeError: return obj # variables to display the percentage of work done self.geo_len = 0 try: self.geo_len = len(self.tools) except TypeError: self.geo_len = 1 self.old_disp_number = 0 self.el_count = 0 for tool in self.tools: # Offset Drills if 'drills' in self.tools[tool]: new_drills = [] for drill in self.tools[tool]['drills']: new_drills.append(affinity.translate(drill, xoff=dx, yoff=dy)) self.tools[tool]['drills'] = new_drills # Offset Slots if 'slots' in self.tools[tool]: new_slots = [] for slot in self.tools[tool]['slots']: new_start = affinity.translate(slot[0], xoff=dx, yoff=dy) new_stop = affinity.translate(slot[1], xoff=dx, yoff=dy) new_slot = (new_start, new_stop) new_slots.append(new_slot) self.tools[tool]['slots'] = new_slots # Offset solid_geometry self.tools[tool]['solid_geometry'] = offset_geom(self.tools[tool]['solid_geometry']) # update status display 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 # Recreate geometry self.create_geometry() self.app.proc_container.new_text = '' def mirror(self, axis, point): """ :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("appParsers.ParseExcellon.Excellon.mirror()") px, py = point xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis] def mirror_geom(obj): try: new_obj = [] for geo in obj: new_obj.append(mirror_geom(geo)) return new_obj except TypeError: try: return affinity.scale(obj, xscale, yscale, origin=(px, py)) except AttributeError: return obj # Modify data # variables to display the percentage of work done self.geo_len = 0 try: self.geo_len = len(self.tools) except TypeError: self.geo_len = 1 self.old_disp_number = 0 self.el_count = 0 for tool in self.tools: # Offset Drills if 'drills' in self.tools[tool]: new_drills = [] for drill in self.tools[tool]['drills']: new_drills.append(affinity.scale(drill, xscale, yscale, origin=(px, py))) self.tools[tool]['drills'] = new_drills # Offset Slots if 'slots' in self.tools[tool]: new_slots = [] for slot in self.tools[tool]['slots']: new_start = affinity.scale(slot[0], xscale, yscale, origin=(px, py)) new_stop = affinity.scale(slot[1], xscale, yscale, origin=(px, py)) new_slot = (new_start, new_stop) new_slots.append(new_slot) self.tools[tool]['slots'] = new_slots # Offset solid_geometry self.tools[tool]['solid_geometry'] = mirror_geom(self.tools[tool]['solid_geometry']) # update status display 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 # Recreate geometry self.create_geometry() self.app.proc_container.new_text = '' def skew(self, angle_x=None, angle_y=None, point=None): """ Shear/Skew the geometries of an object by angles along x and y dimensions. Tool sizes, feedrates an Z-plane dimensions are untouched. :param angle_x: :param angle_y: 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. :param point: Origin point for Skew See shapely manual for more information: http://toblerity.org/shapely/manual.html#affine-transformations """ log.debug("appParsers.ParseExcellon.Excellon.skew()") if angle_x is None: angle_x = 0.0 if angle_y is None: angle_y = 0.0 if angle_x == 0 and angle_y == 0: return def skew_geom(obj): try: new_obj = [] for g in obj: new_obj.append(skew_geom(g)) return new_obj except TypeError: try: return affinity.skew(obj, angle_x, angle_y, origin=(px, py)) except AttributeError: return obj # variables to display the percentage of work done self.geo_len = 0 try: self.geo_len = len(self.tools) except TypeError: self.geo_len = 1 self.old_disp_number = 0 self.el_count = 0 if point is None: px, py = 0, 0 else: px, py = point for tool in self.tools: # Offset Drills if 'drills' in self.tools[tool]: new_drills = [] for drill in self.tools[tool]['drills']: new_drills.append(affinity.skew(drill, angle_x, angle_y, origin=(px, py))) self.tools[tool]['drills'] = new_drills # Offset Slots if 'slots' in self.tools[tool]: new_slots = [] for slot in self.tools[tool]['slots']: new_start = affinity.skew(slot[0], angle_x, angle_y, origin=(px, py)) new_stop = affinity.skew(slot[1], angle_x, angle_y, origin=(px, py)) new_slot = (new_start, new_stop) new_slots.append(new_slot) self.tools[tool]['slots'] = new_slots # Offset solid_geometry self.tools[tool]['solid_geometry'] = skew_geom(self.tools[tool]['solid_geometry']) # update status display 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 self.create_geometry() self.app.proc_container.new_text = '' def rotate(self, angle, point=None): """ Rotate the geometry of an object by an angle around the 'point' coordinates :param angle: :param point: tuple of coordinates (x, y) :return: None """ log.debug("appParsers.ParseExcellon.Excellon.rotate()") if angle == 0: return def rotate_geom(obj, origin=None): if type(obj) is list: new_obj = [] for g in obj: new_obj.append(rotate_geom(g)) return new_obj else: if origin: try: return affinity.rotate(obj, angle, origin=origin) except AttributeError: return obj else: try: return affinity.rotate(obj, angle, origin=orig) except AttributeError: return obj # variables to display the percentage of work done self.geo_len = 0 try: self.geo_len = len(self.tools) except TypeError: self.geo_len = 1 self.old_disp_number = 0 self.el_count = 0 if point is None: orig = 'center' else: orig = point for tool in self.tools: # Offset Drills if 'drills' in self.tools[tool]: new_drills = [] for drill in self.tools[tool]['drills']: new_drills.append(affinity.rotate(drill, angle, origin=orig)) self.tools[tool]['drills'] = new_drills # Offset Slots if 'slots' in self.tools[tool]: new_slots = [] for slot in self.tools[tool]['slots']: new_start = affinity.rotate(slot[0], angle, origin=orig) new_stop = affinity.rotate(slot[1], angle, origin=orig) new_slot = (new_start, new_stop) new_slots.append(new_slot) self.tools[tool]['slots'] = new_slots # Offset solid_geometry self.tools[tool]['solid_geometry'] = rotate_geom(self.tools[tool]['solid_geometry'], origin=orig) # update status display 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 self.create_geometry() self.app.proc_container.new_text = '' def buffer(self, distance, join, factor): """ :param distance: if 'factor' is True then distance is the factor :param factor: True or False (None) :param join: The type of line joint used by the shapely buffer method: round, square, bevel :return: None """ log.debug("appParsers.ParseExcellon.Excellon.buffer()") if distance == 0: return def buffer_geom(obj): try: new_obj = [] for g in obj: new_obj.append(buffer_geom(g)) return new_obj except TypeError: try: if factor is None: return obj.buffer(distance, resolution=self.geo_steps_per_circle) else: return affinity.scale(obj, xfact=distance, yfact=distance, origin='center') except AttributeError: return obj # buffer solid_geometry for tool, tool_dict in list(self.tools.items()): res = buffer_geom(tool_dict['solid_geometry']) try: __ = iter(res) self.tools[tool]['solid_geometry'] = res except TypeError: self.tools[tool]['solid_geometry'] = [res] if factor is None: self.tools[tool]['tooldia'] += distance else: self.tools[tool]['tooldia'] *= distance self.create_geometry()