Add translation and intersection

KicadModTree/PolygonPoints.py

@@ -148,6 +148,14 @@ def rotate(self, angle, origin=(0, 0), use_degrees=True):
             p.rotate(angle=angle, origin=origin, use_degrees=use_degrees)
         return self
 
+    def translate(self, distance_vector):
+        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

@@ -225,6 +225,13 @@ def from_polar(radius, angle, origin=(0, 0), use_degrees=True):
 
         return Vector2D({'x': x, 'y': y})+Vector2D(origin)
 
+    def to_homogeneous(self):
+        return Vector3D(self.x, self.y, 1)
+
+    @staticmethod
+    def from_homogeneous(source):
+        return Vector2D(source.x/source.z, source.y/source.z)
+
 
 class Vector3D(Vector2D):
     r"""Representation of a 3D Vector in space
@@ -298,6 +305,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

@@ -123,6 +123,11 @@ def rotate(self, angle, origin=(0, 0), use_degrees=True):
         self.start_pos.rotate(angle=angle, origin=origin, use_degrees=use_degrees)
         return self
 
+    def translate(self, distance_vector):
+        self.center_pos += distance_vector
+        self.start_pos += distance_vector
+        return self
+
     def calculateBoundingBox(self):
         # TODO: finish implementation
         min_x = min(self.start_pos.x, self._calulateEndPos().x)

KicadModTree/nodes/base/Circle.py

@@ -57,6 +57,11 @@ def rotate(self, angle, origin=(0, 0), use_degrees=True):
         self._calcEndPos()
         return self
 
+    def translate(self, distance_vector):
+        self.center_pos += distance_vector
+        self._calcEndPos()
+        return self
+
     def calculateBoundingBox(self):
         min_x = self.center_pos.x-self.radius
         min_y = self.center_pos.y-self.radius

KicadModTree/nodes/base/Line.py

@@ -52,6 +52,19 @@ def rotate(self, angle, origin=(0, 0), use_degrees=True):
         self.end_pos.rotate(angle=angle, origin=origin, use_degrees=use_degrees)
         return self
 
+    def translate(self, distance_vector):
+        self.start_pos += distance_vector
+        self.end_pos += distance_vector
+        return self
+
+    def cut(self, other, second_point=(0, 0)):
+        pass
+
+    def to_homogeneous(self):
+        p1 = self.start_pos.to_homogeneous()
+        p2 = self.end_pos.to_homogeneous()
+        return p1.cross_product(p2)
+
     def calculateBoundingBox(self):
         render_start_pos = self.getRealPosition(self.start_pos)
         render_end_pos = self.getRealPosition(self.end_pos)

KicadModTree/nodes/base/Pad.py

@@ -249,6 +249,10 @@ def rotate(self, angle, origin=(0, 0), use_degrees=True):
         self.rotation -= a
         return self
 
+    def translate(self, distance_vector):
+        self.at += distance_vector
+        return self
+
     # calculate the outline of a pad
     def calculateBoundingBox(self):
         return Node.calculateBoundingBox(self)

KicadModTree/nodes/base/Polygon.py

@@ -53,6 +53,10 @@ def rotate(self, angle, origin=(0, 0), use_degrees=True):
         self.nodes.rotate(angle=angle, origin=origin, use_degrees=use_degrees)
         return self
 
+    def translate(self, distance_vector):
+        self.nodes.translate(distance_vector)
+        return self
+
     def calculateBoundingBox(self):
         return nodes.calculateBoundingBox()
 

KicadModTree/nodes/base/Text.py

@@ -80,6 +80,10 @@ def rotate(self, angle, origin=(0, 0), use_degrees=True):
         self.rotation -= a
         return self
 
+    def translate(self, distance_vector):
+        self.at += distance_vector
+        return self
+
     def calculateBoundingBox(self):
         width = len(self.text)*self.size['x']
         height = self.size['y']

KicadModTree/util/geometric_util.py

@@ -0,0 +1,64 @@
+# KicadModTree is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# KicadModTree is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with kicad-footprint-generator. If not, see < http://www.gnu.org/licenses/ >.
+#
+# (C) 2016-2018 by Thomas Pointhuber, <thomas.pointhuber@gmx.at>
+
+import math
+from KicadModTree.nodes.base import *
+from KicadModTree.Vector import *
+
+
+class BaseNodeIntersection():
+
+    @staticmethod
+    def intersectTwoLines(line1, line2):
+        # we use homogeneous coordinates here.
+        l1 = line1.to_homogeneous()
+        l2 = line2.to_homogeneous()
+
+        ip = l1.cross_product(l2)
+        if ip.z == 0:
+            return None
+
+        return Vector2D.from_homogeneous(ip)
+
+    @staticmethod
+    def intersectLineWithCircle(line, circle):
+        # from http://mathworld.wolfram.com/Circle-LineIntersection.html
+        # Equations are for circle center on (0, 0) so we translate everything
+        # to the orign (well the line anyways as we do only need the radius of the circle)
+        lt = Line(start=line.start_pos, end=line.end_pos).translate(-circle.center_pos)
+
+        d = lt.end_pos - lt.start_pos
+        dr = math.hypot(d.x, d.y)
+        D = lt.start_pos.x*lt.end_pos.y - lt.end_pos.x*lt.start_pos.y
+
+        discriminant = circle.radius**2 * dr**2 - D**2
+        intersection = []
+        if discriminant < 0:
+            return intersection
+
+        intersection.append(
+            Vector2D({
+                'x': (D*d.y + math.copysign(1, d.y)*d.x*math.sqrt(discriminant))/dr**2,
+                'y': (-D*d.x + abs(d.y)*math.sqrt(discriminant))/dr**2
+                }) + circle.center_pos)
+        if discriminant == 0:
+            return intersection
+
+        intersection.append(
+            Vector2D({
+                'x': (D*d.y - math.copysign(1, d.y)*d.x*math.sqrt(discriminant))/dr**2,
+                'y': (-D*d.x - abs(d.y)*math.sqrt(discriminant))/dr**2
+                }) + circle.center_pos)
+        return intersection