diff options
Diffstat (limited to 'gerbonara/gerber/excellon.py')
| -rwxr-xr-x | gerbonara/gerber/excellon.py | 904 |
1 files changed, 904 insertions, 0 deletions
diff --git a/gerbonara/gerber/excellon.py b/gerbonara/gerber/excellon.py new file mode 100755 index 0000000..5ab062a --- /dev/null +++ b/gerbonara/gerber/excellon.py @@ -0,0 +1,904 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be> + +# 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. + +""" +Excellon File module +==================== +**Excellon file classes** + +This module provides Excellon file classes and parsing utilities +""" + +import math +import operator + +from .cam import CamFile, FileSettings +from .excellon_statements import * +from .excellon_tool import ExcellonToolDefinitionParser +from .primitives import Drill, Slot +from .utils import inch, metric + + +try: + from cStringIO import StringIO +except(ImportError): + from io import StringIO + + + +def read(filename): + """ Read data from filename and return an ExcellonFile + Parameters + ---------- + filename : string + Filename of file to parse + + Returns + ------- + file : :class:`gerber.excellon.ExcellonFile` + An ExcellonFile created from the specified file. + + """ + # File object should use settings from source file by default. + with open(filename, 'rU') as f: + data = f.read() + settings = FileSettings(**detect_excellon_format(data)) + return ExcellonParser(settings).parse(filename) + +def loads(data, filename=None, settings=None, tools=None): + """ Read data from string and return an ExcellonFile + Parameters + ---------- + data : string + string containing Excellon file contents + + filename : string, optional + string containing the filename of the data source + + tools: dict (optional) + externally defined tools + + Returns + ------- + file : :class:`gerber.excellon.ExcellonFile` + An ExcellonFile created from the specified file. + + """ + # File object should use settings from source file by default. + if not settings: + settings = FileSettings(**detect_excellon_format(data)) + return ExcellonParser(settings, tools).parse_raw(data, filename) + + +class DrillHit(object): + """Drill feature that is a single drill hole. + + Attributes + ---------- + tool : ExcellonTool + Tool to drill the hole. Defines the size of the hole that is generated. + position : tuple(float, float) + Center position of the drill. + + """ + def __init__(self, tool, position): + self.tool = tool + self.position = position + + def to_inch(self): + if self.tool.settings.units == 'metric': + self.tool.to_inch() + self.position = tuple(map(inch, self.position)) + + def to_metric(self): + if self.tool.settings.units == 'inch': + self.tool.to_metric() + self.position = tuple(map(metric, self.position)) + + @property + def bounding_box(self): + position = self.position + radius = self.tool.diameter / 2. + + min_x = position[0] - radius + max_x = position[0] + radius + min_y = position[1] - radius + max_y = position[1] + radius + return ((min_x, max_x), (min_y, max_y)) + + def offset(self, x_offset=0, y_offset=0): + self.position = tuple(map(operator.add, self.position, (x_offset, y_offset))) + + def __str__(self): + return 'Hit (%f, %f) {%s}' % (self.position[0], self.position[1], self.tool) + +class DrillSlot(object): + """ + A slot is created between two points. The way the slot is created depends on the statement used to create it + """ + + TYPE_ROUT = 1 + TYPE_G85 = 2 + + def __init__(self, tool, start, end, slot_type): + self.tool = tool + self.start = start + self.end = end + self.slot_type = slot_type + + def to_inch(self): + if self.tool.settings.units == 'metric': + self.tool.to_inch() + self.start = tuple(map(inch, self.start)) + self.end = tuple(map(inch, self.end)) + + def to_metric(self): + if self.tool.settings.units == 'inch': + self.tool.to_metric() + self.start = tuple(map(metric, self.start)) + self.end = tuple(map(metric, self.end)) + + @property + def bounding_box(self): + start = self.start + end = self.end + radius = self.tool.diameter / 2. + min_x = min(start[0], end[0]) - radius + max_x = max(start[0], end[0]) + radius + min_y = min(start[1], end[1]) - radius + max_y = max(start[1], end[1]) + radius + return ((min_x, max_x), (min_y, max_y)) + + def offset(self, x_offset=0, y_offset=0): + self.start = tuple(map(operator.add, self.start, (x_offset, y_offset))) + self.end = tuple(map(operator.add, self.end, (x_offset, y_offset))) + + +class ExcellonFile(CamFile): + """ A class representing a single excellon file + + The ExcellonFile class represents a single excellon file. + + http://www.excellon.com/manuals/program.htm + (archived version at https://web.archive.org/web/20150920001043/http://www.excellon.com/manuals/program.htm) + + Parameters + ---------- + tools : list + list of gerber file statements + + hits : list of tuples + list of drill hits as (<Tool>, (x, y)) + + settings : dict + Dictionary of gerber file settings + + filename : string + Filename of the source gerber file + + Attributes + ---------- + units : string + either 'inch' or 'metric'. + + """ + + def __init__(self, statements, tools, hits, settings, filename=None): + super(ExcellonFile, self).__init__(statements=statements, + settings=settings, + filename=filename) + self.tools = tools + self.hits = hits + + @property + def primitives(self): + """ + Gets the primitives. Note that unlike Gerber, this generates new objects + """ + primitives = [] + for hit in self.hits: + if isinstance(hit, DrillHit): + primitives.append(Drill(hit.position, hit.tool.diameter, + units=self.settings.units)) + elif isinstance(hit, DrillSlot): + primitives.append(Slot(hit.start, hit.end, hit.tool.diameter, + units=self.settings.units)) + else: + raise ValueError('Unknown hit type') + return primitives + + @property + def bounding_box(self): + xmin = ymin = 100000000000 + xmax = ymax = -100000000000 + for hit in self.hits: + bbox = hit.bounding_box + xmin = min(bbox[0][0], xmin) + xmax = max(bbox[0][1], xmax) + ymin = min(bbox[1][0], ymin) + ymax = max(bbox[1][1], ymax) + return ((xmin, xmax), (ymin, ymax)) + + def report(self, filename=None): + """ Print or save drill report + """ + if self.settings.units == 'inch': + toolfmt = ' T{:0>2d} {:%d.%df} {: >3d} {:f}in.\n' % self.settings.format + else: + toolfmt = ' T{:0>2d} {:%d.%df} {: >3d} {:f}mm\n' % self.settings.format + rprt = '=====================\nExcellon Drill Report\n=====================\n' + if self.filename is not None: + rprt += 'NC Drill File: %s\n\n' % self.filename + rprt += 'Drill File Info:\n----------------\n' + rprt += (' Data Mode %s\n' % 'Absolute' + if self.settings.notation == 'absolute' else 'Incremental') + rprt += (' Units %s\n' % 'Inches' + if self.settings.units == 'inch' else 'Millimeters') + rprt += '\nTool List:\n----------\n\n' + rprt += ' Code Size Hits Path Length\n' + rprt += ' --------------------------------------\n' + for tool in iter(self.tools.values()): + rprt += toolfmt.format(tool.number, tool.diameter, + tool.hit_count, self.path_length(tool.number)) + if filename is not None: + with open(filename, 'w') as f: + f.write(rprt) + return rprt + + def write(self, filename=None): + filename = filename if filename is not None else self.filename + with open(filename, 'w') as f: + + # Copy the header verbatim + for statement in self.statements: + if not isinstance(statement, ToolSelectionStmt): + f.write(statement.to_excellon(self.settings) + '\n') + else: + break + + # Write out coordinates for drill hits by tool + for tool in iter(self.tools.values()): + f.write(ToolSelectionStmt(tool.number).to_excellon(self.settings) + '\n') + for hit in self.hits: + if hit.tool.number == tool.number: + f.write(CoordinateStmt( + *hit.position).to_excellon(self.settings) + '\n') + f.write(EndOfProgramStmt().to_excellon() + '\n') + + def to_inch(self): + """ + Convert units to inches + """ + if self.units != 'inch': + for statement in self.statements: + statement.to_inch() + for tool in iter(self.tools.values()): + tool.to_inch() + #for primitive in self.primitives: + # primitive.to_inch() + #for hit in self.hits: + # hit.to_inch() + self.units = 'inch' + + def to_metric(self): + """ Convert units to metric + """ + if self.units != 'metric': + for statement in self.statements: + statement.to_metric() + for tool in iter(self.tools.values()): + tool.to_metric() + #for primitive in self.primitives: + # print("Converting to metric: {}".format(primitive)) + # primitive.to_metric() + # print(primitive) + for hit in self.hits: + hit.to_metric() + self.units = '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) + for hit in self. hits: + hit.offset(x_offset, y_offset) + + def path_length(self, tool_number=None): + """ Return the path length for a given tool + """ + lengths = {} + positions = {} + for hit in self.hits: + tool = hit.tool + num = tool.number + positions[num] = ((0, 0) if positions.get(num) is None + else positions[num]) + lengths[num] = 0.0 if lengths.get(num) is None else lengths[num] + lengths[num] = lengths[ + num] + math.hypot(*tuple(map(operator.sub, positions[num], hit.position))) + positions[num] = hit.position + + if tool_number is None: + return lengths + else: + return lengths.get(tool_number) + + def hit_count(self, tool_number=None): + counts = {} + for tool in iter(self.tools.values()): + counts[tool.number] = tool.hit_count + if tool_number is None: + return counts + else: + return counts.get(tool_number) + + def update_tool(self, tool_number, **kwargs): + """ Change parameters of a tool + """ + if kwargs.get('feed_rate') is not None: + self.tools[tool_number].feed_rate = kwargs.get('feed_rate') + if kwargs.get('retract_rate') is not None: + self.tools[tool_number].retract_rate = kwargs.get('retract_rate') + if kwargs.get('rpm') is not None: + self.tools[tool_number].rpm = kwargs.get('rpm') + if kwargs.get('diameter') is not None: + self.tools[tool_number].diameter = kwargs.get('diameter') + if kwargs.get('max_hit_count') is not None: + self.tools[tool_number].max_hit_count = kwargs.get('max_hit_count') + if kwargs.get('depth_offset') is not None: + self.tools[tool_number].depth_offset = kwargs.get('depth_offset') + # Update drill hits + newtool = self.tools[tool_number] + for hit in self.hits: + if hit.tool.number == newtool.number: + hit.tool = newtool + + +class ExcellonParser(object): + """ Excellon File Parser + + Parameters + ---------- + settings : FileSettings or dict-like + Excellon file settings to use when interpreting the excellon file. + """ + def __init__(self, settings=None, ext_tools=None): + self.notation = 'absolute' + self.units = 'inch' + self.zeros = 'leading' + self.format = (2, 4) + self.state = 'INIT' + self.statements = [] + self.tools = {} + self.ext_tools = ext_tools or {} + self.comment_tools = {} + self.hits = [] + self.active_tool = None + self.pos = [0., 0.] + self.drill_down = False + self._previous_line = '' + # Default for plated is None, which means we don't know + self.plated = ExcellonTool.PLATED_UNKNOWN + if settings is not None: + self.units = settings.units + self.zeros = settings.zeros + self.notation = settings.notation + self.format = settings.format + + @property + def coordinates(self): + return [(stmt.x, stmt.y) for stmt in self.statements if isinstance(stmt, CoordinateStmt)] + + @property + def bounds(self): + xmin = ymin = 100000000000 + xmax = ymax = -100000000000 + for x, y in self.coordinates: + if x is not None: + xmin = x if x < xmin else xmin + xmax = x if x > xmax else xmax + if y is not None: + ymin = y if y < ymin else ymin + ymax = y if y > ymax else ymax + return ((xmin, xmax), (ymin, ymax)) + + @property + def hole_sizes(self): + return [stmt.diameter for stmt in self.statements if isinstance(stmt, ExcellonTool)] + + @property + def hole_count(self): + return len(self.hits) + + def parse(self, filename): + with open(filename, 'rU') as f: + data = f.read() + return self.parse_raw(data, filename) + + def parse_raw(self, data, filename=None): + for line in StringIO(data): + self._parse_line(line.strip()) + for stmt in self.statements: + stmt.units = self.units + return ExcellonFile(self.statements, self.tools, self.hits, + self._settings(), filename) + + def _parse_line(self, line): + # skip empty lines + # Prepend previous line's data... + line = '{}{}'.format(self._previous_line, line) + self._previous_line = '' + + # Skip empty lines + if not line.strip(): + return + + if line[0] == ';': + comment_stmt = CommentStmt.from_excellon(line) + self.statements.append(comment_stmt) + + # get format from altium comment + if "FILE_FORMAT" in comment_stmt.comment: + detected_format = tuple( + [int(x) for x in comment_stmt.comment.split('=')[1].split(":")]) + if detected_format: + self.format = detected_format + + if "TYPE=PLATED" in comment_stmt.comment: + self.plated = ExcellonTool.PLATED_YES + + if "TYPE=NON_PLATED" in comment_stmt.comment: + self.plated = ExcellonTool.PLATED_NO + + if "HEADER:" in comment_stmt.comment: + self.state = "HEADER" + + if " Holesize " in comment_stmt.comment: + self.state = "HEADER" + + # Parse this as a hole definition + tools = ExcellonToolDefinitionParser(self._settings()).parse_raw(comment_stmt.comment) + if len(tools) == 1: + tool = tools[tools.keys()[0]] + self._add_comment_tool(tool) + + elif line[:3] == 'M48': + self.statements.append(HeaderBeginStmt()) + self.state = 'HEADER' + + elif line[0] == '%': + self.statements.append(RewindStopStmt()) + if self.state == 'HEADER': + self.state = 'DRILL' + elif self.state == 'INIT': + self.state = 'HEADER' + + elif line[:3] == 'M00' and self.state == 'DRILL': + if self.active_tool: + cur_tool_number = self.active_tool.number + next_tool = self._get_tool(cur_tool_number + 1) + + self.statements.append(NextToolSelectionStmt(self.active_tool, next_tool)) + self.active_tool = next_tool + else: + raise Exception('Invalid state exception') + + elif line[:3] == 'M95': + self.statements.append(HeaderEndStmt()) + if self.state == 'HEADER': + self.state = 'DRILL' + + elif line[:3] == 'M15': + self.statements.append(ZAxisRoutPositionStmt()) + self.drill_down = True + + elif line[:3] == 'M16': + self.statements.append(RetractWithClampingStmt()) + self.drill_down = False + + elif line[:3] == 'M17': + self.statements.append(RetractWithoutClampingStmt()) + self.drill_down = False + + elif line[:3] == 'M30': + stmt = EndOfProgramStmt.from_excellon(line, self._settings()) + self.statements.append(stmt) + + elif line[:3] == 'G00': + # Coordinates may be on the next line + if line.strip() == 'G00': + self._previous_line = line + return + + self.statements.append(RouteModeStmt()) + self.state = 'ROUT' + + stmt = CoordinateStmt.from_excellon(line[3:], self._settings()) + stmt.mode = self.state + + x = stmt.x + y = stmt.y + self.statements.append(stmt) + if self.notation == 'absolute': + if x is not None: + self.pos[0] = x + if y is not None: + self.pos[1] = y + else: + if x is not None: + self.pos[0] += x + if y is not None: + self.pos[1] += y + + elif line[:3] == 'G01': + + # Coordinates might be on the next line... + if line.strip() == 'G01': + self._previous_line = line + return + + self.statements.append(RouteModeStmt()) + self.state = 'LINEAR' + + stmt = CoordinateStmt.from_excellon(line[3:], self._settings()) + stmt.mode = self.state + + # The start position is where we were before the rout command + start = (self.pos[0], self.pos[1]) + + x = stmt.x + y = stmt.y + self.statements.append(stmt) + if self.notation == 'absolute': + if x is not None: + self.pos[0] = x + if y is not None: + self.pos[1] = y + else: + if x is not None: + self.pos[0] += x + if y is not None: + self.pos[1] += y + + # Our ending position + end = (self.pos[0], self.pos[1]) + + if self.drill_down: + if not self.active_tool: + self.active_tool = self._get_tool(1) + + self.hits.append(DrillSlot(self.active_tool, start, end, DrillSlot.TYPE_ROUT)) + self.active_tool._hit() + + elif line[:3] == 'G05': + self.statements.append(DrillModeStmt()) + self.drill_down = False + self.state = 'DRILL' + + elif 'INCH' in line or 'METRIC' in line: + stmt = UnitStmt.from_excellon(line) + self.units = stmt.units + self.zeros = stmt.zeros + if stmt.format: + self.format = stmt.format + self.statements.append(stmt) + + elif line[:3] == 'M71' or line[:3] == 'M72': + stmt = MeasuringModeStmt.from_excellon(line) + self.units = stmt.units + self.statements.append(stmt) + + elif line[:3] == 'ICI': + stmt = IncrementalModeStmt.from_excellon(line) + self.notation = 'incremental' if stmt.mode == 'on' else 'absolute' + self.statements.append(stmt) + + elif line[:3] == 'VER': + stmt = VersionStmt.from_excellon(line) + self.statements.append(stmt) + + elif line[:4] == 'FMAT': + stmt = FormatStmt.from_excellon(line) + self.statements.append(stmt) + self.format = stmt.format_tuple + + elif line[:3] == 'G40': + self.statements.append(CutterCompensationOffStmt()) + + elif line[:3] == 'G41': + self.statements.append(CutterCompensationLeftStmt()) + + elif line[:3] == 'G42': + self.statements.append(CutterCompensationRightStmt()) + + elif line[:3] == 'G90': + self.statements.append(AbsoluteModeStmt()) + self.notation = 'absolute' + + elif line[0] == 'F': + infeed_rate_stmt = ZAxisInfeedRateStmt.from_excellon(line) + self.statements.append(infeed_rate_stmt) + + elif line[0] == 'T' and self.state == 'HEADER': + if not ',OFF' in line and not ',ON' in line: + tool = ExcellonTool.from_excellon(line, self._settings(), None, self.plated) + self._merge_properties(tool) + self.tools[tool.number] = tool + self.statements.append(tool) + else: + self.statements.append(UnknownStmt.from_excellon(line)) + + elif line[0] == 'T' and self.state != 'HEADER': + stmt = ToolSelectionStmt.from_excellon(line) + self.statements.append(stmt) + + # T0 is used as END marker, just ignore + if stmt.tool != 0: + tool = self._get_tool(stmt.tool) + + if not tool: + # FIXME: for weird files with no tools defined, original calc from gerb + if self._settings().units == "inch": + diameter = (16 + 8 * stmt.tool) / 1000.0 + else: + diameter = metric((16 + 8 * stmt.tool) / 1000.0) + + tool = ExcellonTool( + self._settings(), number=stmt.tool, diameter=diameter) + self.tools[tool.number] = tool + + # FIXME: need to add this tool definition inside header to + # make sure it is properly written + for i, s in enumerate(self.statements): + if isinstance(s, ToolSelectionStmt) or isinstance(s, ExcellonTool): + self.statements.insert(i, tool) + break + + self.active_tool = tool + + elif line[0] == 'R' and self.state != 'HEADER': + stmt = RepeatHoleStmt.from_excellon(line, self._settings()) + self.statements.append(stmt) + for i in range(stmt.count): + self.pos[0] += stmt.xdelta if stmt.xdelta is not None else 0 + self.pos[1] += stmt.ydelta if stmt.ydelta is not None else 0 + self.hits.append(DrillHit(self.active_tool, tuple(self.pos))) + self.active_tool._hit() + + elif line[0] in ['X', 'Y']: + if 'G85' in line: + stmt = SlotStmt.from_excellon(line, self._settings()) + + # I don't know if this is actually correct, but it makes sense + # that this is where the tool would end + x = stmt.x_end + y = stmt.y_end + + self.statements.append(stmt) + + if self.notation == 'absolute': + if x is not None: + self.pos[0] = x + if y is not None: + self.pos[1] = y + else: + if x is not None: + self.pos[0] += x + if y is not None: + self.pos[1] += y + + if self.state == 'DRILL' or self.state == 'HEADER': + if not self.active_tool: + self.active_tool = self._get_tool(1) + + self.hits.append(DrillSlot(self.active_tool, (stmt.x_start, stmt.y_start), (stmt.x_end, stmt.y_end), DrillSlot.TYPE_G85)) + self.active_tool._hit() + else: + stmt = CoordinateStmt.from_excellon(line, self._settings()) + + # We need this in case we are in rout mode + start = (self.pos[0], self.pos[1]) + + x = stmt.x + y = stmt.y + self.statements.append(stmt) + if self.notation == 'absolute': + if x is not None: + self.pos[0] = x + if y is not None: + self.pos[1] = y + else: + if x is not None: + self.pos[0] += x + if y is not None: + self.pos[1] += y + + if self.state == 'LINEAR' and self.drill_down: + if not self.active_tool: + self.active_tool = self._get_tool(1) + + self.hits.append(DrillSlot(self.active_tool, start, tuple(self.pos), DrillSlot.TYPE_ROUT)) + + elif self.state == 'DRILL' or self.state == 'HEADER': + # Yes, drills in the header doesn't follow the specification, but it there are many + # files like this + if not self.active_tool: + self.active_tool = self._get_tool(1) + + self.hits.append(DrillHit(self.active_tool, tuple(self.pos))) + self.active_tool._hit() + + else: + self.statements.append(UnknownStmt.from_excellon(line)) + + def _settings(self): + return FileSettings(units=self.units, format=self.format, + zeros=self.zeros, notation=self.notation) + + def _add_comment_tool(self, tool): + """ + Add a tool that was defined in the comments to this file. + + If we have already found this tool, then we will merge this comment tool definition into + the information for the tool + """ + + existing = self.tools.get(tool.number) + if existing and existing.plated == None: + existing.plated = tool.plated + + self.comment_tools[tool.number] = tool + + def _merge_properties(self, tool): + """ + When we have externally defined tools, merge the properties of that tool into this one + + For now, this is only plated + """ + + if tool.plated == ExcellonTool.PLATED_UNKNOWN: + ext_tool = self.ext_tools.get(tool.number) + + if ext_tool: + tool.plated = ext_tool.plated + + def _get_tool(self, toolid): + + tool = self.tools.get(toolid) + if not tool: + tool = self.comment_tools.get(toolid) + if tool: + tool.settings = self._settings() + self.tools[toolid] = tool + + if not tool: + tool = self.ext_tools.get(toolid) + if tool: + tool.settings = self._settings() + self.tools[toolid] = tool + + return tool + +def detect_excellon_format(data=None, filename=None): + """ Detect excellon file decimal format and zero-suppression settings. + + Parameters + ---------- + data : string + String containing contents of Excellon file. + + Returns + ------- + settings : dict + Detected excellon file settings. Keys are + - `format`: decimal format as tuple (<int part>, <decimal part>) + - `zero_suppression`: zero suppression, 'leading' or 'trailing' + """ + results = {} + detected_zeros = None + detected_format = None + zeros_options = ('leading', 'trailing', ) + format_options = ((2, 4), (2, 5), (3, 3),) + + if data is None and filename is None: + raise ValueError('Either data or filename arguments must be provided') + if data is None: + with open(filename, 'rU') as f: + data = f.read() + + # Check for obvious clues: + p = ExcellonParser() + p.parse_raw(data) + + # Get zero_suppression from a unit statement + zero_statements = [stmt.zeros for stmt in p.statements + if isinstance(stmt, UnitStmt)] + + # get format from altium comment + format_comment = [stmt.comment for stmt in p.statements + if isinstance(stmt, CommentStmt) + and 'FILE_FORMAT' in stmt.comment] + + detected_format = (tuple([int(val) for val in + format_comment[0].split('=')[1].split(':')]) + if len(format_comment) == 1 else None) + detected_zeros = zero_statements[0] if len(zero_statements) == 1 else None + + # Bail out here if possible + if detected_format is not None and detected_zeros is not None: + return {'format': detected_format, 'zeros': detected_zeros} + + # Only look at remaining options + if detected_format is not None: + format_options = (detected_format,) + if detected_zeros is not None: + zeros_options = (detected_zeros,) + + # Brute force all remaining options, and pick the best looking one... + for zeros in zeros_options: + for fmt in format_options: + key = (fmt, zeros) + settings = FileSettings(zeros=zeros, format=fmt) + try: + p = ExcellonParser(settings) + ef = p.parse_raw(data) + size = tuple([t[0] - t[1] for t in ef.bounding_box]) + hole_area = 0.0 + for hit in p.hits: + tool = hit.tool + hole_area += math.pow(math.pi * tool.diameter / 2., 2) + results[key] = (size, p.hole_count, hole_area) + except: + pass + + # See if any of the dimensions are left with only a single option + formats = set(key[0] for key in iter(results.keys())) + zeros = set(key[1] for key in iter(results.keys())) + if len(formats) == 1: + detected_format = formats.pop() + if len(zeros) == 1: + detected_zeros = zeros.pop() + + # Bail out here if we got everything.... + if detected_format is not None and detected_zeros is not None: + return {'format': detected_format, 'zeros': detected_zeros} + + # Otherwise score each option and pick the best candidate + else: + scores = {} + for key in results.keys(): + size, count, diameter = results[key] + scores[key] = _layer_size_score(size, count, diameter) + minscore = min(scores.values()) + for key in iter(scores.keys()): + if scores[key] == minscore: + return {'format': key[0], 'zeros': key[1]} + + +def _layer_size_score(size, hole_count, hole_area): + """ Heuristic used for determining the correct file number interpretation. + Lower is better. + """ + board_area = size[0] * size[1] + if board_area == 0: + return 0 + + hole_percentage = hole_area / board_area + hole_score = (hole_percentage - 0.25) ** 2 + size_score = (board_area - 8) ** 2 + return hole_score * size_score |