add Texas SO-20 PowerPAD

.codeclimate.yml

@@ -19,3 +19,4 @@ ratings:
 exclude_paths:
 - doc/**/*
 - scripts/**/*
+- "**/tests/"

.travis.yml

@@ -6,10 +6,10 @@ cache:
 language: python
 python:
   - "2.7"
-  - "3.3"
   - "3.4"
   - "3.5"
   - "3.6"
+  - "3.7"
 install:
   - ./manage.sh update_dev_packages
 script:

AUTHORS.md

@@ -1,23 +1,22 @@
 **Maintainer:**
 
 * Thomas Pointhuber <thomas.pointhuber@gmx.at> @pointhi
-
+* Rene Pöschl, @poeschlr
+* @evanshultz
 
 **Contributors:**
 
 People who have submitted patches, reported bugs, consulted features or generally made KicadModTree better
 
 * Oliver, @SchrodingersGat
 * Jan W. Krieger, @jkriege2
-* Rene Pöschl, @poeschlr
 * Frank, @Frankkkkk
 * @Hackscribble
 * @stoth
 * Patrick Pelletier, @ppelleti
 * @DASFrank
 * Dominik Baack, @matyro
-* Jordi Orlando, @0xdec
-* @evanshultz
+* Jordi Pakey-Rodriguez, @0xdec
 * George, @grob6000
 * Tobias Müller, @twam
 * Terje Io, @terjeio
@@ -27,3 +26,58 @@ People who have submitted patches, reported bugs, consulted features or generall
 * Trevor Vannoy,  @tvannoy
 * Kari Hautio, @kh4
 * Stefan, @Misca1234
+* Antonio Vazquez, @antoniovazquezblanco
+* Hendrik v. Raven, @lorem-ipsum
+* Asuki Kono, @asukiaaa
+* Xathar, @jneiva08
+* @matthuszagh
+* @ferdymercury
+* @jhalmen
+* @herostrat
+* @fauxpark
+* @matthijskooijman
+* Clara Hobbs, @Ratfink
+* @MRQ
+* Stefan Krüger, @s-light
+* John Whitmore, @johnfwhitmore
+* Daniel Mack, @zonque
+* @dominformant
+* @tpambor
+* @nivekg
+* Joel, @myfreescalewebpage
+* JonRB, @eeyrjmr
+* Alexander Ransmann, @cronJ
+* Christian Schlüter, @chschlue
+* Chase Patterson, @chapatt
+* Rolf Schäuble, @rschaeuble
+* @penoud
+* @ki5libs
+* @fvollmer
+* @cp-aquila
+* Anders Wallin, @aewallin
+* Jonas Schievink, @jonas-schievink
+* Diego Herranz, @diegoherranz
+* Alexandre Oliveira, @RockyTV
+* Konstantin Oblaukhov, @ObKo
+* Jesper, @JeppeSRC
+* Jacob E. F. Overgaard @JacobEFO
+* Ed Peguillan III, @yankee14
+* Thomas Schmid, @rckTom
+* @mitch354
+* Jan Krueger, @einball
+* @dogtopus
+* Darrell Harmon, @dlharmon
+* David Imhoff, @dimhoff
+* marble, @cyber-murmel
+* @chemicstry
+* @awygle
+* @TiZed
+* Sean Leavey, @SeanDS
+* @Schlumpf
+* Daniel Giesbrecht, @DanSGiesbrecht
+* Caleb Reister, @calebreister
+* Greg Cormier, @gcormier
+* Ilya Elenskiy, @EvilMav
+* Mathias Walter, @tolot27
+* Michael Munch, @Munken
+* @waschhauser

KicadModTree/KicadFileHandler.py

@@ -186,7 +186,7 @@ def _serialize_Arc(self, node):
 
     def _serialize_CirclePoints(self, node):
         center_pos = node.getRealPosition(node.center_pos)
