Add EasyEda file parser

Issue #95

Author: qu1ck

InteractiveHtmlBom/core/ibom.py

@@ -239,7 +239,9 @@ def main(parser, config, logger):
     # type: (EcadParser, Config, Logger) -> None
     global log
     log = logger
-    pcb_file_name = parser.file_name
+    pcb_file_name = os.path.basename(parser.file_name)
+    pcb_file_dir = os.path.dirname(parser.file_name)
+
     # Get extra field data
     extra_fields = None
     if config.netlist_file and os.path.isfile(config.netlist_file):
@@ -266,9 +268,10 @@ def main(parser, config, logger):
 
     extra_fields = extra_fields[1] if extra_fields else None
 
-    pcb_file_dir = os.path.dirname(pcb_file_name)
-
     pcbdata, components = parser.parse()
+    if not pcbdata or not components:
+        logger.error('Parsing failed.')
+        exit(1)
     pcbdata["bom"]["both"] = generate_bom(components, config, extra_fields)
 
     # build BOM

InteractiveHtmlBom/ecad/__init__.py

@@ -1,3 +1,21 @@
-def get_kicad_parser(file_name, logger, board):
+import os
+
+
+def get_parser_by_extension(file_name, logger):
+    ext = os.path.splitext(file_name)[1]
+    if ext == '.kicad_pcb':
+        return get_kicad_parser(file_name, logger)
+    elif ext == '.json':
+        return get_easyeda_parser(file_name, logger)
+    else:
+        return None
+
+
+def get_kicad_parser(file_name, logger, board=None):
     from .kicad import PcbnewParser
     return PcbnewParser(file_name, logger, board)
+
+
+def get_easyeda_parser(file_name, logger):
+    from .easyeda import EasyEdaParser
+    return EasyEdaParser(file_name, logger)

InteractiveHtmlBom/ecad/common.py

@@ -1,3 +1,6 @@
+import math
+
+
 class EcadParser(object):
 
     def __init__(self, file_name, logger):
@@ -30,3 +33,94 @@ def __init__(self, ref, val, footprint, layer, attr=None):
         self.footprint = footprint
         self.layer = layer
         self.attr = attr
+
+
+class BoundingBox(object):
+    """Geometry util to calculate and compound bounding box of simple shapes."""
+
+    def __init__(self):
+        self._x0 = None
+        self._y0 = None
+        self._x1 = None
+        self._y1 = None
+
+    def to_dict(self):
+        # type: () -> dict
+        return {
+            "minx": self._x0,
+            "miny": self._y0,
+            "maxx": self._x1,
+            "maxy": self._y1,
+        }
+
+    def to_component_dict(self):
+        # type: () -> dict
+        return {
+            "pos": [self._x0, self._y0],
+            "size": [self._x1 - self._x0, self._y1 - self._y0],
+        }
+
+    def add(self, other):
+        """Add another bounding box.
+        :type other: BoundingBox
+        """
+        if other._x0 is not None:
+            self.add_point(other._x0, other._y0)
+            self.add_point(other._x1, other._y1)
+        return self
+
+    @staticmethod
+    def _rotate(x, y, rx, ry, angle):
+        sin = math.sin(math.radians(angle))
+        cos = math.cos(math.radians(angle))
+        new_x = rx + (x - rx) * cos - (y - ry) * sin
+        new_y = ry + (x - rx) * sin + (y - ry) * cos
+        return new_x, new_y
+
+    def add_point(self, x, y, rx=0, ry=0, angle=0):
+        x, y = self._rotate(x, y, rx, ry, angle)
+        if self._x0 is None:
+            self._x0 = x
+            self._y0 = y
+            self._x1 = x
+            self._y1 = y
+        else:
+            self._x0 = min(self._x0, x)
+            self._y0 = min(self._y0, y)
+            self._x1 = max(self._x1, x)
+            self._y1 = max(self._y1, y)
+        return self
+
+    def add_segment(self, x0, y0, x1, y1, r):
+        self.add_circle(x0, y0, r)
+        self.add_circle(x1, y1, r)
+        return self
+
+    def add_rectangle(self, x, y, w, h, angle=0):
+        self.add_point(x - w / 2, y - h / 2, x, y, angle)
+        self.add_point(x + w / 2, y - h / 2, x, y, angle)
+        self.add_point(x - w / 2, y + h / 2, x, y, angle)
+        self.add_point(x + w / 2, y + h / 2, x, y, angle)
+        return self
+
+    def add_circle(self, x, y, r):
+        self.add_point(x - r, y)
+        self.add_point(x, y - r)
+        self.add_point(x + r, y)
+        self.add_point(x, y + r)
+        return self
+
+    def add_arc(self):
+        # TODO
+        pass
+
+    def pad(self, amount):
+        """Add small padding to the box."""
+        if self._x0 is not None:
+            self._x0 -= amount
+            self._y0 -= amount
+            self._x1 += amount
+            self._y1 += amount
+
+    def initialized(self):
+        return self._x0 is not None