-        end_pos = node.getRealPosition(node.end_pos)
+        end_pos = node.getRealPosition(node.center_pos + (node.radius, 0))
 
         return [
                 ['center', center_pos.x, center_pos.y],
@@ -238,13 +238,16 @@ def _serialize_Text(self, node):
             sexpr.append('hide')
         sexpr.append(SexprSerializer.NEW_LINE)
 
-        sexpr.append(['effects',
-                      ['font',
-                       ['size', node.size.x, node.size.y],
-                       ['thickness', node.thickness]
-                      ]
-                     ]
-                    )  # NOQA
+        effects = [
+                'effects',
+                ['font',
+                    ['size', node.size.x, node.size.y],
+                    ['thickness', node.thickness]]]
+
+        if node.mirror:
+            effects.append(['justify', 'mirror'])
+
+        sexpr.append(effects)
         sexpr.append(SexprSerializer.NEW_LINE)
 
         return sexpr

KicadModTree/PolygonPoints.py

@@ -143,6 +143,37 @@ def cut(self, other):
 
         self.nodes.insert(idx_self+1, other[idx_other])
 
+    def rotate(self, angle, origin=(0, 0), use_degrees=True):
+        r""" Rotate points around given origin
+
+        :params:
+            * *angle* (``float``)
+                rotation angle
+            * *origin* (``Vector2D``)
+                origin point for the rotation. default: (0, 0)
+            * *use_degrees* (``boolean``)
+                rotation angle is given in degrees. default:True
+        """
+
+        for p in self.nodes:
+            p.rotate(angle=angle, origin=origin, use_degrees=use_degrees)
+        return self
+
+    def translate(self, distance_vector):
+        r""" Translate points
+
+        :params:
+            * *distance_vector* (``Vector2D``)
+                2D vector defining by how much and in what direction to translate.
+        """
+
+        for p in self.nodes:
+            p += distance_vector
+        return self
+
+    def __copy__(self):
+        return PolygonPoints(nodes=self.nodes)
+
     def __iter__(self):
         for n in self.nodes:
             yield n

KicadModTree/Vector.py

@@ -19,7 +19,7 @@
 import warnings
 
 from KicadModTree.util.kicad_util import formatFloat
-from math import sqrt
+from math import sqrt, sin, cos, hypot, atan2, degrees, radians
 
 
 class Vector2D(object):
@@ -85,7 +85,8 @@ def distance_to(self, value):
         :return: distance between self and other point
         """
         other = Vector2D.__arithmetic_parse(value)
-        return sqrt((other.x - self.x)**2 + (other.y - self.y)**2)
+        d = other - self
+        return hypot(d.x, d.y)
 
     @staticmethod
     def __arithmetic_parse(value):
@@ -191,6 +192,90 @@ def __iter__(self):
     def __copy__(self):
         return Vector2D(self.x, self.y)
 
+    def rotate(self, angle, origin=(0, 0), use_degrees=True):
+        r""" Rotate vector around given origin
+
+        :params:
+            * *angle* (``float``)
+                rotation angle
+            * *origin* (``Vector2D``)
+                origin point for the rotation. default: (0, 0)
+            * *use_degrees* (``boolean``)
+                rotation angle is given in degrees. default:True
+        """
+
+        op = Vector2D(origin)
+
+        if use_degrees:
+            angle = radians(angle)
+
+        temp = op.x + cos(angle) * (self.x - op.x) - sin(angle) * (self.y - op.y)
+        self.y = op.y + sin(angle) * (self.x - op.x) + cos(angle) * (self.y - op.y)
+        self.x = temp
+
+        return self
+
+    def to_polar(self, origin=(0, 0), use_degrees=True):
+        r""" Get polar representation of the vector
+
+        :params:
+            * *origin* (``Vector2D``)
+                origin point for polar conversion. default: (0, 0)
+            * *use_degrees* (``boolean``)
+                angle in degrees. default:True
+        """
+
+        op = Vector2D(origin)
+
+        diff = self - op
+        radius = hypot(diff.x, diff.y)
+
+        angle = atan2(diff.y, diff.x)
+        if use_degrees:
+            angle = degrees(angle)
+
+        return (radius, angle)
+
+    @staticmethod
+    def from_polar(radius, angle, origin=(0, 0), use_degrees=True):
+        r""" Generate a vector from its polar representation
+
+        :params:
+            * *radius* (``float``)
+                lenght of the vector
+            * *angle* (``float``)
+                angle of the vector
+            * *origin* (``Vector2D``)
+                origin point for polar conversion. default: (0, 0)
+            * *use_degrees* (``boolean``)
+                angle in degrees. default:True
+        """
+
+        if use_degrees:
+            angle = radians(angle)
+
+        x = radius * cos(angle)
+        y = radius * sin(angle)
+
+        return Vector2D({'x': x, 'y': y})+Vector2D(origin)
+
+    def to_homogeneous(self):
+        r""" Get homogeneous representation
+        """
+
+        return Vector3D(self.x, self.y, 1)
+
+    @staticmethod
+    def from_homogeneous(source):
+        r""" Recover 2d vector from its homogeneous representation
+
+        :params:
+            * *source* (``Vector3D``)
+                3d homogeneous representation
+        """
+
+        return Vector2D(source.x/source.z, source.y/source.z)
+
 
 class Vector3D(Vector2D):
     r"""Representation of a 3D Vector in space
@@ -264,6 +349,19 @@ def round_to(self, base):
 
         return Vector3D([round(v / base) * base for v in self])
 
+    def cross_product(self, other):
+        other = Vector3D.__arithmetic_parse(other)
+
+        return Vector3D({
+                    'x': self.y*other.z - self.z*other.y,
+                    'y': self.z*other.x - self.x*other.z,
+                    'z': self.x*other.y - self.y*other.x})
+
+    def dot_product(self, other):
+        other = Vector3D.__arithmetic_parse(other)
+
+        return self.x*other.x + self.y*other.y + self.z*other.z
+
     @staticmethod
     def __arithmetic_parse(value):
         if isinstance(value, Vector3D):

KicadModTree/nodes/base/Arc.py

@@ -16,19 +16,29 @@
 from KicadModTree.Vector import *
 from KicadModTree.nodes.Node import Node
 import math
+from KicadModTree.util.geometric_util import geometricArc, BaseNodeIntersection
 
 
-class Arc(Node):
+class Arc(Node, geometricArc):
     r"""Add an Arc to the render tree
 
     :param \**kwargs:
         See below
 
     :Keyword Arguments:
+        * *geometry* (``geometricArc``)
+          alternative to using geometric parameters
         * *center* (``Vector2D``) --
           center of arc
         * *start* (``Vector2D``) --
           start point of arc
+        * *midpoint* (``Vector2D``) --
+          alternative to start point
+          point is on arc and defines point of equal distance to both arc ends
+          arcs of this form are given as midpoint, center plus angle
+        * *end* (``Vector2D``) --
+          alternative to angle
+          arcs of this form are given as start, end and center
         * *angle* (``float``) --
           angle of arc
         * *layer* (``str``) --
@@ -44,13 +54,34 @@ class Arc(Node):
 
     def __init__(self, **kwargs):
         Node.__init__(self)
-        self.center_pos = Vector2D(kwargs['center'])
-        self.start_pos = Vector2D(kwargs['start'])
-        self.angle = kwargs['angle']
+        geometricArc.__init__(self, **kwargs)
 
         self.layer = kwargs.get('layer', 'F.SilkS')
         self.width = kwargs.get('width')
 
+    def copyReplaceGeometry(self, geometry):
+        return Arc(geometry=geometry, layer=self.layer, width=self.width)
+
+    def copy(self):
+        return Arc(
+            center=self.center_pos, start=self.start_pos, angle=self.angle,
+            layer=self.layer, width=self.width
+            )
+
+    def cut(self, *other):
+        r""" cut line with given other element
+
+        :params:
+            * *other* (``Line``, ``Circle``, ``Arc``)
+                cut the element on any intersection with the given geometric element
+        """
+        result = []
+        garcs = geometricArc.cut(self, *other)
+        for g in garcs:
+            result.append(self.copyReplaceGeometry(g))
+
+        return result
+
     def calculateBoundingBox(self):
         # TODO: finish implementation
         min_x = min(self.start_pos.x, self._calulateEndPos().x)
@@ -76,25 +107,6 @@ def calculateBoundingBox(self):
 
         return Node.calculateBoundingBox({'min': Vector2D((min_x, min_y)), 'max': Vector2D((max_x, max_y))})
 
-    def _calulateEndPos(self):
-        radius = self._calculateRadius()
-
-        angle = self._calculateStartAngle() + math.radians(self.angle)
-
-        return Vector2D(math.sin(angle)*radius, math.cos(angle)*radius)
-
-    def _calculateRadius(self):
-        x_size = self.start_pos.x - self.center_pos.x
-        y_size = self.start_pos.y - self.center_pos.y
-
-        return math.sqrt(math.pow(x_size, 2) + math.pow(y_size, 2))
-
-    def _calculateStartAngle(self):
-        x_size = self.start_pos.x - self.center_pos.x
-        y_size = self.start_pos.y - self.center_pos.y
-
-        return math.atan2(y_size, x_size)
-
     def _getRenderTreeText(self):
         render_strings = ['fp_arc']
         render_strings.append(self.center_pos.render('(center {x} {y})'))