Replace Point class with a 3 position tuple and a collection of helper functions.

PyCam has been spending about 75% of it's time creating point objects. I decided to replace
the pycam Point object with a 3 position tuple, and the pycam Vector object with a 4 position tuple.

All of the point object methods were rewritten to accept and emit tuples. The transform_by_matrix method
was rewritten to accept both 3 and 4 position tuples with behavior dependent on that size. The
normalized method is the only method required to emit the same kind of object that it is called on, and
this has been taken care of with the tuple version.

What does this mean?
All instances of Point(x,y,z) have been converted into (x,y,z)
All instances of Vector(x,y,z) have been converted into (x,y,z,'v')
The notation to access the x,y,z of the Point objects has been been changed
	from p.x,p.y,p.z to p[0],p[1],p[2]
The notation for the point math functions has been completely changed.
Instead of p1.sub(p2) it has been converted to psub(p1,p2)
Instead of p1.sub(p2).mul(0.5) it has been converted to pmul(psub(p1,p2), 0.5)

It is very important to point out that the tuple is an immutable type.
You can not change it once you create it.
t[0] = calculated_x_value # syntax error
You have to replace the reference (t) to the old tuple with a new reference to a new tuple.
t = (calculated_x_value, t[1], t[2]) # works

There was a particularly hairy mutable/immutable barrier in the next() generator present in each class that
inherits TransformableContainer. The TransformableContainer.transform_by_matrix function uses these
generators to collapse polygons and lines and triangles into points where a shift is performed on each.
Now that point is immutable, you can not change the value emitted by the generator.
Geometry/__init__.py transform_by_marix and the associated next() generator in each sub class has been
rewritten to transfer the attr used to store the reference to the tuple.
Geometry/__init__.py transform_by_matrix now sets these attributes which effectively gets around this
limitation.

There could be some old point object code in any of the files not contained in this commit.
It is impossible to know without running the code path and/or careful analysis of each file.

Some list comprehensions that convert a list of point objects into a 3 position tuple have been removed.

Whitham D. Reeve II

pycam/Cutters/BaseCutter.py

@@ -23,7 +23,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 
 from pycam.Geometry import IDGenerator
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.utils import number, INFINITE, epsilon
 from pycam.Geometry.intersection import intersect_cylinder_point, \
         intersect_cylinder_line
@@ -32,12 +32,12 @@ import uuid
 
 class BaseCutter(IDGenerator):
 
-    vertical = Point(0, 0, -1)
+    vertical = (0, 0, -1)
 
     def __init__(self, radius, location=None, height=None):
         super(BaseCutter, self).__init__()
         if location is None:
-            location = Point(0, 0, 0)
+            location = (0, 0, 0)
         if height is None:
             height = 10
         radius = number(radius)
@@ -56,22 +56,22 @@ class BaseCutter(IDGenerator):
     def get_minx(self, start=None):
         if start is None:
             start = self.location
-        return start.x - self.distance_radius
+        return start[0] - self.distance_radius
 
     def get_maxx(self, start=None):
         if start is None:
             start = self.location
-        return start.x + self.distance_radius
+        return start[0] + self.distance_radius
 
     def get_miny(self, start=None):
         if start is None:
             start = self.location
-        return start.y - self.distance_radius
+        return start[1] - self.distance_radius
 
     def get_maxy(self, start=None):
         if start is None:
             start = self.location
-        return start.y + self.distance_radius
+        return start[1] + self.distance_radius
 
     def update_uuid(self):
         self.uuid = uuid.uuid4()
@@ -105,7 +105,7 @@ class BaseCutter(IDGenerator):
         # "moveto" is used for collision detection calculation.
         self.location = location
         for shape, set_pos_func in self.shape.values():
-            set_pos_func(location.x, location.y, location.z)
+            set_pos_func(location[0], location[1], location[2])
 
     def intersect(self, direction, triangle, start=None):
         raise NotImplementedError("Inherited class of BaseCutter does not " \
@@ -126,7 +126,7 @@ class BaseCutter(IDGenerator):
 
         # check bounding circle collision
         c = triangle.middle
-        if (c.x - start.x) ** 2 + (c.y - start.y) ** 2 \
+        if (c[0] - start[0]) ** 2 + (c[1] - start[1]) ** 2 \
                 > (self.distance_radiussq + 2 * self.distance_radius \
                     * triangle.radius + triangle.radiussq) + epsilon:
             return None
@@ -150,7 +150,8 @@ class BaseCutter(IDGenerator):
                 start=start)
         if cp:
             # check if the contact point is between the endpoints
-            m = cp.sub(edge.p1).dot(edge.dir)
+            m = pdot(psub(cp, edge.p1), edge.dir)
+            #m = cp.sub(edge.p1).dot(edge.dir)
             if (m < -epsilon) or (m > edge.len + epsilon):
                 return (None, INFINITE, cp)
         return (cl, l, cp)
@@ -159,8 +160,8 @@ class BaseCutter(IDGenerator):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_cylinder_point(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_radius, self.distance_radiussq, direction, point)
+                padd(psub(start, self.location), self.center), #start.sub(self.location).add(self.center)
+                self.axis, self.distance_radius, self.distance_radiussq, direction, point)
         # offset intersection
         if ccp:
             cl = cp.add(start.sub(ccp))
@@ -172,7 +173,8 @@ class BaseCutter(IDGenerator):
             start = self.location
         (cl, ccp, cp, l) = self.intersect_cylinder_point(direction, point,
                 start=start)
-        if ccp and ccp.z < start.sub(self.location).add(self.center).z:
+        #if ccp and ccp[2] < start.sub(self.location).add(self.center)[2]:
+        if ccp and ccp[2] < padd(psub(start, self.location), self.center)[2]:
             return (None, INFINITE, None)
         return (cl, l, cp)
 
@@ -180,11 +182,12 @@ class BaseCutter(IDGenerator):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_cylinder_line(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_radius, self.distance_radiussq, direction, edge)
+                padd(psub(start, self.location), self.center), #start.sub(self.location).add(self.center), 
+                self.axis, self.distance_radius, self.distance_radiussq, direction, edge)
         # offset intersection
         if ccp:
-            cl = start.add(cp.sub(ccp))
+            cl = padd(start, psub(cp, ccp))
+            #cl = start.add(cp.sub(ccp))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -195,10 +198,12 @@ class BaseCutter(IDGenerator):
                 start=start)
         if not ccp:
             return (None, INFINITE, None)
-        m = cp.sub(edge.p1).dot(edge.dir)
+        m = pdot(psub(cp, edge.p1), edge.dir)
+        #m = cp.sub(edge.p1).dot(edge.dir)
         if (m < -epsilon) or (m > edge.len + epsilon):
             return (None, INFINITE, None)
-        if ccp.z < start.sub(self.location).add(self.center).z:
+        #if ccp.z < start.sub(self.location).add(self.center)[2]:
+        if ccp[2] < padd(psub(start, self.location), self.center)[2]:
             return (None, INFINITE, None)
         return (cl, l, cp)
 

pycam/Cutters/CylindricalCutter.py

@@ -22,7 +22,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 from pycam.Geometry.utils import INFINITE, sqrt
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.intersection import intersect_circle_plane, \
         intersect_circle_point, intersect_circle_line
 from pycam.Cutters.BaseCutter import BaseCutter
@@ -40,7 +40,7 @@ class CylindricalCutter(BaseCutter):
 
     def __init__(self, radius, **kwargs):
         BaseCutter.__init__(self, radius, **kwargs)
-        self.axis = Vector(0, 0, 1)
+        self.axis = (0, 0, 1, 'v')
 
     def __repr__(self):
         return "CylindricalCutter<%s,%s>" % (self.location, self.radius)
@@ -92,17 +92,17 @@ class CylindricalCutter(BaseCutter):
                 geom_connect_transform = ode.GeomTransform(geom.space)
                 geom_connect_transform.setBody(geom.getBody())
                 geom_connect = ode_physics.get_parallelepiped_geom(
-                        (Point(-hypotenuse / 2, radius, -diff_z / 2),
-                        Point(hypotenuse / 2, radius, diff_z / 2),
-                        Point(hypotenuse / 2, -radius, diff_z / 2),
-                        Point(-hypotenuse / 2, -radius, -diff_z / 2)),
-                        (Point(-hypotenuse / 2, radius,
+                        ((-hypotenuse / 2, radius, -diff_z / 2),
+                        (hypotenuse / 2, radius, diff_z / 2),
+                        (hypotenuse / 2, -radius, diff_z / 2),
+                        (-hypotenuse / 2, -radius, -diff_z / 2)),
+                        ((-hypotenuse / 2, radius,
                             self.height - diff_z / 2),
-                        Point(hypotenuse / 2,
+                        (hypotenuse / 2,
                             radius, self.height + diff_z / 2),
-                        Point(hypotenuse / 2, -radius,
+                        (hypotenuse / 2, -radius,
                             self.height + diff_z / 2),
-                        Point(-hypotenuse / 2, -radius,
+                        (-hypotenuse / 2, -radius,
                             self.height - diff_z / 2)))
                 geom_connect.setRotation(rot_matrix_box)
                 geom_connect.setPosition((hypotenuse / 2, 0, radius))
@@ -119,7 +119,7 @@ class CylindricalCutter(BaseCutter):
         if not GL_enabled:
             return
         GL.glPushMatrix()
-        GL.glTranslate(self.center.x, self.center.y, self.center.z)
+        GL.glTranslate(self.center[0], self.center[1], self.center[2])
         if not hasattr(self, "_cylinder"):
             self._cylinder = GLU.gluNewQuadric()
         GLU.gluCylinder(self._cylinder, self.radius, self.radius, self.height,
@@ -131,17 +131,18 @@ class CylindricalCutter(BaseCutter):
 
     def moveto(self, location, **kwargs):
         BaseCutter.moveto(self, location, **kwargs)
-        self.center = Point(location.x, location.y,
-                location.z - self.get_required_distance())
+        self.center = (location[0], location[1],
+                location[2] - self.get_required_distance())
 
     def intersect_circle_plane(self, direction, triangle, start=None):
         if start is None:
             start = self.location
         (ccp, cp, d) = intersect_circle_plane(
-                start.sub(self.location).add(self.center), self.distance_radius,
-                direction, triangle)
+                padd(psub(start, self.location), self.center), #start.sub(self.location).add(self.center), 
+                self.distance_radius, direction, triangle)
         if ccp and cp:
-            cl = cp.add(start.sub(ccp))
+            cl = padd(cp, psub(start, ccp))
+            #cl = cp.add(start.sub(ccp))
             return (cl, ccp, cp, d)
         return (None, None, None, INFINITE)
 
@@ -149,10 +150,11 @@ class CylindricalCutter(BaseCutter):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_circle_point(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_radius, self.distance_radiussq, direction, point)
+                padd(psub(start, self.location), self.center), #start.sub(self.location).add(self.center), 
+                self.axis, self.distance_radius, self.distance_radiussq, direction, point)
         if ccp:
-            cl = cp.add(start.sub(ccp))
+            cl = padd(cp, psub(start, ccp))
+            #cl = cp.add(start.sub(ccp))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -160,10 +162,11 @@ class CylindricalCutter(BaseCutter):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_circle_line(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_radius, self.distance_radiussq, direction, edge)
+                padd(psub(start, self.location), self.center), #start.sub(self.location).add(self.center), 
+                self.axis, self.distance_radius, self.distance_radiussq, direction, edge)
         if ccp:
-            cl = cp.add(start.sub(ccp))
+            cl = padd(cp, psub(start, ccp))
+            #cl = cp.add(start.sub(ccp))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -177,7 +180,7 @@ class CylindricalCutter(BaseCutter):
             d = d_t
             cl = cl_t
             cp = cp_t
-        if cl and (direction.x == 0) and (direction.y == 0):
+        if cl and (direction[0] == 0) and (direction[1] == 0):
             #print 'circle_triangle:'
             #print 'cl is:', cl, 'd is:', d, 'cp is:', cp
             return (cl, d, cp)
@@ -202,7 +205,7 @@ class CylindricalCutter(BaseCutter):
             cl = cl_e3
             cp = cp_e3
             #print 'circle_edge e3:'
-        if cl and (direction.x == 0) and (direction.y == 0):
+        if cl and (direction[0] == 0) and (direction[1] == 0):
             #print 'circle_edge:'
             #print 'cl is:', cl, 'd is:', d, 'cp is:', cp
             return (cl, d, cp)
@@ -227,11 +230,11 @@ class CylindricalCutter(BaseCutter):
             cl = cl_p3
             cp = cp_p3
             #print 'circle vertex p3:'
-        if cl and (direction.x == 0) and (direction.y == 0):
+        if cl and (direction[0] == 0) and (direction[1] == 0):
             #print 'circle vertex:'
             #print 'cl is:', cl, 'd is:', d, 'cp is:', cp
             return (cl, d, cp)
-        if (direction.x != 0) or (direction.y != 0):
+        if (direction[0] != 0) or (direction[1] != 0):
             (cl_p1, d_p1, cp_p1) = self.intersect_cylinder_vertex(direction,
                     triangle.p1, start=start)
             (cl_p2, d_p2, cp_p2) = self.intersect_cylinder_vertex(direction,

pycam/Cutters/SphericalCutter.py

@@ -22,7 +22,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 from pycam.Geometry import Matrix
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.utils import INFINITE, epsilon, sqrt
 from pycam.Geometry.intersection import intersect_sphere_plane, \
         intersect_sphere_point, intersect_sphere_line
@@ -41,7 +41,7 @@ class SphericalCutter(BaseCutter):
 
     def __init__(self, radius, **kwargs):
         BaseCutter.__init__(self, radius, **kwargs)
-        self.axis = Vector(0, 0, 1)
+        self.axis = (0, 0, 1, 'v')
 
     def __repr__(self):
         return "SphericalCutter<%s,%s>" % (self.location, self.radius)
@@ -84,17 +84,17 @@ class SphericalCutter(BaseCutter):
                 geom_connect_transform = ode.GeomTransform(geom.space)
                 geom_connect_transform.setBody(geom.getBody())
                 geom_connect = ode_physics.get_parallelepiped_geom((
-                        Point(-hypotenuse / 2, radius, -diff_z / 2),
-                        Point(hypotenuse / 2, radius, diff_z / 2),
-                        Point(hypotenuse / 2, -radius, diff_z / 2),
-                        Point(-hypotenuse / 2, -radius, -diff_z / 2)),
-                        (Point(-hypotenuse / 2, radius,
+                        (-hypotenuse / 2, radius, -diff_z / 2),
+                        (hypotenuse / 2, radius, diff_z / 2),
+                        (hypotenuse / 2, -radius, diff_z / 2),
+                        (-hypotenuse / 2, -radius, -diff_z / 2)),
+                        ((-hypotenuse / 2, radius,
                             self.height - diff_z / 2),
-                        Point(hypotenuse / 2, radius,
+                        (hypotenuse / 2, radius,
                             self.height + diff_z / 2),
-                        Point(hypotenuse / 2, -radius,
+                        (hypotenuse / 2, -radius,
                             self.height + diff_z / 2),
-                        Point(-hypotenuse / 2, -radius,
+                        (-hypotenuse / 2, -radius,
                             self.height - diff_z / 2)))
                 geom_connect.setRotation(rot_matrix_box)
                 geom_connect.setPosition((hypotenuse / 2, 0, radius))
@@ -129,7 +129,7 @@ class SphericalCutter(BaseCutter):
         if not GL_enabled:
             return
         GL.glPushMatrix()
-        GL.glTranslate(self.center.x, self.center.y, self.center.z)
+        GL.glTranslate(self.center[0], self.center[1], self.center[2])
         if not hasattr(self, "_sphere"):
             self._sphere = GLU.gluNewQuadric()
         GLU.gluSphere(self._sphere, self.radius, 10, 10)
@@ -141,17 +141,18 @@ class SphericalCutter(BaseCutter):
 
     def moveto(self, location, **kwargs):
         BaseCutter.moveto(self, location, **kwargs)
-        self.center = Point(location.x, location.y, location.z + self.radius)
+        self.center = (location[0], location[1], location[2] + self.radius)
 
     def intersect_sphere_plane(self, direction, triangle, start=None):
         if start is None:
             start = self.location
         (ccp, cp, d) = intersect_sphere_plane(
-                start.sub(self.location).add(self.center), self.distance_radius,
-                direction, triangle)
+                padd(psub(start, self.location), self.center), #start.sub(self.location).add(self.center), 
+                self.distance_radius, direction, triangle)
         # offset intersection
         if ccp:
-            cl = cp.add(start.sub(ccp))
+            cl = padd(cp, psub(start, ccp))
+            #cl = cp.add(start.sub(ccp))
             return (cl, ccp, cp, d)
         return (None, None, None, INFINITE)
 
@@ -166,8 +167,8 @@ class SphericalCutter(BaseCutter):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_sphere_point(
-                start.sub(self.location).add(self.center), self.distance_radius,
-                self.distance_radiussq, direction, point)
+                padd(psub(start, self.location), self.center), #start.sub(self.location).add(self.center), 
+                self.distance_radius, self.distance_radiussq, direction, point)
         # offset intersection
         cl = None
         if cp:
@@ -183,11 +184,12 @@ class SphericalCutter(BaseCutter):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_sphere_line(
-                start.sub(self.location).add(self.center), self.distance_radius,
-                self.distance_radiussq, direction, edge)
+                padd(psub(start, self.location), self.center), # start.sub(self.location).add(self.center),
+                self.distance_radius, self.distance_radiussq, direction, edge)
         # offset intersection
         if ccp:
-            cl = cp.sub(ccp.sub(start))
+            cl = psub(cp, psub(ccp, start))
+            #cl = cp.sub(ccp.sub(start))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -196,9 +198,11 @@ class SphericalCutter(BaseCutter):
                 start=start)
         if cp:
             # check if the contact point is between the endpoints
-            d = edge.p2.sub(edge.p1)
-            m = cp.sub(edge.p1).dot(d)
-            if (m < -epsilon) or (m > d.normsq + epsilon):
+            d = psub(edge.p2, edge.p1)
+            #d = edge.p2.sub(edge.p1)
+            m = pdot(psub(cp, edge.p1), d)
+            #m = cp.sub(edge.p1).dot(d)
+            if (m < -epsilon) or (m > pnormsq(d) + epsilon):
                 return (None, INFINITE, None)
         return (cl, l, cp)
 
@@ -216,7 +220,7 @@ class SphericalCutter(BaseCutter):
             d = d_t
             cl = cl_t
             cp = cp_t
-        if cl and (direction.x == 0) and (direction.y == 0):
+        if cl and (direction[0] == 0) and (direction[1] == 0):
             return (cl, d, cp)
         (cl_e1, d_e1, cp_e1) = self.intersect_sphere_edge(direction,
                 triangle.e1, start=start)
@@ -254,9 +258,9 @@ class SphericalCutter(BaseCutter):
             d = d_p3
             cl = cl_p3
             cp = cp_p3
-        if cl and (direction.x == 0) and (direction.y == 0):
+        if cl and (direction[0] == 0) and (direction[1] == 0):
             return (cl, d, cp)
-        if (direction.x != 0) or (direction.y != 0):
+        if (direction[0] != 0) or (direction[1] != 0):
             (cl_p1, d_p1, cp_p1) = self.intersect_cylinder_vertex(direction,
                     triangle.p1, start=start)
             (cl_p2, d_p2, cp_p2) = self.intersect_cylinder_vertex(direction,

pycam/Cutters/ToroidalCutter.py

@@ -21,7 +21,7 @@ You should have received a copy of the GNU General Public License
 along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.utils import INFINITE, number, epsilon
 from pycam.Geometry.intersection import intersect_torus_plane, \
         intersect_torus_point, intersect_circle_plane, intersect_circle_point, \
@@ -46,7 +46,7 @@ class ToroidalCutter(BaseCutter):
         # we need "minorradius" for "moveto" - thus set it before parent's init
         BaseCutter.__init__(self, radius, **kwargs)
         self.majorradius = self.radius - minorradius
-        self.axis = Point(0, 0, 1)
+        self.axis = (0, 0, 1)
         self.majorradiussq = self.majorradius ** 2
         self.minorradiussq = self.minorradius ** 2
         self.distance_majorradius = self.majorradius \
@@ -97,7 +97,7 @@ class ToroidalCutter(BaseCutter):
         if not GL_enabled:
             return
         GL.glPushMatrix()
-        GL.glTranslate(self.center.x, self.center.y, self.center.z)
+        GL.glTranslate(self.center[0], self.center[1], self.center[2])
         GLUT.glutSolidTorus(self.minorradius, self.majorradius, 10, 20)
         if not hasattr(self, "_cylinder"):
             self._cylinder = GLU.gluNewQuadric()
@@ -105,7 +105,7 @@ class ToroidalCutter(BaseCutter):
                 10, 20)
         GL.glPopMatrix()
         GL.glPushMatrix()
-        GL.glTranslate(self.location.x, self.location.y, self.location.z)
+        GL.glTranslate(self.location[0], self.location[1], self.location[2])
         if not hasattr(self, "_disk"):
             self._disk = GLU.gluNewQuadric()
         GLU.gluDisk(self._disk, 0, self.majorradius, 20, 10)
@@ -113,17 +113,18 @@ class ToroidalCutter(BaseCutter):
 
     def moveto(self, location, **kwargs):
         BaseCutter.moveto(self, location, **kwargs)
-        self.center = Point(location.x, location.y, location.z+self.minorradius)
+        self.center = (location[0], location[1], location[2]+self.minorradius)
 
     def intersect_torus_plane(self, direction, triangle, start=None):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_torus_plane(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_majorradius, self.distance_minorradius, direction,
+                padd(psub(start, self.location), self.center), # start.sub(self.location).add(self.center), 
+                self.axis, self.distance_majorradius, self.distance_minorradius, direction,
                 triangle)
         if cp:
-            cl = cp.add(start.sub(ccp))
+            cl = padd(cp, psub(start, ccp))
+            #cl = cp.add(start.sub(ccp))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -138,12 +139,13 @@ class ToroidalCutter(BaseCutter):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_torus_point(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_majorradius, self.distance_minorradius,
+                padd(psub(start, self.location), self.center), # start.sub(self.location).add(self.center), 
+                self.axis, self.distance_majorradius, self.distance_minorradius,
                 self.distance_majorradiussq, self.distance_minorradiussq,
                 direction, point)
         if ccp:
-            cl = point.add(start.sub(ccp))
+            cl = padd(point, psub(start, ccp))
+            #cl = point.add(start.sub(ccp))
             return (cl, ccp, point, l)
         return (None, None, None, INFINITE)
 
@@ -195,11 +197,12 @@ class ToroidalCutter(BaseCutter):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_cylinder_point(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_radius, self.distance_radiussq, direction, point)
+                padd(psub(start, self.location), self.center), # start.sub(self.location).add(self.center), 
+                self.axis, self.distance_radius, self.distance_radiussq, direction, point)
         # offset intersection
         if ccp:
-            cl = start.add(direction.mul(l))
+            cl = padd(start, pmul(direction, l))
+            #cl = start.add(direction.mul(l))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -207,21 +210,23 @@ class ToroidalCutter(BaseCutter):
         if start is None:
             start = self.location
         (ccp, cp, l) = intersect_cylinder_line(
-                start.sub(self.location).add(self.center), self.axis,
-                self.distance_radius, self.distance_radiussq, direction, edge)
+                padd(psub(start, self.location), self.center), # start.sub(self.location).add(self.center), 
+                self.axis, self.distance_radius, self.distance_radiussq, direction, edge)
         # offset intersection
         if ccp:
-            cl = start.add(cp.sub(ccp))
+            cl = padd(start, psub(cp, ccp))
+            #cl = start.add(cp.sub(ccp))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
     def intersect_cylinder_edge(self, direction, edge, start=None):
         (cl, ccp, cp, l) = self.intersect_cylinder_line(direction, edge,
                 start=start)
-        if ccp and ccp.z < self.center.z:
+        if ccp and ccp[2] < self.center[2]:
             return (None, INFINITE, None)
         if ccp:
-            m = cp.sub(edge.p1).dot(edge.dir)
+            m = pdot(psub(cp, edge.p1), edge.dir)
+            #m = cp.sub(edge.p1).dot(edge.dir)
             if (m < -epsilon) or (m > edge.len + epsilon):
                 return (None, INFINITE, None)
         return (cl, l, cp)
@@ -233,7 +238,8 @@ class ToroidalCutter(BaseCutter):
                 self.distance_majorradius, direction, triangle)
         # offset intersection
         if ccp:
-            cl = cp.sub(ccp.sub(start))
+            cl = psub(cp, psub(ccp, start))
+            #cl = cp.sub(ccp.sub(start))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -244,7 +250,8 @@ class ToroidalCutter(BaseCutter):
                 self.distance_majorradius, self.distance_majorradiussq,
                 direction, point)
         if ccp:
-            cl = cp.sub(ccp.sub(start))
+            cl = psub(cp, psub(ccp, start))
+            #cl = cp.sub(ccp.sub(start))
             return (cl, ccp, point, l)
         return (None, None, None, INFINITE)
 
@@ -255,7 +262,8 @@ class ToroidalCutter(BaseCutter):
                 self.distance_majorradius, self.distance_majorradiussq,
                 direction, edge)
         if ccp:
-            cl = cp.sub(ccp.sub(start))
+            cl = psub(cp, psub(ccp, start))
+            #cl = cp.sub(ccp.sub(start))
             return (cl, ccp, cp, l)
         return (None, None, None, INFINITE)
 
@@ -347,7 +355,7 @@ class ToroidalCutter(BaseCutter):
             d = d_e3
             cl = cl_e3
             cp = cp_e3
-        if direction.x != 0 or direction.y != 0:
+        if direction[0] != 0 or direction[1] != 0:
             (cl_p1, d_p1, cp_p1) = self.intersect_cylinder_vertex(direction,
                     triangle.p1, start=start)
             (cl_p2, d_p2, cp_p2) = self.intersect_cylinder_vertex(direction,

pycam/Geometry/Letters.py

@@ -24,7 +24,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 from pycam.Geometry import TransformableContainer
 from pycam.Geometry.Model import ContourModel
 from pycam.Geometry.Line import Line
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 
 TEXT_ALIGN_LEFT = 0
 TEXT_ALIGN_CENTER = 1
@@ -50,9 +50,7 @@ class Letter(TransformableContainer):
 
     def get_positioned_lines(self, base_point, skew=None):
         result = []
-        get_skewed_point = lambda p: \
-                Point(base_point.x + p.x + (p.y * skew / 100.0),
-                        base_point.y + p.y, base_point.z)
+        get_skewed_point = lambda p: (base_point[0] + p[0] + (p[1] * skew / 100.0), base_point[1] + p[1], base_point[2])
         for line in self.lines:
             skewed_p1 = get_skewed_point(line.p1)
             skewed_p2 = get_skewed_point(line.p2)
@@ -133,13 +131,15 @@ class Charset(object):
                     # update line height
                     line_height = max(line_height, charset_letter.maxy())
                     # shift the base position
-                    base = base.add(Point(
+                    base = base.add((
                             charset_letter.maxx() + letter_spacing, 0, 0))
                 else:
                     # unknown character - add a small whitespace
-                    base = base.add(Point(letter_spacing, 0, 0))
+                    base = padd(base, (letter_spacing, 0, 0))
+                    #base = base.add(Point(letter_spacing, 0, 0))
             # go to the next line
-            base = Point(origin.x, base.y - line_height * line_factor, origin.z)
+            base = (origin[0], base[1] - line_height * line_factor, origin[2])
+            #base = Point(origin.x, base.y - line_height * line_factor, origin.z)
             if not current_line.maxx is None:
                 if align == TEXT_ALIGN_CENTER:
                     current_line.shift(-current_line.maxx / 2, 0, 0)

pycam/Geometry/Line.py

@@ -22,7 +22,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 from pycam.Geometry import TransformableContainer, IDGenerator
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Plane import Plane
 from pycam.Geometry.utils import epsilon, sqrt
 # OpenGLTools will be imported later, if necessary
@@ -48,61 +48,64 @@ class Line(IDGenerator, TransformableContainer):
         self.reset_cache()
 
     def copy(self):
-        return self.__class__(self.p1.copy(), self.p2.copy())
+        return self.__class__(self.p1, self.p2)
 
     @property
     def vector(self):
         if self._vector is None:
-            self._vector = self.p2.sub(self.p1)
+            self._vector = psub(self.p2, self.p1)
+            #self._vector = self.p2.sub(self.p1)
         return self._vector
 
     @property
     def dir(self):
-        return self.vector.normalized()
+        return pnormalized(self.vector)
+        #return self.vector.normalized()
 
     @property
     def len(self):
-        return self.vector.norm
+        return pnorm(self.vector)
+        #return self.vector.norm
 
     @property
     def minx(self):
         if self._minx is None:
-            self._minx = min(self.p1.x, self.p2.x)
+            self._minx = min(self.p1[0], self.p2[0])
         return self._minx
 
     @property
     def maxx(self):
         if self._maxx is None:
-            self._maxx = max(self.p1.x, self.p2.x)
+            self._maxx = max(self.p1[0], self.p2[0])
         return self._maxx
 
     @property
     def miny(self):
         if self._miny is None:
-            self._miny = min(self.p1.y, self.p2.y)
+            self._miny = min(self.p1[1], self.p2[1])
         return self._miny
 
     @property
     def maxy(self):
         if self._maxy is None:
-            self._maxy = max(self.p1.y, self.p2.y)
+            self._maxy = max(self.p1[1], self.p2[1])
         return self._maxy
 
     @property
     def minz(self):
         if self._minz is None:
-            self._minz = min(self.p1.z, self.p2.z)
+            self._minz = min(self.p1[2], self.p2[2])
         return self._minz
 
     @property
     def maxz(self):
         if self._maxz is None:
-            self._maxz = max(self.p1.z, self.p2.z)
+            self._maxz = max(self.p1[2], self.p2[2])
         return self._maxz
 
     def __repr__(self):
-        return "Line<%g,%g,%g>-<%g,%g,%g>" % (self.p1.x, self.p1.y, self.p1.z,
-                self.p2.x, self.p2.y, self.p2.z)
+        return "Line<%g,%g,%g>-<%g,%g,%g>" % (self.p1[0], self.p1[1], self.p1[2],
+                self.p2[0], self.p2[1], self.p2[2])
 
     def __cmp__(self, other):
         """ Two lines are equal if both pairs of points are at the same
@@ -121,8 +124,10 @@ class Line(IDGenerator, TransformableContainer):
             return cmp(str(self), str(other))
         
     def next(self):
-        yield self.p1
-        yield self.p2
+        yield "p1"
+        #yield self.p1
+        #yield lambda x: self.p2 = x
+        yield "p2"
 
     def get_children_count(self):
         # a line always contains two points
@@ -141,23 +146,28 @@ class Line(IDGenerator, TransformableContainer):
         return (self.p1, self.p2)
 
     def point_with_length_multiply(self, l):
-        return self.p1.add(self.dir.mul(l*self.len))
+        return padd(self.p1, pmul(self.dir, l*self.len))
+        #return self.p1.add(self.dir.mul(l*self.len))
 
     def get_length_line(self, length):
         """ return a line with the same direction and the specified length
         """
-        return Line(self.p1, self.p1.add(self.dir.mul(length)))
+        return Line(self.p1, padd(self.p1, pmul(self.dir, length)))
+        #return Line(self.p1, self.p1.add(self.dir.mul(length)))
 
     def closest_point(self, p):
         v = self.dir
         if v is None:
             # for zero-length lines
             return self.p1
-        l = self.p1.dot(v) - p.dot(v)
-        return self.p1.sub(v.mul(l))
+        l = pdot(self.p1, v) - pdot(p, v)
+        #l = self.p1.dot(v) - p.dot(v)
+        return psub(self.p1, pmul(v, l))
+        #return self.p1.sub(v.mul(l))
 
     def dist_to_point_sq(self, p):
-        return p.sub(self.closest_point(p)).normsq
+        return pnormsq(psub(p, self.closes_point(p)))
+        #return p.sub(self.closest_point(p)).normsq
 
     def dist_to_point(self, p):
         return sqrt(self.dist_to_point_sq(p))
@@ -166,8 +176,11 @@ class Line(IDGenerator, TransformableContainer):
         if (p == self.p1) or (p == self.p2):
             # these conditions are not covered by the code below
             return True
-        dir1 = p.sub(self.p1).normalized()
-        dir2 = self.p2.sub(p).normalized()
+            
+        dir1 = pnormalized(psub(p, self.p1))
+        #dir1 = p.sub(self.p1).normalized()
+        dir2 = pnormalized(psub(self.p2, p))
+        #dir2 = self.p2.sub(p).normalized()
         # True if the two parts of the line have the same direction or if the
         # point is self.p1 or self.p2.
         return (dir1 == dir2 == self.dir) or (dir1 is None) or (dir2 is None)
@@ -178,8 +191,8 @@ class Line(IDGenerator, TransformableContainer):
         if not color is None:
             GL.glColor4f(*color)
         GL.glBegin(GL.GL_LINES)
-        GL.glVertex3f(self.p1.x, self.p1.y, self.p1.z)
-        GL.glVertex3f(self.p2.x, self.p2.y, self.p2.z)
+        GL.glVertex3f(self.p1[0], self.p1[1], self.p1[2])
+        GL.glVertex3f(self.p2[0], self.p2[1], self.p2[2])
         GL.glEnd()
         # (optional) draw a cone for visualizing the direction of each line
         if show_directions and (self.len > 0):
@@ -196,24 +209,30 @@ class Line(IDGenerator, TransformableContainer):
         0 and 1.
         """
         x1, x2, x3, x4 = self.p1, self.p2, line.p1, line.p2
-        a = x2.sub(x1)
-        b = x4.sub(x3)
-        c = x3.sub(x1)
+        a = psub(x2, x1)
+        #a = x2.sub(x1)
+        b = psub(x4, x3)
+        #b = x4.sub(x3)
+        c = psub(x3, x1)
+        #c = x3.sub(x1)
         # see http://mathworld.wolfram.com/Line-LineIntersection.html (24)
         try:
-            factor = c.cross(b).dot(a.cross(b)) / a.cross(b).normsq
+            factor = pdot(pcross(c, b), pcross(a, b)) / pnormsq(pcross(a, b))
+            #factor = c.cross(b).dot(a.cross(b)) / a.cross(b).normsq
         except ZeroDivisionError:
             # lines are parallel
             # check if they are _one_ line
-            if a.cross(c).norm != 0:
+            #if a.cross(c).norm != 0:
+            if pnorm(pcross(a,c)) != 0:
                 # the lines are parallel with a distance
                 return None, None
             # the lines are on one straight
             candidates = []
             if self.is_point_inside(x3):
-                candidates.append((x3, c.norm / a.norm))
+                candidates.append((x3, pnorm(c) / pnorm(a)))
             elif self.is_point_inside(x4):
-                candidates.append((x4, line.p2.sub(self.p1).norm / a.norm))
+                candidates.append((x4, pnorm(psub(line.p2, self.p1)) / pnorm(a)))
+                #candidates.append((x4, line.p2.sub(self.p1).norm / a.norm))
             elif line.is_point_inside(x1):
                 candidates.append((x1, 0))
             elif line.is_point_inside(x2):
@@ -224,13 +243,14 @@ class Line(IDGenerator, TransformableContainer):
             candidates.sort(key=lambda (cp, dist): dist)
             return candidates[0]
         if infinite_lines or (-epsilon <= factor <= 1 + epsilon):
-            intersection = x1.add(a.mul(factor))
+            intersection = padd(x1, pmul(a, factor))
+            #intersection = x1.add(a.mul(factor))
             # check if the intersection is between x3 and x4
             if infinite_lines:
                 return intersection, factor
-            elif (min(x3.x, x4.x) - epsilon <= intersection.x <= max(x3.x, x4.x) + epsilon) \
-                    and (min(x3.y, x4.y) - epsilon <= intersection.y <= max(x3.y, x4.y) + epsilon) \
-                    and (min(x3.z, x4.z) - epsilon <= intersection.z <= max(x3.z, x4.z) + epsilon):
+            elif (min(x3[0], x4[0]) - epsilon <= intersection[0] <= max(x3[0], x4[0]) + epsilon) \
+                    and (min(x3[1], x4[1]) - epsilon <= intersection[1] <= max(x3[1], x4[1]) + epsilon) \
+                    and (min(x3[2], x4[2]) - epsilon <= intersection[2] <= max(x3[2], x4[2]) + epsilon):
                 return intersection, factor
             else:
                 # intersection outside of the length of line(x3, x4)
@@ -247,15 +267,15 @@ class Line(IDGenerator, TransformableContainer):
         else:
             # the line needs to be cropped
             # generate the six planes of the cube for possible intersections
-            minp = Point(minx, miny, minz)
-            maxp = Point(maxx, maxy, maxz)
+            minp = (minx, miny, minz)
+            maxp = (maxx, maxy, maxz)
             planes = [
-                    Plane(minp, Point(1, 0, 0)),
-                    Plane(minp, Point(0, 1, 0)),
-                    Plane(minp, Point(0, 0, 1)),
-                    Plane(maxp, Point(1, 0, 0)),
-                    Plane(maxp, Point(0, 1, 0)),
-                    Plane(maxp, Point(0, 0, 1)),
+                    Plane(minp, (1, 0, 0)),
+                    Plane(minp, (0, 1, 0)),
+                    Plane(minp, (0, 0, 1)),
+                    Plane(maxp, (1, 0, 0)),
+                    Plane(maxp, (0, 1, 0)),
+                    Plane(maxp, (0, 0, 1)),
             ]
             # calculate all intersections
             intersections = [plane.intersect_point(self.dir, self.p1)

pycam/Geometry/Matrix.py

@@ -23,7 +23,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 # various matrix related functions for PyCAM
 
 
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.utils import sqrt, number, epsilon
 import math
 
@@ -54,23 +54,6 @@ def get_dot_product(a, b):
     """
     return sum(l1 * l2 for l1, l2 in zip(a, b))
 
-def get_cross_product(a, b):
-    """ calculate the cross product of two 3d vectors
-
-    @type a: tuple(float) | list(float) | pycam.Geometry.Point
-    @value a: the first vector to be multiplied
-    @type b: tuple(float) | list(float) | pycam.Geometry.Point
-    @value b: the second vector to be multiplied
-    @rtype: tuple(float)
-    @return: the cross product is a 3d vector
-    """
-    if isinstance(a, Point):
-        a = (a.x, a.y, a.z)
-    if isinstance(b, Point):
-        b = (b.x, b.y, b.z)
-    return (a[1] * b[2] - a[2] * b[1],
-            a[2] * b[0] - a[0] * b[2],
-            a[0] * b[1] - a[1] * b[0])
 
 def get_length(vector):
     """ calculate the lengt of a 3d vector
@@ -101,13 +84,10 @@ def get_rotation_matrix_from_to(v_orig, v_dest):
     @rtype: tuple(tuple(float))
     @return: the roation matrix (3x3)
     """
-    if isinstance(v_orig, Point):
-        v_orig = (v_orig.x, v_orig.y, v_orig.z)
-    if isinstance(v_dest, Point):
-        v_dest = (v_dest.x, v_dest.y, v_dest.z)
+
     v_orig_length = get_length(v_orig)
     v_dest_length = get_length(v_dest)
-    cross_product = get_length(get_cross_product(v_orig, v_dest))
+    cross_product = get_length(pcross(v_orig, v_dest))
     try:
         arcsin = cross_product / (v_orig_length * v_dest_length)
     except ZeroDivisionError:
@@ -121,9 +101,9 @@ def get_rotation_matrix_from_to(v_orig, v_dest):
     # calculate the rotation axis
     # The rotation axis is equal to the cross product of the original and
     # destination vectors.
-    rot_axis = Point(v_orig[1] * v_dest[2] - v_orig[2] * v_dest[1],
+    rot_axis = pnormalized((v_orig[1] * v_dest[2] - v_orig[2] * v_dest[1],
             v_orig[2] * v_dest[0] - v_orig[0] * v_dest[2],
-            v_orig[0] * v_dest[1] - v_orig[1] * v_dest[0]).normalized()
+            v_orig[0] * v_dest[1] - v_orig[1] * v_dest[0]))
     if not rot_axis:
         return None
     # get the rotation matrix
@@ -131,15 +111,15 @@ def get_rotation_matrix_from_to(v_orig, v_dest):
     c = math.cos(rot_angle)
     s = math.sin(rot_angle)
     t = 1 - c
-    return ((t * rot_axis.x * rot_axis.x + c,
-            t * rot_axis.x * rot_axis.y - s * rot_axis.z,
-            t * rot_axis.x * rot_axis.z + s * rot_axis.y),
-            (t * rot_axis.x * rot_axis.y + s * rot_axis.z,
-            t * rot_axis.y * rot_axis.y + c,
-            t * rot_axis.y * rot_axis.z - s * rot_axis.x),
-            (t * rot_axis.x * rot_axis.z - s * rot_axis.y,
-            t * rot_axis.y * rot_axis.z + s * rot_axis.x,
-            t * rot_axis.z * rot_axis.z + c))
+    return ((t * rot_axis[0] * rot_axis[0] + c,
+            t * rot_axis[0] * rot_axis[1] - s * rot_axis[2],
+            t * rot_axis[0] * rot_axis[2] + s * rot_axis[1]),
+            (t * rot_axis[0] * rot_axis[1] + s * rot_axis[2],
+            t * rot_axis[1] * rot_axis[1] + c,
+            t * rot_axis[1] * rot_axis[2] - s * rot_axis[0]),
+            (t * rot_axis[0] * rot_axis[2] - s * rot_axis[1],
+            t * rot_axis[1] * rot_axis[2] + s * rot_axis[0],
+            t * rot_axis[2] * rot_axis[2] + c))
 
 def get_rotation_matrix_axis_angle(rot_axis, rot_angle, use_radians=True):
     """ calculate rotation matrix for a normalized vector and an angle

pycam/Geometry/Model.py

@@ -31,7 +31,7 @@ from pycam.Geometry.Triangle import Triangle
 from pycam.Geometry.Line import Line
 from pycam.Geometry.Plane import Plane
 from pycam.Geometry.Polygon import Polygon
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.TriangleKdtree import TriangleKdtree
 from pycam.Geometry.Matrix import TRANSFORMATIONS
 from pycam.Toolpath import Bounds
@@ -324,7 +324,7 @@ class Model(BaseModel):
                 # Find all groups with the same direction (see 'normal') that
                 # share at least one edge with the current triangle.
                 touch_groups = []
-                if t.normal.z == 0:
+                if t.normal[2] == 0:
                     # ignore vertical triangles
                     continue
                 for group_index, group in enumerate(groups):
@@ -359,7 +359,7 @@ class ContourModel(BaseModel):
         self.name = "contourmodel%d" % self.id
         if plane is None:
             # the default plane points upwards along the z axis
-            plane = Plane(Point(0, 0, 0), Vector(0, 0, 1))
+            plane = Plane((0, 0, 0), (0, 0, 1, 'v'))
         self._plane = plane
         self._line_groups = []
         self._item_groups.append(self._line_groups)
@@ -804,7 +804,7 @@ class PolygonGroup(object):
         self.inner = inner_list
         self.callback = callback
         self.lines = outer.get_lines()
-        self.z_level = self.lines[0].p1.z
+        self.z_level = self.lines[0].p1[2]
         for poly in inner_list:
             self.lines.extend(poly.get_lines())
 
@@ -836,7 +836,7 @@ class PolygonGroup(object):
                     # create the backside plane
                     backside_points = []
                     for p in item.get_points():
-                        backside_points.insert(0, Point(p.x, p.y, self.z_level))
+                        backside_points.insert(0, (p[0], p[1], self.z_level))
                     triangle_optimizer.append(Triangle(*backside_points))
             if self.callback and self.callback():
                 return None
@@ -873,7 +873,7 @@ class PolygonGroup(object):
             # the contour points of the model will always be at level zero
             a[2] = self.z_level
             b[2] = self.z_level
-            return Line(Point(*a), Point(*b))
+            return Line(a, b)
         valid_indices = [index for index, p in enumerate(coords)
                 if not p[2] is None]
         none_indices = [index for index, p in enumerate(coords) if p[2] is None]
@@ -891,7 +891,7 @@ class PolygonGroup(object):
                         fan_points.append(cp)
                     final_points.append(cp)
                 else:
-                    final_points.append(Point(*coords[index]))
+                    final_points.append(coords[index])
             # check if the three fan_points are in line
             if len(fan_points) == 3:
                 fan_points.sort()
@@ -905,7 +905,7 @@ class PolygonGroup(object):
                 # is hardly possible, anyway.
                 for index in range(4):
                     if index in valid_indices:
-                        final_points.append(Point(*coords[index]))
+                        final_points.append(coords[index])
                     else:
                         probe_line = get_line(index - 1, index)
                         cp = self._get_closest_line_collision(probe_line)
@@ -913,7 +913,7 @@ class PolygonGroup(object):
             else:
                 for index in range(4):
                     if index in valid_indices:
-                        final_points.append(Point(*coords[index]))
+                        final_points.append(coords[index])
                     else:
                         if ((index + 1) % 4) in valid_indices:
                             other_index = index + 1
@@ -925,7 +925,7 @@ class PolygonGroup(object):
         elif valid_count == 3:
             for index in range(4):
                 if index in valid_indices:
-                    final_points.append(Point(*coords[index]))
+                    final_points.append(coords[index])
                 else:
                     # add two points
                     for other_index in (index - 1, index + 1):
@@ -933,7 +933,7 @@ class PolygonGroup(object):
                         cp = self._get_closest_line_collision(probe_line)
                         final_points.append(cp)
         else:
-            final_points.extend([Point(*coord) for coord in coords])
+            final_points.extend(coords)
         valid_points = []
         for p in final_points:
             if not (p is None) and not (p in valid_points):
@@ -970,17 +970,18 @@ class PolygonGroup(object):
         return grid
 
     def calculate_point_height(self, x, y, func):
-        point = Point(x, y, self.outer.minz)
+        point = (x, y, self.outer.minz)
         if not self.outer.is_point_inside(point):
             return None
         for poly in self.inner:
             if poly.is_point_inside(point):
                 return None
-        point = Point(x, y, self.outer.minz)
+        point = (x, y, self.outer.minz)
         line_distances = []
         for line in self.lines:
-            cross_product = line.dir.cross(point.sub(line.p1))
-            if cross_product.z > 0:
+            cross_product = pcross(line.dir, psub(point, line.p1))
+            #cross_product = line.dir.cross(point.sub(line.p1))
+            if cross_product[2] > 0:
                 close_points = []
                 close_point = line.closest_point(point)
                 if not line.is_point_inside(close_point):
@@ -989,8 +990,10 @@ class PolygonGroup(object):
                 else:
                     close_points.append(close_point)
                 for p in close_points:
-                    direction = point.sub(p)
-                    dist = direction.norm
+                    direction = psub(point, p)
+                    #direction = point.sub(p)
+                    dist = pnorm(direction)
+                    #dist = direction.norm
                     line_distances.append(dist)
             elif cross_product.z == 0:
                 # the point is on the line
@@ -1012,10 +1015,10 @@ class TriangleOptimizer(object):
 
     def append(self, triangle):
         # use a simple tuple instead of an object as the dict's key
-        normal_coords = triangle.normal.x, triangle.normal.y, triangle.normal.z
-        if not normal_coords in self.groups:
-            self.groups[normal_coords] = []
-        self.groups[normal_coords].append(triangle)
+        normal = triangle.normal
+        if not normal in self.groups:
+            self.groups[normal] = []
+        self.groups[normal].append(triangle)
 
     def optimize(self):
         for group in self.groups.values():
@@ -1068,7 +1071,8 @@ class Rectangle(IDGenerator, TransformableContainer):
             orders = ((p1, p2, p3, p4), (p1, p2, p4, p3), (p1, p3, p2, p4),
                     (p1, p3, p4, p2), (p1, p4, p2, p3), (p1, p4, p3, p2))
             for order in orders:
-                if abs(order[0].sub(order[2]).norm - order[1].sub(order[3]).norm) < epsilon:
+                #if abs(order[0].sub(order[2]).norm - order[1].sub(order[3]).norm) < epsilon:
+                if abs(pnorm(psub(order[0], order[2])) - pnorm(psub(order[1], order[3]))) < epsilon:
                     t1 = Triangle(order[0], order[1], order[2])
                     t2 = Triangle(order[2], order[3], order[0])
                     if t1.normal == t2.normal == normal:
@@ -1085,22 +1089,26 @@ class Rectangle(IDGenerator, TransformableContainer):
         self.reset_cache()
 
     def reset_cache(self):
-        self.maxx = max([p.x for p in self.get_points()])
-        self.minx = max([p.x for p in self.get_points()])
-        self.maxy = max([p.y for p in self.get_points()])
-        self.miny = max([p.y for p in self.get_points()])
-        self.maxz = max([p.z for p in self.get_points()])
-        self.minz = max([p.z for p in self.get_points()])
-        self.normal = Triangle(self.p1, self.p2, self.p3).normal.normalized()
+        self.maxx = max([p[0] for p in self.get_points()])
+        self.minx = max([p[0] for p in self.get_points()])
+        self.maxy = max([p[1] for p in self.get_points()])
+        self.miny = max([p[1] for p in self.get_points()])
+        self.maxz = max([p[2] for p in self.get_points()])
+        self.minz = max([p[2] for p in self.get_points()])
+        self.normal = pnormalized(Triangle(self.p1, self.p2, self.p3).normal)
 
     def get_points(self):
         return (self.p1, self.p2, self.p3, self.p4)
 
     def next(self):
-        yield self.p1
-        yield self.p2
-        yield self.p3
-        yield self.p4
+        #yield self.p1
+        #yield self.p2
+        #yield self.p3
+        #yield self.p4
+        yield "p1"
+        yield "p2"
+        yield "p3"
+        yield "p4"
 
     def __repr__(self):
         return "Rectangle%d<%s,%s,%s,%s>" % (self.id, self.p1, self.p2,
@@ -1132,8 +1140,8 @@ class Rectangle(IDGenerator, TransformableContainer):
         if len(unique_vertices) != 2:
             log.error("Invalid number of vertices: %s" % unique_vertices)
             return None
-        if abs(unique_vertices[0].sub(unique_vertices[1]).norm - \
-                shared_vertices[0].sub(shared_vertices[1]).norm) < epsilon:
+        if abs(pnorm(psub(unique_verticies[0], unique_verticies[1])) - pnorm(psub(shared_vertices[0], shared_vertices[1]))) < epsilon:
+        #if abs(unique_vertices[0].sub(unique_vertices[1]).norm - shared_vertices[0].sub(shared_vertices[1]).norm) < epsilon:
             try:
                 return Rectangle(unique_vertices[0], unique_vertices[1],
                         shared_vertices[0], shared_vertices[1],

pycam/Geometry/Plane.py

@@ -22,7 +22,8 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 from pycam.Geometry import TransformableContainer, IDGenerator
 from pycam.Geometry.utils import INFINITE, epsilon
-from pycam.Geometry.Point import Vector
+from pycam.Geometry.PointUtils import *
+
 # "Line" is imported later to avoid circular imports
 #from pycam.Geometry.Line import Line
 
@@ -34,11 +35,11 @@ class Plane(IDGenerator, TransformableContainer):
     def __init__(self, point, normal=None):
         super(Plane, self).__init__()
         if normal is None:
-            normal = Vector(0, 0, 1)
+            normal = (0, 0, 1, 'v')
         self.p = point
         self.n = normal
-        if not isinstance(self.n, Vector):
-            self.n = self.n.get_vector()
+        if not len(self.n) > 3:
+            self.n = (self.n[0], self.n[1], self.n[2], 'v')
 
     def __repr__(self):
         return "Plane<%s,%s>" % (self.p, self.n)
@@ -56,8 +57,8 @@ class Plane(IDGenerator, TransformableContainer):
         return self.__class__(self.p.copy(), self.n.copy())
 
     def next(self):
-        yield self.p
-        yield self.n
+        yield "p"
+        yield "n"
 
     def get_children_count(self):
         # a plane always consists of two points
@@ -65,21 +66,24 @@ class Plane(IDGenerator, TransformableContainer):
 
     def reset_cache(self):
         # we need to prevent the "normal" from growing
-        norm = self.n.normalized()
+        norm = pnormalized(self.n)
         if norm:
             self.n = norm
 
     def intersect_point(self, direction, point):
-        if (not direction is None) and (direction.norm != 1):
+        if (not direction is None) and (pnorm(direction) != 1):
             # calculations will go wrong, if the direction is not a unit vector
-            direction = direction.normalized()
+            direction = pnormalized(direction)
         if direction is None:
             return (None, INFINITE)
-        denom = self.n.dot(direction)
+        denom = pdot(self.n, direction)
+        #denom = self.n.dot(direction)
         if denom == 0:
             return (None, INFINITE)
-        l = -(self.n.dot(point) - self.n.dot(self.p)) / denom
-        cp = point.add(direction.mul(l))
+        l = -(pdot(self.n, point) - pdot(self.n, self.p)) / denom
+        #l = -(self.n.dot(point) - self.n.dot(self.p)) / denom
+        cp = padd(point, pmul(direction, l))
+        #cp = point.add(direction.mul(l))
         return (cp, l)
 
     def intersect_triangle(self, triangle, counter_clockwise=False):
@@ -101,7 +105,7 @@ class Plane(IDGenerator, TransformableContainer):
             # a distance that is lower than the length of the edge.
             if (not cp is None) and (-epsilon < l < edge.len - epsilon):
                 collisions.append(cp)
-            elif (cp is None) and (self.n.dot(edge.dir) == 0):
+            elif (cp is None) and (pdot(self.n, edge.dir) == 0):
                 cp, dist = self.intersect_point(self.n, point)
                 if abs(dist) < epsilon:
                     # the edge is on the plane
@@ -116,8 +120,10 @@ class Plane(IDGenerator, TransformableContainer):
             # no further calculation, if the line is zero-sized
             if collision_line.len == 0:
                 return collision_line
-            cross = self.n.cross(collision_line.dir)
-            if (cross.dot(triangle.normal) < 0) == bool(not counter_clockwise):
+            cross = pcross(self.n, collision_line.dir)
+            #cross = self.n.cross(collision_line.dir)
+            #if (cross.dot(triangle.normal) < 0) == bool(not counter_clockwise):
+            if (pdot(cross, triangle.normal) < 0) == bool(not counter_clockwise):
                 # anti-clockwise direction -> revert the direction of the line
                 collision_line = Line(collision_line.p2, collision_line.p1)
             return collision_line

pycam/Geometry/Point.py

-# -*- coding: utf-8 -*-
-"""
-$Id$
-
-Copyright 2010 Lars Kruse <devel@sumpfralle.de>
-Copyright 2008-2009 Lode Leroy
-
-This file is part of PyCAM.
-
-PyCAM 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.
-
-PyCAM 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 PyCAM.  If not, see <http://www.gnu.org/licenses/>.
-"""
-
-from pycam.Geometry.utils import epsilon, sqrt, number
-from pycam.Geometry import IDGenerator
-
-
-def _is_near(x, y):
-    return abs(x - y) < epsilon
-
-
-class Point(IDGenerator):
-
-    __slots__ = ["id", "x", "y", "z", "_norm", "_normsq"]
-
-    def __init__(self, x, y, z):
-        super(Point, self).__init__()
-        self.x = number(x)
-        self.y = number(y)
-        self.z = number(z)
-        self.reset_cache()
-
-    @property
-    def norm(self):
-        if self._norm is None:
-            self._norm = sqrt(self.normsq)
-        return self._norm
-
-    @property
-    def normsq(self):
-        if self._normsq is None:
-            self._normsq = self.dot(self)
-        return self._normsq
-
-    def copy(self):
-        return self.__class__(float(self.x), float(self.y), float(self.z))
-
-    def __repr__(self):
-        return "Point%d<%g,%g,%g>" % (self.id, self.x, self.y, self.z)
-
-    def __cmp__(self, other):
-        """ Two points are equal if all dimensions are identical.
-        Otherwise the result is based on the individual x/y/z comparisons.
-        """
-        if self.__class__ == other.__class__:
-            if (self.id == other.id) or \
-                    ((_is_near(self.x, other.x)) and \
-                        (_is_near(self.y, other.y)) and \
-                        (_is_near(self.z, other.z))):
-                return 0
-            elif not _is_near(self.x, other.x):
-                return cmp(self.x, other.x)
-            elif not _is_near(self.y, other.y):
-                return cmp(self.y, other.y)
-            else:
-                return cmp(self.z, other.z)
-        else:
-            return cmp(str(self), str(other))
-
-    def transform_by_matrix(self, matrix, transformed_list=None, callback=None):
-        # accept 3x4 matrices as well as 3x3 matrices
-        offsets = []
-        for column in matrix:
-            if len(column) < 4:
-                offsets.append(0)
-            else:
-                offsets.append(column[3])
-        x = self.x * matrix[0][0] + self.y * matrix[0][1] \
-                + self.z * matrix[0][2] + offsets[0]
-        y = self.x * matrix[1][0] + self.y * matrix[1][1] \
-                + self.z * matrix[1][2] + offsets[1]
-        z = self.x * matrix[2][0] + self.y * matrix[2][1] \
-                + self.z * matrix[2][2] + offsets[2]
-        self.x = x
-        self.y = y
-        self.z = z
-        if callback:
-            callback()
-        self.reset_cache()
-
-    def reset_cache(self):
-        self._norm = None
-        self._normsq = None
-        
-    def mul(self, c):
-        c = number(c)
-        return Point(self.x * c, self.y * c, self.z * c)
-
-    def div(self, c):
-        c = number(c)
-        return Point(self.x / c, self.y / c, self.z / c)
-
-    def add(self, p):
-        return Point(self.x + p.x, self.y + p.y, self.z + p.z)
-
-    def sub(self, p):
-        return Point(self.x - p.x, self.y - p.y, self.z - p.z)
-
-    def dot(self, p):
-        return self.x * p.x + self.y * p.y + self.z * p.z
-
-    def cross(self, p):
-        return Point(self.y * p.z - p.y * self.z, p.x * self.z - self.x * p.z,
-                self.x * p.y - p.x * self.y)
-
-    def normalized(self):
-        n = self.norm
-        if n == 0:
-            return None
-        else:
-            return self.__class__(self.x / n, self.y / n, self.z / n)
-
-    def is_inside(self, minx=None, maxx=None, miny=None, maxy=None, minz=None,
-            maxz=None):
-        return ((minx is None) or (minx - epsilon <= self.x)) \
-                and ((maxx is None) or (self.x <= maxx + epsilon)) \
-                and ((miny is None) or (miny - epsilon <= self.y)) \
-                and ((maxy is None) or (self.y <= maxy + epsilon)) \
-                and ((minz is None) or (minz - epsilon <= self.z)) \
-                and ((maxz is None) or (self.z <= maxz + epsilon))
-
-    def get_vector(self):
-        return Vector(self.x, self.y, self.z)
-
-
-class Vector(Point):
-    """ The Vector class is similar to the Point class. The only difference
-    is that vectors are not shifted during transformations. This feature
-    is necessary for normals (e.g. of Triangles or Planes).
-    """
-
-    __slots__ = []
-
-    def transform_by_matrix(self, matrix, transformed_list=None, callback=None):
-        x = self.x * matrix[0][0] + self.y * matrix[0][1] \
-                + self.z * matrix[0][2]
-        y = self.x * matrix[1][0] + self.y * matrix[1][1] \
-                + self.z * matrix[1][2]
-        z = self.x * matrix[2][0] + self.y * matrix[2][1] \
-                + self.z * matrix[2][2]
-        self.x = x
-        self.y = y
-        self.z = z
-        if callback:
-            callback()
-        self.reset_cache()
-
-    def __repr__(self):
-        return "Vector%d<%g,%g,%g>" % (self.id, self.x, self.y, self.z)
-

pycam/Geometry/PointKdtree.py

@@ -21,7 +21,6 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 from pycam.Geometry.utils import epsilon
-from pycam.Geometry.Point import Point
 from pycam.Geometry.kdtree import Node, kdtree
 
 
@@ -37,7 +36,7 @@ class PointKdtree(kdtree):
         self.tolerance = tolerance
         nodes = []
         for p in points:
-            n = Node(p, (p.x, p.y, p.z))
+            n = Node(p, p)
             nodes.append(n)
         kdtree.__init__(self, nodes, cutoff, cutoff_distance)
 
@@ -59,7 +58,7 @@ class PointKdtree(kdtree):
             self._n = n
             return nn.obj
         else:
-            n.obj = Point(x, y, z)
+            n.obj = (x, y, z)
             self._n = None
             self.insert(n)
             return n.obj

pycam/Geometry/PointUtils.py

+# -*- coding: utf-8 -*-
+"""
+$Id$
+
+Copyright 2010 Lars Kruse <devel@sumpfralle.de>
+Copyright 2008-2009 Lode Leroy
+
+This file is part of PyCAM.
+
+PyCAM 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.
+
+PyCAM 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 PyCAM.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+from pycam.Geometry.utils import epsilon, sqrt, number
+
+def _is_near(x, y):
+    return abs(x - y) < epsilon
+
+def pnorm(a):
+    return sqrt(pdot(a,a))
+
+def pnormsq(a):
+    return pdot(a,a)
+
+def pcmp(a,b):
+    """ Two points are equal if all dimensions are identical.
+    Otherwise the result is based on the individual x/y/z comparisons.
+    """
+    if (_is_near(a[0], b[0]) and _is_near(a[1], b[1]) and _is_near(a[2], b[2])):
+        return 0
+    elif not _is_near(a[0], b[0]):
+        return cmp(a[0], b[0])
+    elif not _is_near(a[1], b[1]):
+        return cmp(a[1], b[1])
+    else:
+        return cmp(a[2], b[2])
+
+def ptransform_by_matrix(a, matrix, transformed_list=None):
+    if len(a) > 3:
+        return (a[0] * matrix[0][0] + a[1] * matrix[0][1] + a[2] * matrix[0][2],
+                a[0] * matrix[1][0] + a[1] * matrix[1][1] + a[2] * matrix[1][2],
+                a[0] * matrix[2][0] + a[1] * matrix[2][1] + a[2] * matrix[2][2]) + a[3:]
+    else:
+        # accept 3x4 matrices as well as 3x3 matrices
+        offsets = []
+        for column in matrix:
+            if len(column) < 4:
+                offsets.append(0)
+            else:
+                offsets.append(column[3])
+        
+        return (a[0] * matrix[0][0] + a[1] * matrix[0][1] + a[2] * matrix[0][2] + offsets[0],
+                a[0] * matrix[1][0] + a[1] * matrix[1][1] + a[2] * matrix[1][2] + offsets[1],
+                a[0] * matrix[2][0] + a[1] * matrix[2][1] + a[2] * matrix[2][2] + offsets[2])
+    
+
+        
+def pmul(a, c):
+    c = number(c)
+    return (a[0] * c, a[1] * c, a[2] * c)
+
+def pdiv(a, c):
+    c = number(c)
+    return (a[0] / c, a[0] / c, a[0] / c)
+
+def padd(a, b):
+    return (a[0] + b[0], a[1] + b[1], a[2] + b[2])
+
+def psub(a, b):
+    return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
+
+def pdot(a, b):
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+def pcross(a, b):
+    return (a[1] * b[2] - b[1] * a[2], b[0] * a[2] - a[0] * b[2], a[0] * b[1] - b[0] * a[1])
+
+def pnormalized(a):
+    n = pnorm(a)
+    if n == 0:
+        return None
+    else:
+        return (a[0] / n, a[1] / n, a[2] / n) + a[3:]
+
+def pis_inside(a, minx=None, maxx=None, miny=None, maxy=None, minz=None, maxz=None):
+    return ((minx is None) or (minx - epsilon <= a[0])) \
+            and ((maxx is None) or (a[0] <= maxx + epsilon)) \
+            and ((miny is None) or (miny - epsilon <= a[1])) \
+            and ((maxy is None) or (a[1] <= maxy + epsilon)) \
+            and ((minz is None) or (minz - epsilon <= a[2])) \
+            and ((maxz is None) or (a[2] <= maxz + epsilon))

pycam/Geometry/TriangleKdtree.py

@@ -79,10 +79,10 @@ class TriangleKdtree(kdtree):
     def __init__(self, triangles, cutoff=3, cutoff_distance=1.0):
         nodes = []
         for t in triangles:
-            n = Node(t, (min(t.p1.x, t.p2.x, t.p3.x),
-                    max(t.p1.x, t.p2.x, t.p3.x),
-                    min(t.p1.y, t.p2.y, t.p3.y),
-                    max(t.p1.y, t.p2.y, t.p3.y)))
+            n = Node(t, (min(t.p1[0], t.p2[0], t.p3[0]),
+                    max(t.p1[0], t.p2[0], t.p3[0]),
+                    min(t.p1[1], t.p2[1], t.p3[1]),
+                    max(t.p1[1], t.p2[1], t.p3[1])))
             nodes.append(n)
         super(TriangleKdtree, self).__init__(nodes, cutoff, cutoff_distance)
 

pycam/Geometry/__init__.py

@@ -21,11 +21,15 @@ You should have received a copy of the GNU General Public License
 along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-__all__ = ["utils", "Line", "Model", "Path", "Plane", "Point", "Triangle",
+__all__ = ["utils", "Line", "Model", "Path", "Plane", "Triangle",
            "PolygonExtractor", "TriangleKdtree", "intersection", "kdtree",
-           "Matrix", "Polygon", "Letters"]
+           "Matrix", "Polygon", "Letters", "PointUtils"]
 
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.utils import epsilon, ceil
+from pycam.Utils import log
+import types
+log = log.get_logger()
 import math
 
 
@@ -33,17 +37,24 @@ def get_bisector(p1, p2, p3, up_vector):
     """ Calculate the bisector between p1, p2 and p3, whereas p2 is the origin
     of the angle.
     """
-    d1 = p2.sub(p1).normalized()
-    d2 = p2.sub(p3).normalized()
-    bisector_dir = d1.add(d2).normalized()
+    d1 = pnormalized(psub(p2, p1))
+    #d1 = p2.sub(p1).normalized()
+    d2 = pnormalized(psub(p2, p3))
+    #d2 = p2.sub(p3).normalized()
+    bisector_dir = pnormalized(padd(d1, d2))
+    #bisector_dir = d1.add(d2).normalized()
     if bisector_dir is None:
         # the two vectors pointed to opposite directions
-        bisector_dir = d1.cross(up_vector).normalized()
+        bisector_dir = pnormalized(pcross(d1, up_vector))
+        #bisector_dir = d1.cross(up_vector).normalized()
     else:
-        skel_up_vector = bisector_dir.cross(p2.sub(p1))
-        if up_vector.dot(skel_up_vector) < 0:
+        skel_up_vector = pcross(bisector_dir, psub(p2, p1))
+        #skel_up_vector = bisector_dir.cross(p2.sub(p1))
+        #if up_vector.dot(skel_up_vector) < 0:
+        if pdot(up_vector, skel_up_vector) < 0:
             # reverse the skeleton vector to point outwards
-            bisector_dir = bisector_dir.mul(-1)
+            bisector_dir = pmul(bisector_dir, -1)
+            #bisector_dir = bisector_dir.mul(-1)
     return bisector_dir
 
 def get_angle_pi(p1, p2, p3, up_vector, pi_factor=False):
@@ -57,20 +68,22 @@ def get_angle_pi(p1, p2, p3, up_vector, pi_factor=False):
       p2--------p1
     The result is in a range between 0 and 2*PI.
     """
-    d1 = p2.sub(p1).normalized()
-    d2 = p2.sub(p3).normalized()
+    d1 = pnormalized(psub(p2, p1))
+    #d1 = p2.sub(p1).normalized()
+    d2 = pnormalized(psub(p2, p3))
+    #d2 = p2.sub(p3).normalized()
     if (d1 is None) or (d2 is None):
         return 2 * math.pi
-    angle = math.acos(d1.dot(d2))
+    angle = math.acos(pdot(d1, d2))
+    #angle = math.acos(d1.dot(d2))
     # check the direction of the points (clockwise/anti)
     # The code is taken from Polygon.get_area
     value = [0, 0, 0]
     for (pa, pb) in ((p1, p2), (p2, p3), (p3, p1)):
-        value[0] += pa.y * pb.z - pa.z * pb.y
-        value[1] += pa.z * pb.x - pa.x * pb.z
-        value[2] += pa.x * pb.y - pa.y * pb.x
-    area = up_vector.x * value[0] + up_vector.y * value[1] \
-            + up_vector.z * value[2]
+        value[0] += pa[1] * pb[2] - pa[2] * pb[1]
+        value[1] += pa[2] * pb[0] - pa[0] * pb[2]
+        value[2] += pa[0] * pb[1] - pa[1] * pb[0]
+    area = up_vector[0] * value[0] + up_vector[1] * value[1] + up_vector[2] * value[2]
     if area > 0:
         # The points are in anti-clockwise order. Thus the angle is greater
         # than 180 degree.
@@ -113,8 +126,8 @@ def get_points_of_arc(center, radius, a1, a2, plane=None, cords=32):
     angle_segment = angle_diff / num_of_segments
     points = []
     get_angle_point = lambda angle: (
-            center.x + radius * math.cos(angle),
-            center.y + radius * math.sin(angle))
+            center[0] + radius * math.cos(angle),
+            center[1] + radius * math.sin(angle))
     points.append(get_angle_point(a1))
     for index in range(num_of_segments):
         points.append(get_angle_point(a1 + angle_segment * (index + 1)))
@@ -131,23 +144,24 @@ def get_bezier_lines(points_with_bulge, segments=32):
         if not bulge1 and not bulge2:
             # straight line
             return [Line.Line(p1, p2)]
-        straight_dir = p2.sub(p1).normalized()
+        straight_dir = pnormalized(psub(p2, p1))
+        #straight_dir = p2.sub(p1).normalized()
         #bulge1 = max(-1.0, min(1.0, bulge1))
         bulge1 = math.atan(bulge1)
         rot_matrix = Matrix.get_rotation_matrix_axis_angle((0, 0, 1),
                 -2 * bulge1, use_radians=True)
-        dir1_mat = Matrix.multiply_vector_matrix((straight_dir.x,
-                straight_dir.y, straight_dir.z), rot_matrix)
-        dir1 = Point.Vector(dir1_mat[0], dir1_mat[1], dir1_mat[2])
+        dir1_mat = Matrix.multiply_vector_matrix((straight_dir[0],
+                straight_dir[1], straight_dir[2]), rot_matrix)
+        dir1 = (dir1_mat[0], dir1_mat[1], dir1_mat[2], 'v')
         if bulge2 is None:
             bulge2 = bulge1
         else:
             bulge2 = math.atan(bulge2)
         rot_matrix = Matrix.get_rotation_matrix_axis_angle((0, 0, 1),
                 2 * bulge2, use_radians=True)
-        dir2_mat = Matrix.multiply_vector_matrix((straight_dir.x,
-                straight_dir.y, straight_dir.z), rot_matrix)
-        dir2 = Point.Vector(dir2_mat[0], dir2_mat[1], dir2_mat[2])
+        dir2_mat = Matrix.multiply_vector_matrix((straight_dir[0],
+                straight_dir[1], straight_dir[2]), rot_matrix)
+        dir2 = (dir2_mat[0], dir2_mat[1], dir2_mat[2], 'v')
         # interpretation of bulge1 and bulge2:
         # /// taken from http://paulbourke.net/dataformats/dxf/dxf10.html ///
         # The bulge is the tangent of 1/4 the included angle for an arc
@@ -155,7 +169,8 @@ def get_bezier_lines(points_with_bulge, segments=32):
         # point to the end point; a bulge of 0 indicates a straight segment,
         # and a bulge of 1 is a semicircle.
         alpha = 2 * (abs(bulge1) + abs(bulge2))
-        dist = p2.sub(p1).norm
+        dist = pnorm(psub(p2, p1))
+        #dist = p2.sub(p1).norm
         # calculate the radius of the circumcircle - avoiding divide-by-zero
         if (abs(alpha) < epsilon) or (abs(math.pi - alpha) < epsilon):
             radius = dist / 2.0
@@ -165,16 +180,22 @@ def get_bezier_lines(points_with_bulge, segments=32):
         # The calculation of "factor" is based on random guessing - but it
         # seems to work well.
         factor = 4 * radius * math.tan(alpha / 4.0)
-        dir1 = dir1.mul(factor)
-        dir2 = dir2.mul(factor)
+        dir1 = pmul(dir1, factor)
+        #dir1 = dir1.mul(factor)
+        dir2 = pmul(dir2, factor)
+        #dir2 = dir2.mul(factor)
         for index in range(segments + 1):
             # t: 0..1
             t = float(index) / segments
             # see: http://en.wikipedia.org/wiki/Cubic_Hermite_spline
-            p = p1.mul(2 * t ** 3 - 3 * t ** 2 + 1).add(
-                    dir1.mul(t ** 3 - 2 * t ** 2 + t).add(
-                    p2.mul(-2 * t ** 3 + 3 * t ** 2).add(
-                    dir2.mul(t ** 3 - t ** 2))))
+            #p = p1.mul(2 * t ** 3 - 3 * t ** 2 + 1).add(
+            #    dir1.mul(t ** 3 - 2 * t ** 2 + t).add(
+            #        p2.mul(-2 * t ** 3 + 3 * t ** 2).add(
+            #            dir2.mul(t ** 3 - t ** 2)
+            #        )
+            #    )
+            #)
+            p = padd( pmul(p1, 2 * t ** 3 - 3 * t ** 2 + 1) ,padd( pmul(dir1, t ** 3 - 2 * t ** 2 + t), padd(pmul(p2, -2 * t ** 3 + 3 * t ** 2) ,pmul(dir2, t ** 3 - t ** 2))))
             result_points.append(p)
         # create lines
         result = []
@@ -232,15 +253,23 @@ class TransformableContainer(object):
         # Use the 'id' builtin to prevent expensive object comparions.
         for item in self.next():
             if isinstance(item, TransformableContainer):
-                item.transform_by_matrix(matrix, transformed_list,
-                        callback=callback)
+                item.transform_by_matrix(matrix, transformed_list,callback=callback)
             elif not id(item) in transformed_list:
                 # non-TransformableContainer do not care to update the
                 # 'transformed_list'. Thus we need to do it.
-                transformed_list.append(id(item))
+                #transformed_list.append(id(item))
                 # Don't transmit the 'transformed_list' if the object is
                 # not a TransformableContainer. It is not necessary and it
                 # is hard to understand on the lowest level (e.g. Point).
+                if isinstance(item, str):
+                    theval = getattr(self, item)
+                    if isinstance(theval, tuple):
+                        setattr(self, item, ptransform_by_matrix(theval, matrix))
+                    elif isinstance(theval, list):
+                        setattr(self, item, [ptransform_by_matrix(x, matrix) for x in theval])
+                elif isinstance(item, tuple):
+                    log.error("ERROR!! A tuple (Point, Vector) made it into base transform_by_matrix without a back reference. Point/Vector remains unchanged.")
+                else:
                     item.transform_by_matrix(matrix, callback=callback)
             # run the callback - e.g. for a progress counter
             if callback and callback():

pycam/Gui/OpenGLTools.py

@@ -20,7 +20,7 @@ You should have received a copy of the GNU General Public License
 along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.utils import sqrt
 
 # careful import
@@ -56,37 +56,37 @@ def keep_matrix(func):
 @keep_matrix
 def draw_direction_cone(p1, p2, position=0.5, precision=12, size=0.1):
     # convert p1 and p2 from list/tuple to Point
-    if not hasattr(p1, "sub"):
-        p1 = Point(*p1)
-    if not hasattr(p2, "sub"):
-        p2 = Point(*p2)
-    distance = p2.sub(p1)
-    length = distance.norm
-    direction = distance.normalized()
+    distance = psub(p2, p1)
+    #distance = p2.sub(p1)
+    length = pnorm(distance)
+    direction = pnormalized(distance)
+    #direction = distance.normalized()
     if direction is None:
         # zero-length line
         return
     cone_length = length * size
     cone_radius = cone_length / 3.0
     # move the cone to the middle of the line
-    GL.glTranslatef((p1.x + p2.x) * position,
-            (p1.y + p2.y) * position, (p1.z + p2.z) * position)
+    GL.glTranslatef((p1[0] + p2[0]) * position,
+            (p1[1] + p2[1]) * position, (p1[2] + p2[2]) * position)
     # rotate the cone according to the line direction
     # The cross product is a good rotation axis.
-    cross = direction.cross(Point(0, 0, -1))
-    if cross.norm != 0:
+    cross = pcross(direction, (0, 0, -1))
+    #cross = direction.cross(Point(0, 0, -1))
+    #if cross.norm != 0:
+    if pnorm(cross) != 0:
         # The line direction is not in line with the z axis.
         try:
-            angle = math.asin(sqrt(direction.x ** 2 + direction.y ** 2))
+            angle = math.asin(sqrt(direction[0] ** 2 + direction[1] ** 2))
         except ValueError:
             # invalid angle - just ignore this cone
             return
         # convert from radians to degree
         angle = angle / math.pi * 180
-        if direction.z < 0:
+        if direction[2] < 0:
             angle = 180 - angle
-        GL.glRotatef(angle, cross.x, cross.y, cross.z)
-    elif direction.z == -1:
+        GL.glRotatef(angle, cross[0], cross[1], cross[2])
+    elif direction[2] == -1:
         # The line goes down the z axis - turn it around.
         GL.glRotatef(180, 1, 0, 0)
     else:

pycam/Importers/CXFImporter.py

@@ -22,7 +22,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 from pycam.Geometry.Letters import Charset
 from pycam.Geometry.Line import Line
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry import get_points_of_arc
 import pycam.Utils.log
 import pycam.Utils
@@ -144,13 +144,13 @@ class CXFParser(object):
                     type_char = line[0].upper()
                     if (type_def == "L") and (len(coords) == 4):
                         # line
-                        p1 = Point(coords[0], coords[1], 0)
-                        p2 = Point(coords[2], coords[3], 0)
+                        p1 = (coords[0], coords[1], 0)
+                        p2 = (coords[2], coords[3], 0)
                         char_definition.append(Line(p1, p2))
                     elif (type_def in ("A", "AR")) and (len(coords) == 5):
                         # arc
                         previous = None
-                        center = Point(coords[0], coords[1], 0)
+                        center = (coords[0], coords[1], 0)
                         radius = coords[2]
                         start_angle, end_angle = coords[3], coords[4]
                         if type_def == "AR":
@@ -158,7 +158,7 @@ class CXFParser(object):
                             start_angle, end_angle = end_angle, start_angle
                         for p in get_points_of_arc(center, radius, start_angle,
                                 end_angle):
-                            current = Point(p[0], p[1], 0)
+                            current = (p[0], p[1], 0)
                             if not previous is None:
                                 char_definition.append(Line(previous, current))
                             previous = current

pycam/Importers/DXFImporter.py

@@ -21,7 +21,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 from pycam.Geometry.Triangle import Triangle
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Line import Line
 import pycam.Geometry.Model
 import pycam.Geometry.Matrix
@@ -142,8 +142,10 @@ class DXFParser(object):
                     current_group = []
                     groups.append(current_group)
         def get_distance_between_groups(group1, group2):
-            forward = group1[-1].p2.sub(group2[0].p1).norm
-            backward = group2[-1].p2.sub(group1[0].p1).norm
+            forward = pnorm(psub(group1[-1].p2, group2[0].p1))
+            #forward = group1[-1].p2.sub(group2[0].p1).norm
+            backward = pnorm(psub(group2[-1].p2, group1[0].p1))
+            #backward = group2[-1].p2.sub(group1[0].p1).norm
             return min(forward, backward)
         remaining_groups = groups[:]
         ordered_groups = []
@@ -305,7 +307,7 @@ class DXFParser(object):
                     "between line %d and %d" % (start_line, end_line))
         else:
             self._open_sequence_items.append(
-                    (Point(point[0], point[1], point[2]), bulge))
+                    ((point[0], point[1], point[2]), bulge))
 
     def parse_polyline(self, init):
         start_line = self.line_number
@@ -358,7 +360,7 @@ class DXFParser(object):
                                 "date in line %d: %s" % \
                                 (self.line_number, p_array))
                     p_array[index] = 0
-            points.append((Point(p_array[0], p_array[1], p_array[2]), bulge))
+            points.append(((p_array[0], p_array[1], p_array[2]), bulge))
         current_point = [None, None, None]
         bulge = None
         extra_vertex_flag = False
@@ -755,15 +757,15 @@ class DXFParser(object):
                     + "%d and %d" % (start_line, end_line))
         else:
             # no color height adjustment for 3DFACE
-            point1 = Point(p1[0], p1[1], p1[2])
-            point2 = Point(p2[0], p2[1], p2[2])
-            point3 = Point(p3[0], p3[1], p3[2])
+            point1 = (p1[0], p1[1], p1[2])
+            point2 = (p2[0], p2[1], p2[2])
+            point3 = (p3[0], p3[1], p3[2])
             triangles = []
             triangles.append((point1, point2, point3))
             # DXF specifies, that p3=p4 if triangles (instead of quads) are
             # written.
             if (not None in p4) and (p3 != p4):
-                point4 = Point(p4[0], p4[1], p4[2])
+                point4 = (p4[0], p4[1], p4[2])
                 triangles.append((point3, point4, point1))
             for t in triangles:
                 if (t[0] != t[1]) and (t[0] != t[2]) and (t[1] != t[2]):
@@ -811,7 +813,7 @@ class DXFParser(object):
                 # use the color code as the z coordinate
                 p1[2] = float(color) / 255
                 p2[2] = float(color) / 255
-            line = Line(Point(p1[0], p1[1], p1[2]), Point(p2[0], p2[1], p2[2]))
+            line = Line((p1[0], p1[1], p1[2]), (p2[0], p2[1], p2[2]))
             if line.p1 != line.p2:
                 self.lines.append(line)
             else:
@@ -862,7 +864,7 @@ class DXFParser(object):
             if self._color_as_height and (not color is None):
                 # use the color code as the z coordinate
                 center[2] = float(color) / 255
-            center = Point(center[0], center[1], center[2])
+            center = (center[0], center[1], center[2])
             xy_point_coords = pycam.Geometry.get_points_of_arc(center, radius,
                     angle_start, angle_end)
             # Somehow the order of points seems to be the opposite of what is
@@ -871,9 +873,9 @@ class DXFParser(object):
             if len(xy_point_coords) > 1:
                 for index in range(len(xy_point_coords) - 1):
                     p1 = xy_point_coords[index]
-                    p1 = Point(p1[0], p1[1], center.z)
+                    p1 = (p1[0], p1[1], center[2])
                     p2 = xy_point_coords[index + 1]
-                    p2 = Point(p2[0], p2[1], center.z)
+                    p2 = (p2[0], p2[1], center[2])
                     if p1 != p2:
                         self.lines.append(Line(p1, p2))
             else:

pycam/Importers/STLImporter.py

@@ -21,7 +21,7 @@ You should have received a copy of the GNU General Public License
 along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Triangle import Triangle
 from pycam.Geometry.PointKdtree import PointKdtree
 from pycam.Geometry.utils import epsilon
@@ -40,17 +40,17 @@ vertices = 0
 edges = 0
 kdtree = None
 
+lastUniqueVertex = (None,None,None)
 def UniqueVertex(x, y, z):
-    global vertices
+    global vertices,lastUniqueVertex
     if kdtree:
-        last = Point.id
         p = kdtree.Point(x, y, z)
-        if p.id == last:
+        if p == lastUniqueVertex:
             vertices += 1
         return p
     else:
         vertices += 1
-        return Point(x, y, z)
+        return (x, y, z)
 
 def ImportModel(filename, use_kdtree=True, callback=None, **kwargs):
     global vertices, edges, kdtree
@@ -127,7 +127,7 @@ def ImportModel(filename, use_kdtree=True, callback=None, **kwargs):
             a2 = unpack("<f", f.read(4))[0] 
             a3 = unpack("<f", f.read(4))[0] 
 
-            n = Vector(float(a1), float(a2), float(a3))
+            n = (float(a1), float(a2), float(a3), 'v')
             
             v11 = unpack("<f", f.read(4))[0] 
             v12 = unpack("<f", f.read(4))[0] 
@@ -150,9 +150,11 @@ def ImportModel(filename, use_kdtree=True, callback=None, **kwargs):
             # not used
             attribs = unpack("<H", f.read(2)) 
             
-            dotcross = n.dot(p2.sub(p1).cross(p3.sub(p1)))
+            dotcross = pdot(n, pcross(psub(p2, p1), psub(p3, p1)))
+            #dotcross = n.dot(p2.sub(p1).cross(p3.sub(p1)))
             if a1 == a2 == a3 == 0:
-                dotcross = p2.sub(p1).cross(p3.sub(p1)).z
+                dotcross = pcross(psub(p2, p1), psub(p3,p1))[2]
+                #dotcross = p2.sub(p1).cross(p3.sub(p1)).z
                 n = None
 
             if dotcross > 0:
@@ -209,8 +211,7 @@ def ImportModel(filename, use_kdtree=True, callback=None, **kwargs):
             if m:
                 m = normal.match(line)
                 if m:
-                    n = Vector(float(m.group('x')), float(m.group('y')),
-                            float(m.group('z')))
+                    n = (float(m.group('x')), float(m.group('y')), float(m.group('z')), 'v')
                 else:
                     n = None
                 continue
@@ -243,7 +244,8 @@ def ImportModel(filename, use_kdtree=True, callback=None, **kwargs):
                     n, p1, p2, p3 = None, None, None, None
                     continue
                 if not n:
-                    n = p2.sub(p1).cross(p3.sub(p1)).normalized()
+                    n = pnormalized(pcross(psub(p2, p1), psub(p3, p1)))
+                    #n = p2.sub(p1).cross(p3.sub(p1)).normalized()
 
                 # validate the normal
                 # The three vertices of a triangle in an STL file are supposed
@@ -254,7 +256,8 @@ def ImportModel(filename, use_kdtree=True, callback=None, **kwargs):
                     dotcross = 0
                 else:
                     # make sure the points are in ClockWise order
-                    dotcross = n.dot(p2.sub(p1).cross(p3.sub(p1)))
+                    dotcross = pdot(n, pcross(psub(p2,p1), psub(p3, p1)))
+                    #dotcross = n.dot(p2.sub(p1).cross(p3.sub(p1)))
                 if dotcross > 0:
                     # Triangle expects the vertices in clockwise order
                     t = Triangle(p1, p3, p2, n)

pycam/Importers/TestModel.py

@@ -22,22 +22,21 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 from pycam.Geometry.Triangle import Triangle
 from pycam.Geometry.Line import Line
-from pycam.Geometry.Point import Point
 from pycam.Geometry.Model import Model
 
 
 def get_test_model():
     points = []
-    points.append(Point(-2, 1, 4))
-    points.append(Point(2, 1, 4))
-    points.append(Point(0, -2, 4))
-    points.append(Point(-5, 2, 2))
-    points.append(Point(-1, 3, 2))
-    points.append(Point(5, 2, 2))
-    points.append(Point(4, -1, 2))
-    points.append(Point(2, -4, 2))
-    points.append(Point(-2, -4, 2))
-    points.append(Point(-3, -2, 2))
+    points.append((-2, 1, 4))
+    points.append((2, 1, 4))
+    points.append((0, -2, 4))
+    points.append((-5, 2, 2))
+    points.append((-1, 3, 2))
+    points.append((5, 2, 2))
+    points.append((4, -1, 2))
+    points.append((2, -4, 2))
+    points.append((-2, -4, 2))
+    points.append((-3, -2, 2))
 
     lines = []
     lines.append(Line(points[0], points[1]))

pycam/PathGenerators/ContourFollow.py

@@ -23,7 +23,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 # take a look at the related blog posting describing this algorithm:
 # http://fab.senselab.org/node/43
 
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Line import Line
 from pycam.Geometry.Plane import Plane
 from pycam.PathGenerators import get_free_paths_ode, get_free_paths_triangles
@@ -50,7 +50,8 @@ def _process_one_triangle((model, cutter, up_vector, triangle, z)):
         # Case 1a
         return result, None
     # ignore triangles pointing upwards or downwards
-    if triangle.normal.cross(up_vector).norm == 0:
+    #if triangle.normal.cross(up_vector).norm == 0:
+    if pnorm(pcross(triangle.normal, up_vector)) == 0:
         # Case 1b
         return result, None
     edge_collisions = get_collision_waterline_of_triangle(model, cutter,
@@ -197,7 +198,7 @@ class ContourFollow(object):
 
     def __init__(self, path_processor, physics=None):
         self.pa = path_processor
-        self._up_vector = Vector(0, 0, 1)
+        self._up_vector = (0, 0, 1, 'v')
         self.physics = physics
         self._processed_triangles = []
         if self.physics:
@@ -343,13 +344,15 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
             for index in range(3):
                 edge = Line(proj_points[index - 1], proj_points[index])
                 # the edge should be clockwise around the model
-                if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                #if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                if pdot(pcross(edge.dir, triangle.normal), up_vector) < 0:
                     edge = Line(edge.p2, edge.p1)
                 edges.append((edge, proj_points[index - 2]))
             outer_edges = []
             for edge, other_point in edges:
                 # pick only edges, where the other point is on the right side
-                if other_point.sub(edge.p1).cross(edge.dir).dot(up_vector) > 0:
+                #if other_point.sub(edge.p1).cross(edge.dir).dot(up_vector) > 0:
+                if pdot(pcross(psub(other_point, edge.p1), edge.dir), up_vector) > 0:
                     outer_edges.append(edge)
             if len(outer_edges) == 0:
                 # the points seem to be an one line
@@ -361,14 +364,15 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
                 outer_edges = [long_edge]
         else:
             edge = Line(proj_points[0], proj_points[1])
-            if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+            #if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+            if pdot(pcross(edge.dir, triangle.normal), up_vector) < 0:
                 edge = Line(edge.p2, edge.p1)
             outer_edges = [edge]
     else:
         # some parts of the triangle are above and some below the cutter level
         # Cases (2a), (2b), (3a) and (3b)
         points_above = [plane.get_point_projection(p)
-                for p in triangle.get_points() if p.z > z]
+                for p in triangle.get_points() if p[2] > z]
         waterline = plane.intersect_triangle(triangle)
         if waterline is None:
             if len(points_above) == 0:
@@ -380,7 +384,7 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
                     # "triangle.minz >= z" statement above).
                     outer_edges = []
                 elif not [p for p in triangle.get_points()
-                        if p.z > z + epsilon]:
+                        if p[2] > z + epsilon]:
                     # same as above: fix for inaccurate floating calculations
                     outer_edges = []
                 else:
@@ -397,8 +401,8 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
                 outer_edges = [waterline]
             elif len(points_above) == 1:
                 other_point = points_above[0]
-                dot = other_point.sub(waterline.p1).cross(waterline.dir).dot(
-                        up_vector)
+                dot = pdot(pcross(psub(other_point, waterline.p1), waterline.dir), up_vector)
+                #dot = other_point.sub(waterline.p1).cross(waterline.dir).dot(up_vector)
                 if dot > 0:
                     # Case (2b)
                     outer_edges = [waterline]
@@ -409,7 +413,8 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
                     edges.append(Line(waterline.p2, other_point))
                     outer_edges = []
                     for edge in edges:
-                        if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                        #if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                        if pdot(pcross(edge.dir, triangle.normal), up_vector) < 0:
                             outer_edges.append(Line(edge.p2, edge.p1))
                         else:
                             outer_edges.append(edge)
@@ -422,15 +427,16 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
                     edges.append(Line(waterline.p2, other_point))
                     edges.sort(key=lambda x: x.len)
                     edge = edges[-1]
-                    if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                    #if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                    if pdot(pcross(edge.dir, triangle.normal), up_vector) < 0:
                         outer_edges = [Line(edge.p2, edge.p1)]
                     else:
                         outer_edges = [edge]
             else:
                 # two points above
                 other_point = points_above[0]
-                dot = other_point.sub(waterline.p1).cross(waterline.dir).dot(
-                        up_vector)
+                dot = pdot(pcross(psub(other_point, waterline.p1), waterline.dir), up_vector)
+                #dot = other_point.sub(waterline.p1).cross(waterline.dir).dot(up_vector)
                 if dot > 0:
                     # Case (2b)
                     # the other two points are on the right side
@@ -438,7 +444,8 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
                 elif dot < 0:
                     # Case (3a)
                     edge = Line(points_above[0], points_above[1])
-                    if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                    #if edge.dir.cross(triangle.normal).dot(up_vector) < 0:
+                    if pdot(pcross(edge.dir, triangle.normal), up_vector) < 0:
                         outer_edges = [Line(edge.p2, edge.p1)]
                     else:
                         outer_edges = [edge]
@@ -471,21 +478,23 @@ def get_collision_waterline_of_triangle(model, cutter, up_vector, triangle, z):
         direction = up_vector.cross(edge.dir).normalized()
         if direction is None:
             continue
-        direction = direction.mul(max_length)
-        edge_dir = edge.p2.sub(edge.p1)
+        direction = pmul(direction, max_length)
+        #direction = direction.mul(max_length)
+        edge_dir = psub(edge.p2, edge.p1)
+        #edge_dir = edge.p2.sub(edge.p1)
         # TODO: Adapt the number of potential starting positions to the length
         # of the line. Don't use 0.0 and 1.0 - this could result in ambiguous
         # collisions with triangles sharing these vertices.
         for factor in (0.5, epsilon, 1.0 - epsilon, 0.25, 0.75):
-            start = edge.p1.add(edge_dir.mul(factor))
+            start = padd(edge.p1, pmul(edge_dir, factor))
+            #start = edge.p1.add(edge_dir.mul(factor))
             # We need to use the triangle collision algorithm here - because we
             # need the point of collision in the triangle.
-            collisions = get_free_paths_triangles([model], cutter, start,
-                    start.add(direction), return_triangles=True)
+            collisions = get_free_paths_triangles([model], cutter, start, padd(start, direction), return_triangles=True)
             for index, coll in enumerate(collisions):
                 if (index % 2 == 0) and (not coll[1] is None) \
                         and (not coll[2] is None) \
-                        and (coll[0].sub(start).dot(direction) > 0):
+                        and (pdot(psub(coll[0], start), direction) > 0): #and (coll[0].sub(start).dot(direction) > 0):
                     cl, hit_t, cp = coll
                     break
             else:

pycam/PathGenerators/DropCutter.py

@@ -26,6 +26,8 @@ from pycam.Utils import ProgressCounter
 from pycam.Utils.threading import run_in_parallel
 import pycam.Geometry.Model
 import pycam.Utils.log
+#import pprint
+#pp = pprint.PrettyPrinter(indent=4)
 
 log = pycam.Utils.log.get_logger()
 
@@ -52,11 +54,10 @@ class DropCutter(object):
 
         # Transfer the grid (a generator) into a list of lists and count the
         # items.
-        lines = []
         # usually there is only one layer - but an xy-grid consists of two
+        lines = []
         for layer in motion_grid:
-            for line in layer:
-                lines.append(line)
+            lines.extend(layer)
 		
         num_of_lines = len(lines)
         progress_counter = ProgressCounter(len(lines), draw_callback)
@@ -66,15 +67,13 @@ class DropCutter(object):
 
         args = []
         for one_grid_line in lines:
-            # simplify the data (useful for remote processing)
-            xy_coords = [(pos.x, pos.y) for pos in one_grid_line]
-            args.append((xy_coords, minz, maxz, model, cutter,
-                    self.physics))
+            args.append(([(x,y) for x,y,z in one_grid_line], minz, maxz, model, cutter, self.physics))
+            
         for points in run_in_parallel(_process_one_grid_line, args,
                 callback=progress_counter.update):
             self.pa.new_scanline()
-            if draw_callback and draw_callback(text="DropCutter: processing " \
-                        + "line %d/%d" % (current_line + 1, num_of_lines)):
+            if draw_callback and draw_callback(text="DropCutter: processing line %d/%d" 
+                % (current_line + 1, num_of_lines)):
                 # cancel requested
                 quit_requested = True
                 break

pycam/PathGenerators/EngraveCutter.py

@@ -22,7 +22,6 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 import pycam.PathProcessors.PathAccumulator
-from pycam.Geometry.Point import Point, Vector
 from pycam.Geometry.Line import Line
 from pycam.Geometry.Plane import Plane
 from pycam.Geometry.utils import ceil

pycam/PathGenerators/PushCutter.py

@@ -26,6 +26,7 @@ import pycam.PathProcessors
 from pycam.Geometry.utils import ceil
 from pycam.Utils.threading import run_in_parallel
 from pycam.Utils import ProgressCounter
+from pycam.Geometry.PointUtils import *
 import pycam.Utils.log
 import math
 
@@ -127,7 +128,8 @@ class PushCutter(object):
         for line in layer_grid:
             p1, p2 = line
             # calculate the required calculation depth (recursion)
-            distance = p2.sub(p1).norm
+            distance = pnorm(psub(p2, p1))
+            #distance = p2.sub(p1).norm
             # TODO: accessing cutter.radius here is slightly ugly
             depth = math.log(accuracy * distance / cutter.radius) / math.log(2)
             depth = min(max(ceil(depth), 4), max_depth)

pycam/PathGenerators/__init__.py

@@ -24,7 +24,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 __all__ = ["DropCutter", "PushCutter", "EngraveCutter", "ContourFollow"]
 
 from pycam.Geometry.utils import INFINITE, epsilon, sqrt
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 import pycam.Utils.threading
 
 
@@ -64,15 +64,18 @@ def get_free_paths_triangles(models, cutter, p1, p2, return_triangles=False):
             all_results.extend(one_result)
         return all_results
 
-    backward = p1.sub(p2).normalized()
-    forward = p2.sub(p1).normalized()
-    xyz_dist = p2.sub(p1).norm
+    backward = pnormalized(psub(p1, p2))
+    #backward = p1.sub(p2).normalized()
+    forward = pnormalized(psub(p2, p1))
+    #forward = p2.sub(p1).normalized()
+    xyz_dist = pnorm(psub(p2, p1))
+    #xyz_dist = p2.sub(p1).norm
 
-    minx = min(p1.x, p2.x)
-    maxx = max(p1.x, p2.x)
-    miny = min(p1.y, p2.y)
-    maxy = max(p1.y, p2.y)
-    minz = min(p1.z, p2.z)
+    minx = min(p1[0], p2[0])
+    maxx = max(p1[0], p2[0])
+    miny = min(p1[1], p2[1])
+    maxy = max(p1[1], p2[1])
+    minz = min(p1[2], p2[2])
 
     # find all hits along scan line
     hits = []
@@ -161,15 +164,15 @@ def get_free_paths_ode(physics, p1, p2, depth=8):
     """
     points = []
     # "resize" the drill along the while x/y range and check for a collision
-    physics.extend_drill(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z)
-    physics.set_drill_position((p1.x, p1.y, p1.z))
+    physics.extend_drill(p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2])
+    physics.set_drill_position((p1[0], p1[1], p1[2]))
     if physics.check_collision():
         # collision detected
         if depth > 0:
-            middle_x = (p1.x + p2.x) / 2
-            middle_y = (p1.y + p2.y) / 2
-            middle_z = (p1.z + p2.z) / 2
-            p_middle = Point(middle_x, middle_y, middle_z)
+            middle_x = (p1[0] + p2[0]) / 2
+            middle_y = (p1[1] + p2[1]) / 2
+            middle_z = (p1[2] + p2[2]) / 2
+            p_middle = (middle_x, middle_y, middle_z)
             group1 = get_free_paths_ode(physics, p1, p_middle, depth - 1)
             group2 = get_free_paths_ode(physics, p_middle, p2, depth - 1)
             if group1 and group2 and (group1[-1] == group2[0]):
@@ -222,12 +225,12 @@ def get_max_height_ode(physics, x, y, minz, maxz):
         # skip this point (by going up to safety height)
         return None
     else:
-        return Point(x, y, safe_z)
+        return (x, y, safe_z)
 
 def get_max_height_triangles(model, cutter, x, y, minz, maxz):
     if model is None:
-        return Point(x, y, minz)
-    p = Point(x, y, maxz)
+        return (x, y, minz)
+    p = (x, y, maxz)
     height_max = None
     box_x_min = cutter.get_minx(p)
     box_x_max = cutter.get_maxx(p)
@@ -239,8 +242,8 @@ def get_max_height_triangles(model, cutter, x, y, minz, maxz):
             box_y_max, box_z_max)
     for t in triangles:
         cut = cutter.drop(t, start=p)
-        if cut and ((height_max is None) or (cut.z > height_max)):
-            height_max = cut.z
+        if cut and ((height_max is None) or (cut[2] > height_max)):
+            height_max = cut[2]
     # don't do a complete boundary check for the height
     # this avoids zero-cuts for models that exceed the bounding box height
     if (height_max is None) or (height_max < minz + epsilon):
@@ -248,18 +251,20 @@ def get_max_height_triangles(model, cutter, x, y, minz, maxz):
     if height_max > maxz + epsilon:
         return None
     else:
-        return Point(x, y, height_max)
+        return (x, y, height_max)
 
 def _check_deviance_of_adjacent_points(p1, p2, p3, min_distance):
-    straight = p3.sub(p1)
-    added = p2.sub(p1).norm + p3.sub(p2).norm
+    straight = psub(p3, p1)
+    #straight = p3.sub(p1)
+    added = pnorm(psub(p2, p1)) + pnorm(psub(p3, p2))
+    #added = p2.sub(p1).norm + p3.sub(p2).norm
     # compare only the x/y distance of p1 and p3 with min_distance
-    if straight.x ** 2 + straight.y ** 2 < min_distance ** 2:
+    if straight[0] ** 2 + straight[1] ** 2 < min_distance ** 2:
         # the points are too close together
         return True
     else:
         # allow 0.1% deviance - this is an angle of around 2 degrees
-        return (added / straight.norm) < 1.001
+        return (added / pnorm(straight)) < 1.001
 
 def get_max_height_dynamic(model, cutter, positions, minz, maxz, physics=None):
     max_depth = 8
@@ -291,11 +296,11 @@ def get_max_height_dynamic(model, cutter, positions, minz, maxz, physics=None):
             # distribute the new point two before the middle and one after
             if depth_count % 3 != 2:
                 # insert between the 1st and 2nd point
-                middle = ((p1.x + p2.x) / 2, (p1.y + p2.y) / 2)
+                middle = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
                 result.insert(index + 1, get_max_height(middle[0], middle[1]))
             else:
                 # insert between the 2nd and 3rd point
-                middle = ((p2.x + p3.x) / 2, (p2.y + p3.y) / 2)
+                middle = ((p2[0] + p3[0]) / 2, (p2[1] + p3[1]) / 2)
                 result.insert(index + 2, get_max_height(middle[0], middle[1]))
             depth_count += 1
         else:

pycam/PathProcessors/ContourCutter.py

@@ -22,7 +22,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 import pycam.PathProcessors
 from pycam.Geometry.PolygonExtractor import PolygonExtractor
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Toolpath import simplify_toolpath
 
 class ContourCutter(pycam.PathProcessors.BasePathProcessor):
@@ -33,12 +33,13 @@ class ContourCutter(pycam.PathProcessors.BasePathProcessor):
         self.polygon_extractor = None
         self.points = []
         self.reverse = reverse
-        self.__forward = Point(1, 1, 0)
+        self.__forward = (1, 1, 0)
 
     def append(self, point):
         # Sort the points in positive x/y direction - otherwise the
         # PolygonExtractor breaks.
-        if self.points and (point.sub(self.points[0]).dot(self.__forward) < 0):
+        #if self.points and (point.sub(self.points[0]).dot(self.__forward) < 0):
+        if self.points and (pdot(psub(point, self.points[0]), self.__forward) < 0):
             self.points.insert(0, point)
         else:
             self.points.append(point)

pycam/PathProcessors/__init__.py

@@ -41,10 +41,10 @@ class BasePathProcessor(object):
     def sort_layered(self, upper_first=True):
         if upper_first:
             compare_height = lambda path1, path2: \
-                    path1.points[0].z < path2.points[0].z
+                    path1.points[0][2] < path2.points[0][2]
         else:
             compare_height = lambda path1, path2: \
-                    path1.points[0].z > path2.points[0].z
+                    path1.points[0][2] > path2.points[0][2]
         finished = False
         while not finished:
             index = 0

pycam/Plugins/ModelProjection.py

@@ -23,7 +23,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 import pycam.Plugins
 from pycam.Geometry.Plane import Plane
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 
 
 class ModelProjection(pycam.Plugins.PluginBase):
@@ -87,8 +87,8 @@ class ModelProjection(pycam.Plugins.PluginBase):
                     ("ProjectionModelCustom",
                         self.gui.get_object("ProjectionZLevel").get_value())):
                 if self.gui.get_object(objname).get_active():
-                    plane = Plane(Point(0, 0, z_level), Vector(0, 0, 1))
-                    self.log.info("Projecting 3D model at level z=%g" % plane.p.z)
+                    plane = Plane((0, 0, z_level), (0, 0, 1, 'v'))
+                    self.log.info("Projecting 3D model at level z=%g" % plane.p[2])
                     new_model = model.get_waterline_contour(plane,
                             callback=progress.update)
                     if new_model:

pycam/Plugins/OpenGLViewModel.py

@@ -21,7 +21,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 import pycam.Plugins
-import pycam.Geometry.Point
+from pycam.Geometry.PointUtils import *
 
 
 GTK_COLOR_MAX = 65535.0
@@ -144,30 +144,32 @@ class OpenGLViewModelTriangle(pycam.Plugins.PluginBase):
             model = models[index]
             if not hasattr(model, "triangles"):
                 continue
-            get_coords = lambda p: (p.x, p.y, p.z)
             def calc_normal(main, normals):
-                suitable = pycam.Geometry.Point.Vector(0, 0, 0)
+                suitable = (0, 0, 0, 'v')
                 for normal, weight in normals:
-                    dot = main.dot(normal)
+                    dot = pdot(main, normal)
+                    #dot = main.dot(normal)
                     if dot > 0:
-                        suitable = suitable.add(normal.mul(weight * dot))
-                return suitable.normalized()
+                        suitable = padd(suitable, pmul(normal, weight * dot))
+                        #suitable = suitable.add(normal.mul(weight * dot))
+                return pnormalized(suitable)
+                #return suitable.normalized()
             vertices = {}
             for t in model.triangles():
                 for p in (t.p1, t.p2, t.p3):
-                    coords = get_coords(p)
-                    if not coords in vertices:
-                        vertices[coords] = []
-                    vertices[coords].append((t.normal.normalized(), t.get_area()))
+                    if not p in vertices:
+                        vertices[p] = []
+                    vertices[p].append((pnormalized(t.normal), t.get_area()))
+                    #vertices[p].append((t.normal.normalized(), t.get_area()))
             GL.glBegin(GL.GL_TRIANGLES)
             for t in model.triangles():
                 # The triangle's points are in clockwise order, but GL expects
                 # counter-clockwise sorting.
                 for p in (t.p1, t.p3, t.p2):
-                    coords = get_coords(p)
-                    normal = calc_normal(t.normal.normalized(), vertices[coords])
-                    GL.glNormal3f(normal.x, normal.y, normal.z)
-                    GL.glVertex3f(p.x, p.y, p.z)
+                    normal = calc_normal(pnormalized(t.normal), vertices[p])
+                    #normal = calc_normal(t.normal.normalized(), vertices[coords])
+                    GL.glNormal3f(normal[0], normal[1], normal[2])
+                    GL.glVertex3f(p[0], p[1], p[2])
             GL.glEnd()
             removal_list.append(index)
         # remove all models that we processed

pycam/Plugins/OpenGLViewToolpath.py

@@ -102,9 +102,9 @@ class OpenGLViewToolpath(pycam.Plugins.PluginBase):
                 GL.glFinish()
                 GL.glBegin(GL.GL_LINE_STRIP)
                 if not last_position is None:
-                    GL.glVertex3f(last_position.x, last_position.y, last_position.z)
+                    GL.glVertex3f(last_position[0], last_position[1], last_position[2])
                 last_rapid = rapid
-            GL.glVertex3f(position.x, position.y, position.z)
+            GL.glVertex3f(position[0], position[1], position[2])
             last_position = position
         GL.glEnd()
         if show_directions:

pycam/Plugins/OpenGLWindow.py

@@ -34,7 +34,7 @@ import gtk
 import math
 
 from pycam.Gui.OpenGLTools import draw_complete_model_view
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 import pycam.Geometry.Matrix as Matrix
 from pycam.Geometry.utils import sqrt, number
 import pycam.Plugins
@@ -815,12 +815,13 @@ class Camera(object):
         if (None, None) in low_high:
             return
         max_dim = max([high - low for low, high in low_high])
-        distv = Point(v["distance"][0], v["distance"][1],
-                v["distance"][2]).normalized()
+        distv = pnormalized((v["distance"][0], v["distance"][1], v["distance"][2]))
+        #distv = Point(v["distance"][0], v["distance"][1],v["distance"][2]).normalized()
         # The multiplier "1.25" is based on experiments. 1.414 (sqrt(2)) should
         # be roughly sufficient for showing the diagonal of any model.
-        distv = distv.mul((max_dim * 1.25) / number(math.sin(v["fovy"] / 2)))
-        self.view["distance"] = (distv.x, distv.y, distv.z)
+        distv = pmul(distv, (max_dim * 1.25) / number(math.sin(v["fovy"] / 2)))
+        #distv = distv.mul((max_dim * 1.25) / number(math.sin(v["fovy"] / 2)))
+        self.view["distance"] = distv
         # Adjust the "far" distance for the camera to make sure, that huge
         # models (e.g. x=1000) are still visible.
         self.view["zfar"] = 100 * max_dim
@@ -976,9 +977,10 @@ class Camera(object):
         # Calculate the proportion of each model axis according to the x axis of
         # the screen.
         distv = self.view["distance"]
-        distv = Point(distv[0], distv[1], distv[2]).normalized()
-        factors_x = distv.cross(Point(v_up[0], v_up[1], v_up[2])).normalized()
-        factors_x = (factors_x.x, factors_x.y, factors_x.z)
+        distv = pnormalized((distv[0], distv[1], distv[2]))
+        factors_x = pnormalized(pcross(distv, (v_up[0], v_up[1], v_up[2])))
+        #factors_x = distv.cross(Point(v_up[0], v_up[1], v_up[2])).normalized()
+        #factors_x = (factors_x.x, factors_x.y, factors_x.z)
         return (factors_x, factors_y)
 
 

pycam/Plugins/ToolpathCrop.py

@@ -22,7 +22,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 
 import pycam.Plugins
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Plane import Plane
 import pycam.Gui.ControlsGTK
 
@@ -145,7 +145,7 @@ class ToolpathCrop(pycam.Plugins.PluginBase):
                     polygons.append(poly.copy())
             elif hasattr(model, "get_waterline_contour"):
                 z_slice = self.gui.get_object("ToolpathCropZSlice").get_value()
-                plane = Plane(Point(0, 0, z_slice))
+                plane = Plane((0, 0, z_slice))
                 for poly in model.get_waterline_contour(plane).get_polygons():
                     polygons.append(poly.copy())
         # add an offset if requested

pycam/Plugins/ToolpathExport.py

@@ -24,7 +24,7 @@ import os
 
 import pycam.Plugins
 from pycam.Exporters.GCodeExporter import PATH_MODES
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 
 
 FILTER_GCODE = (("GCode files", ("*.ngc", "*.nc", "*.gc", "*.gcode")),)
@@ -181,7 +181,7 @@ class ToolpathExport(pycam.Plugins.PluginBase):
                 pos_x = self.core.get("touch_off_position_x")
                 pos_y = self.core.get("touch_off_position_y")
                 pos_z = self.core.get("touch_off_position_z")
-                touch_off_pos = Point(pos_x, pos_y, pos_z)
+                touch_off_pos = (pos_x, pos_y, pos_z)
             else:
                 touch_off_pos = None
             generator = generator_func(destination,

pycam/Plugins/ToolpathGrid.py

@@ -22,7 +22,6 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 
 import pycam.Plugins
-import pycam.Geometry.Point
 
 
 class ToolpathGrid(pycam.Plugins.PluginBase):
@@ -97,8 +96,7 @@ class ToolpathGrid(pycam.Plugins.PluginBase):
             new_paths = []
             for x in range(x_count):
                 for y in range(y_count):
-                    shift = pycam.Geometry.Point.Vector(x * (x_space + x_dim),
-                            y * (y_space + y_dim), 0)
+                    shift = (x * (x_space + x_dim), y * (y_space + y_dim), 0, 'v')
                     for path in toolpath.paths:
                         new_path = pycam.Geometry.Path.Path()
                         new_path.points = [shift.add(p) for p in path.points]

pycam/Simulation/ODEBlocks.py

@@ -21,7 +21,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 import pycam.Cutters
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 import ode
 
 try:
@@ -70,25 +70,25 @@ class ODEBlocks(object):
                         self.y_step_width, self.z_width))
                 box.setBody(body)
                 box.setPosition((x_pos, y_pos, z_pos))
-                box.position = Point(x_pos, y_pos, z_pos)
+                box.position = (x_pos, y_pos, z_pos)
                 self.boxes.append(box)
 
     def process_cutter_movement(self, location_start, location_end):
         # TODO: fix this workaround in the cutters shape defintions (or in ODE?)
         # for now we may only move from low x/y values to higher x/y values
-        if (location_start.x > location_end.x) \
-                or (location_start.y > location_end.y):
+        if (location_start[0] > location_end[0]) \
+                or (location_start[1] > location_end[1]):
             location_start, location_end = location_end, location_start
         cutter_body = ode.Body(self.world)
         cutter_shape, cutter_position_func = self.cutter.get_shape("ODE")
         self.space.add(cutter_shape)
         cutter_shape.space = self.space
         cutter_shape.setBody(cutter_body)
-        cutter_position_func(location_start.x, location_start.y,
-                location_start.z)
-        cutter_shape.extend_shape(location_end.x - location_start.x,
-                location_end.y - location_start.y,
-                location_end.z - location_start.z)
+        cutter_position_func(location_start[0], location_start[1],
+                location_start[2])
+        cutter_shape.extend_shape(location_end[0] - location_start[0],
+                location_end[1] - location_start[1],
+                location_end[2] - location_start[2])
         aabb = cutter_shape.getAABB()
         cutter_height = aabb[5] - aabb[4]
         # add a ray along the drill to work around an ODE bug in v0.11.1
@@ -112,8 +112,8 @@ class ODEBlocks(object):
         aabb = box.getAABB()
         end_height, start_height = aabb[-2:]
         height_half = (start_height - end_height) / 2.0
-        x_pos = box.position.x
-        y_pos = box.position.y
+        x_pos = box.position[0]
+        y_pos = box.position[1]
         new_z = end_height
         box.setPosition((x_pos, y_pos, end_height - height_half))
         loops_left = 12
@@ -137,7 +137,7 @@ class ODEBlocks(object):
         z_pos = new_z - new_height / 2.0
         new_box = ode.GeomBox(self.space, (aabb[1] - aabb[0], aabb[3] - aabb[2],
                 new_height))
-        new_box.position = Point(x_pos, y_pos, z_pos)
+        new_box.position = (x_pos, y_pos, z_pos)
         new_box.setBody(box.getBody())
         new_box.setPosition((x_pos, y_pos, z_pos))
         self.boxes.insert(box_index, new_box)
@@ -199,30 +199,30 @@ class ODEBlocks(object):
                     if (0 <= ix < len(height_field)) \
                             and (0 <= iy < len(height_field[ix])):
                         point = height_field[ix][iy]
-                        height_sum += point.z
-                        x_positions.append(point.x)
-                        y_positions.append(point.y)
+                        height_sum += point[2]
+                        x_positions.append(point[0])
+                        y_positions.append(point[1])
                         divisor += 1
                 # Use the middle between the x positions of two adjacent boxes,
                 # _if_ there is a neighbour attached to that corner.
-                if (min(x_positions) < height_field[x][y].x) \
-                        or (max(x_positions) > height_field[x][y].x):
+                if (min(x_positions) < height_field[x][y][0]) \
+                        or (max(x_positions) > height_field[x][y][0]):
                     x_value = (min(x_positions) + max(x_positions)) / 2.0
                 else:
                     # There is no adjacent box in x direction. Use the step size
                     # to calculate the x value of this edge.
-                    x_value = height_field[x][y].x \
+                    x_value = height_field[x][y][0] \
                             + offsets[0] * self.x_step_width / 2.0
                 # same as above for y instead of x
-                if (min(y_positions) < height_field[x][y].y) \
-                        or (max(y_positions) > height_field[x][y].y):
+                if (min(y_positions) < height_field[x][y][1]) \
+                        or (max(y_positions) > height_field[x][y][1]):
                     y_value = (min(y_positions) + max(y_positions)) / 2.0
                 else:
-                    y_value = height_field[x][y].y \
+                    y_value = height_field[x][y][1] \
                             + offsets[1] * self.y_step_width / 2.0
                 # Create a Point instance describing the position and the
                 # average height.
-                points.append(Point(x_value, y_value, height_sum / divisor))
+                points.append((x_value, y_value, height_sum / divisor))
             return points
         # draw the surface
         GL.glBegin(GL.GL_QUADS)
@@ -233,11 +233,11 @@ class ODEBlocks(object):
                 points_around = get_box_height_points(x, y)
                 # Calculate the "normal" of polygon. We picked up three random
                 # points of this quadrilateral.
-                n = self._normal(points_around[1].z, points_around[2].z,
-                        points_around[3].z)
+                n = self._normal(points_around[1][2], points_around[2][2],
+                        points_around[3][2])
                 GL.glNormal3f(n[0], n[1], n[2])
                 for point in points_around:
-                    GL.glVertex3f(point.x, point.y, point.z)
+                    GL.glVertex3f(point[0], point[1], point[2])
                 # go through the conditions for an edge box and use the
                 # appropriate corners for the side faces of the material
                 for condition, i1, i2 in ((x == 0, 3, 0), (y == 0, 0, 1),
@@ -245,16 +245,16 @@ class ODEBlocks(object):
                         (y == self.y_steps - 1, 2, 3)):
                     # check if this point belongs to an edge of the material
                     if condition:
-                        n = self._normal(points_around[1].z, points_around[2].z,
-                                points_around[3].z)
+                        n = self._normal(points_around[1][2], points_around[2][2],
+                                points_around[3][2])
                         GL.glNormal3f(n[0], n[1], n[2])
-                        GL.glVertex3f(points_around[i1].x, points_around[i1].y,
+                        GL.glVertex3f(points_around[i1][0], points_around[i1][1],
                                 self.z_offset)
-                        GL.glVertex3f(points_around[i1].x, points_around[i1].y,
+                        GL.glVertex3f(points_around[i1][0], points_around[i1][1],
                                 points_around[i1].z)
-                        GL.glVertex3f(points_around[i2].x, points_around[i2].y,
+                        GL.glVertex3f(points_around[i2][0], points_around[i2][1],
                                 points_around[i2].z)
-                        GL.glVertex3f(points_around[i2].x, points_around[i2].y,
+                        GL.glVertex3f(points_around[i2][0], points_around[i2][1],
                                 self.z_offset)
         GL.glEnd()
 

pycam/Simulation/ZBuffer.py

@@ -21,7 +21,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 from pycam.Geometry.utils import sqrt
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 import ctypes
 import math
 
@@ -128,12 +128,12 @@ class ZBuffer(object):
             py = self.y[y]
             for x in range(minx, maxx):
                 px = self.x[x]
-                v0x = t.p3.x - t.p1.x
-                v0y = t.p3.y - t.p1.y
-                v1x = t.p2.x - t.p1.x
-                v1y = t.p2.y - t.p1.y
-                v2x = px - t.p1.x
-                v2y = py - t.p1.y
+                v0x = t.p3[0] - t.p1[0]
+                v0y = t.p3[1] - t.p1[1]
+                v1x = t.p2[0] - t.p1[0]
+                v1y = t.p2[1] - t.p1[1]
+                v2x = px - t.p1[0]
+                v2y = py - t.p1[1]
                 dot00 = v0x*v0x + v0y*v0y
                 dot01 = v0x*v1x + v0y*v1y
                 dot02 = v0x*v2x + v0y*v2y
@@ -143,9 +143,9 @@ class ZBuffer(object):
                 u = (dot11 * dot02 - dot01 * dot12) * invDenom
                 v = (dot00 * dot12 - dot01 * dot02) * invDenom
                 if (u >= -EPSILON) and (v >= -EPSILON) and (u + v <= 1-EPSILON):
-                    v0z = t.p3.z - t.p1.z
-                    v1z = t.p2.z - t.p1.z
-                    pz = t.p1.z + v0z * u + v1z * v
+                    v0z = t.p3[2] - t.p1[2]
+                    v1z = t.p2[2] - t.p1[2]
+                    pz = t.p1[2] + v0z * u + v1z * v
                     if pz > self.buf[y][x].z:
                         self.buf[y][x].z = pz
                         self.buf[y+0][x+0].changed = True
@@ -155,8 +155,8 @@ class ZBuffer(object):
                         self.changed = True
 
     def add_cutter(self, c):
-        cx = c.location.x
-        cy = c.location.y
+        cx = c.location[0]
+        cy = c.location[1]
         rsq = c.radiussq
         minx = int((c.minx - self.minx) / (self.maxx - self.minx) * self.xres) \
                 - 1
@@ -182,13 +182,15 @@ class ZBuffer(object):
             maxy = self.yres - 1
         if miny > self.yres - 1: 
             miny = self.yres - 1
-        p = Point(0, 0, 0)
-        zaxis = Point(0, 0, -1)
+        p = (0, 0, 0)
+        zaxis = (0, 0, -1)
 
         for y in range(miny, maxy):
-            p.y = py = self.y[y]
+            py = self.y[y]
+            p = (p[0], py, p[2])
             for x in range(minx, maxx):
-                p.x = px = self.x[x]
+                px = self.x[x]
+                p = (px, p[1], p[2])
                 if (px - cx) * (px - cx) + (py - cy) * (py - cy) \
                         <= rsq + EPSILON:
                     (cl, ccp, cp, l) = c.intersect_point(zaxis, p)

pycam/Toolpath/MotionGrid.py

@@ -20,7 +20,7 @@ You should have received a copy of the GNU General Public License
 along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Line import Line
 from pycam.Geometry.utils import epsilon
 from pycam.Geometry.Polygon import PolygonSorter
@@ -91,9 +91,9 @@ def get_fixed_grid_line(start, end, line_pos, z, step_width=None,
     else:
         steps = floatrange(start, end, inc=step_width)
     if grid_direction == GRID_DIRECTION_X:
-        get_point = lambda pos: Point(pos, line_pos, z)
+        get_point = lambda pos: (pos, line_pos, z)
     else:
-        get_point = lambda pos: Point(line_pos, pos, z)
+        get_point = lambda pos: (line_pos, pos, z)
     for pos in steps:
         yield get_point(pos)
 
@@ -208,7 +208,7 @@ def _get_position(minx, maxx, miny, maxy, z, position):
         y = miny
     else:
         y = maxy
-    return Point(x, y, z)
+    return (x, y, z)
 
 def get_spiral_layer_lines(minx, maxx, miny, maxy, z, line_distance_x,
         line_distance_y, grid_direction, start_position, current_location):
@@ -255,27 +255,33 @@ def get_spiral_layer(minx, maxx, miny, maxy, z, line_distance, step_width,
             previous = None
             for index, (start, end) in enumerate(lines):
                 radius = 0.5 * min(line_distance_x, line_distance_y)
-                edge_vector = end.sub(start)
+                edge_vector = psub(end,start)
+                #edge_vector = end.sub(start)
                 # TODO: ellipse would be better than arc
-                offset = edge_vector.normalized().mul(radius)
+                offset = pmul(pnormalized(edge_vector), radius)
+                #offset = edge_vector.normalized().mul(radius)
                 if previous:
-                    start = start.add(offset)
-                    center = previous.add(offset)
-                    up_vector = previous.sub(center).cross(start.sub(center)).normalized()
-                    north = center.add(Vector(1.0, 0.0, 0.0))
+                    start = padd(start, offset)
+                    #start = start.add(offset)
+                    center = padd(previous, offset)
+                    #center = previous.add(offset)
+                    up_vector = pnormalized(pcross(psub(previous, center), psub(start, center)))
+                    #up_vector = previous.sub(center).cross(start.sub(center)).normalized()
+                    north = padd(center, (1.0, 0.0, 0.0, 'v'))
+                    #north = center.add(Vector(1.0, 0.0, 0.0))
                     angle_start = pycam.Geometry.get_angle_pi(north, center, previous, up_vector, pi_factor=True) * 180.0
                     angle_end = pycam.Geometry.get_angle_pi(north, center, start, up_vector, pi_factor=True) * 180.0
                     # TODO: remove these exceptions based on up_vector.z (get_points_of_arc does not respect the plane, yet)
-                    if up_vector.z < 0:
+                    if up_vector[2] < 0:
                         angle_start, angle_end = -angle_end, -angle_start
                     arc_points = pycam.Geometry.get_points_of_arc(center, radius, angle_start, angle_end)
-                    if up_vector.z < 0:
+                    if up_vector[2] < 0:
                         arc_points.reverse()
                     for arc_index in range(len(arc_points) - 1):
                         p1_coord = arc_points[arc_index]
                         p2_coord = arc_points[arc_index + 1]
-                        p1 = Point(p1_coord[0], p1_coord[1], z)
-                        p2 = Point(p2_coord[0], p2_coord[1], z)
+                        p1 = (p1_coord[0], p1_coord[1], z)
+                        p2 = (p2_coord[0], p2_coord[1], z)
                         rounded_lines.append((p1, p2))
                 if index != len(lines) - 1:
                     end = end.sub(offset)
@@ -294,7 +300,8 @@ def get_spiral_layer(minx, maxx, miny, maxy, z, line_distance, step_width,
                 else:
                     steps = floatrange(0.0, line.len, inc=step_width)
                 for step in steps:
-                    next_point = line.p1.add(line.dir.mul(step))
+                    next_point = padd(line.p1, pmul(line.dir, step))
+                    #next_point = line.p1.add(line.dir.mul(step))
                     points.append(next_point)
             if reverse:
                 points.reverse()
@@ -328,7 +335,7 @@ def get_spiral((low, high), layer_distance, line_distance=None,
 
 def get_lines_layer(lines, z, last_z=None, step_width=None,
         milling_style=MILLING_STYLE_CONVENTIONAL):
-    get_proj_point = lambda proj_point: Point(proj_point.x, proj_point.y, z)
+    get_proj_point = lambda proj_point: (proj_point[0], proj_point[1], z)
     projected_lines = []
     for line in lines:
         if (not last_z is None) and (last_z < line.minz):
@@ -337,9 +344,10 @@ def get_lines_layer(lines, z, last_z=None, step_width=None,
         elif line.minz < z < line.maxz:
             # Split the line at the point at z level and do the calculation
             # for both point pairs.
-            factor = (z - line.p1.z) / (line.p2.z - line.p1.z)
-            plane_point = line.p1.add(line.vector.mul(factor))
-            if line.p1.z < z:
+            factor = (z - line.p1[2]) / (line.p2[2] - line.p1[2])
+            plane_point = padd(line.p1, pmul(line.vector, factor))
+            #plane_point = line.p1.add(line.vector.mul(factor))
+            if line.p1[2] < z:
                 p1 = get_proj_point(line.p1)
                 p2 = line.p2
             else:
@@ -348,10 +356,10 @@ def get_lines_layer(lines, z, last_z=None, step_width=None,
             projected_lines.append(Line(p1, plane_point))
             yield Line(plane_point, p2)
         elif line.minz < last_z < line.maxz:
-            plane = Plane(Point(0, 0, last_z), Vector(0, 0, 1))
+            plane = Plane((0, 0, last_z), (0, 0, 1, 'v'))
             cp = plane.intersect_point(line.dir, line.p1)[0]
             # we can be sure that there is an intersection
-            if line.p1.z > last_z:
+            if line.p1[2] > last_z:
                 p1, p2 = cp, line.p2
             else:
                 p1, p2 = line.p1, cp
@@ -378,7 +386,8 @@ def get_lines_layer(lines, z, last_z=None, step_width=None,
             else:
                 steps = floatrange(0.0, line.len, inc=step_width)
             for step in steps:
-                next_point = line.p1.add(line.dir.mul(step))
+                next_point = padd(line.p1, pmul(line.dir, step))
+                #next_point = line.p1.add(line.dir.mul(step))
                 points.append(next_point)
         yield points
 

pycam/Toolpath/SupportGrid.py

@@ -20,7 +20,7 @@ You should have received a copy of the GNU General Public License
 along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-from pycam.Geometry.Point import Point, Vector
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Triangle import Triangle
 from pycam.Geometry.Plane import Plane
 from pycam.Geometry.Model import Model
@@ -34,16 +34,26 @@ def _get_triangles_for_face(pts):
     return (t1, t2)
 
 def _add_cuboid_to_model(model, start, direction, height, width):
-    up = Vector(0, 0, 1).mul(height)
-    ortho_dir = direction.cross(up).normalized()
-    start1 = start.add(ortho_dir.mul(-width/2))
-    start2 = start1.add(up)
-    start3 = start2.add(ortho_dir.mul(width))
-    start4 = start3.sub(up)
-    end1 = start1.add(direction)
-    end2 = start2.add(direction)
-    end3 = start3.add(direction)
-    end4 = start4.add(direction)
+    up = pmul((0, 0, 1, 'v'), height)
+    #up = Vector(0, 0, 1).mul(height)
+    ortho_dir = pnormalized(pcross(direction, up))
+    #ortho_dir = direction.cross(up).normalized()
+    start1 = padd(start, pmul(ortho_dir, -width/2))
+    #start1 = start.add(ortho_dir.mul(-width/2))
+    start2 = padd(start1, up)
+    #start2 = start1.add(up)
+    start3 = padd(start2, pmul(ortho_dir, width))
+    #start3 = start2.add(ortho_dir.mul(width))
+    start4 = psub(start3, up)
+    #start4 = start3.sub(up)
+    end1 = padd(start1, direction)
+    #end1 = start1.add(direction)
+    end2 = padd(start2, direction)
+    #end2 = start2.add(direction)
+    end3 = padd(start3, direction)
+    #end3 = start3.add(direction)
+    end4 = padd(start4, direction)
+    #end4 = start4.add(direction)
     faces = ((start1, start2, start3, start4), (start1, end1, end2, start2),
             (start2, end2, end3, start3), (start3, end3, end4, start4),
             (start4, end4, end1, start1), (end4, end3, end2, end1))
@@ -54,14 +64,14 @@ def _add_cuboid_to_model(model, start, direction, height, width):
 
 def _add_aligned_cuboid_to_model(minx, maxx, miny, maxy, minz, maxz):
     points = (
-            Point(minx, miny, minz),
-            Point(maxx, miny, minz),
-            Point(maxx, maxy, minz),
-            Point(minx, maxy, minz),
-            Point(minx, miny, maxz),
-            Point(maxx, miny, maxz),
-            Point(maxx, maxy, maxz),
-            Point(minx, maxy, maxz))
+            (minx, miny, minz),
+            (maxx, miny, minz),
+            (maxx, maxy, minz),
+            (minx, maxy, minz),
+            (minx, miny, maxz),
+            (maxx, miny, maxz),
+            (maxx, maxy, maxz),
+            (minx, maxy, maxz))
     triangles = []
     # lower face
     triangles.extend(_get_triangles_for_face(
@@ -159,10 +169,10 @@ def get_support_distributed(model, z_plane, average_distance,
     result = Model()
     if not hasattr(model, "get_polygons"):
         model = model.get_waterline_contour(
-                Plane(Point(0, 0, max(model.minz, z_plane)), Vector(0, 0, 1)))
+                Plane((0, 0, max(model.minz, z_plane)), (0, 0, 1, 'v')))
     if model:
-        model = model.get_flat_projection(Plane(Point(0, 0, z_plane),
-                Vector(0, 0, 1)))
+        model = model.get_flat_projection(Plane((0, 0, z_plane),
+                (0, 0, 1, 'v')))
     if model and bounds:
         model = model.get_cropped_model_by_bounds(bounds)
     if model:
@@ -184,24 +194,24 @@ def get_support_distributed(model, z_plane, average_distance,
         bridges = bridge_calculator(polygon, z_plane, min_bridges_per_polygon,
                 average_distance, avoid_distance)
         for pos, direction in bridges:
-            _add_cuboid_to_model(result, pos, direction.mul(length), height,
-                    thickness)
+            _add_cuboid_to_model(result, pos, pmul(direction, length), height, thickness)
+            #_add_cuboid_to_model(result, pos, direction.mul(length), height, thickness)
     return result
 
 
 class _BridgeCorner(object):
     # currently we only use the xy plane
-    up_vector = Vector(0, 0, 1)
+    up_vector = (0, 0, 1, 'v')
     def __init__(self, barycenter, location, p1, p2, p3):
         self.location = location
         self.position = p2
-        self.direction = pycam.Geometry.get_bisector(p1, p2, p3,
-                self.up_vector).normalized()
-        preferred_direction = p2.sub(barycenter).normalized()
+        self.direction = pnormalized(pycam.Geometry.get_bisector(p1, p2, p3, self.up_vector))
+        preferred_direction = pnormalized(psub(p2, barycenter))
+        #preferred_direction = p2.sub(barycenter).normalized()
         # direction_factor: 0..1 (bigger -> better)
-        direction_factor = (preferred_direction.dot(self.direction) + 1) / 2
-        angle = pycam.Geometry.get_angle_pi(p1, p2, p3,
-                self.up_vector, pi_factor=True)
+        direction_factor = (pdot(preferred_direction, self.direction) + 1) / 2
+        #direction_factor = (preferred_direction.dot(self.direction) + 1) / 2
+        angle = pycam.Geometry.get_angle_pi(p1, p2, p3, self.up_vector, pi_factor=True)
         # angle_factor: 0..1 (bigger -> better)
         if angle > 0.5:
             # use only angles > 90 degree
@@ -275,7 +285,8 @@ def _get_edge_bridges(polygon, z_plane, min_bridges, average_distance,
         avoid_distance):
     def is_near_list(point_list, point, distance):
         for p in point_list:
-            if p.sub(point).norm <= distance:
+            #if p.sub(point).norm <= distance:
+            if pnorm(psub(p, point)) <= distance:
                 return True
         return False
     lines = polygon.get_lines()
@@ -308,8 +319,10 @@ def _get_edge_bridges(polygon, z_plane, min_bridges, average_distance,
         if is_near_list(bridge_positions, position, avoid_distance):
             line = polygon.get_lines()[line_index]
             # calculate two alternative points on the same line
-            position1 = position.add(line.p1).div(2)
-            position2 = position.add(line.p2).div(2)
+            position1 = pdiv(padd(position, line.p1), 2)
+            #position1 = position.add(line.p1).div(2)
+            position2 = pdiv(padd(position, line.p2), 2)
+            #position2 = position.add(line.p2).div(2)
             if is_near_list(bridge_positions, position1, avoid_distance):
                 if is_near_list(bridge_positions, position2,
                         avoid_distance):
@@ -324,9 +337,9 @@ def _get_edge_bridges(polygon, z_plane, min_bridges, average_distance,
         # append the original position (ignoring z_plane)
         bridge_positions.append(position)
         # move the point to z_plane
-        position = Point(position.x, position.y, z_plane)
-        bridge_dir = lines[line_index].dir.cross(
-                polygon.plane.n).normalized()
+        position = (position[0], position[1], z_plane)
+        bridge_dir = pnormalized(pcross(lines[line_index].dir, polygon.plane.n))
+        #bridge_dir = lines[line_index].dir.cross(polygon.plane.n).normalized()
         result.append((position, bridge_dir))
     return result
 

pycam/Toolpath/__init__.py

@@ -22,7 +22,7 @@ along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
 
 __all__ = ["simplify_toolpath", "ToolpathList", "Toolpath", "Generator"]
 
-from pycam.Geometry.Point import Point
+from pycam.Geometry.PointUtils import *
 from pycam.Geometry.Path import Path
 from pycam.Geometry.Line import Line
 from pycam.Geometry.utils import number, epsilon
@@ -34,8 +34,10 @@ log = pycam.Utils.log.get_logger()
 
 
 def _check_colinearity(p1, p2, p3):
-    v1 = p2.sub(p1).normalized()
-    v2 = p3.sub(p2).normalized()
+    v1 = pnormalized(psub(p2, p1))
+    #v1 = p2.sub(p1).normalized()
+    v2 = pnormalized(psub(p3, p2))
+    #v2 = p3.sub(p2).normalized()
     # compare if the normalized distances between p1-p2 and p2-p3 are equal
     return v1 == v2
 
@@ -82,36 +84,36 @@ class Toolpath(object):
             new_paths.append(new_path)
         return Toolpath(new_paths, parameters=self.get_params())
 
-    def _get_limit_generic(self, attr, func):
+    def _get_limit_generic(self, idx, func):
         path_min = []
         for path in self.paths:
             if path.points:
-                path_min.append(func([getattr(p, attr) for p in path.points]))
+                path_min.append(func([ p[idx] for p in path.points]))
         return func(path_min)
 
     @property
     def minx(self):
-        return self._get_limit_generic("x", min)
+        return self._get_limit_generic(0, min)
 
     @property
     def maxx(self):
-        return self._get_limit_generic("x", max)
+        return self._get_limit_generic(0, max)
 
     @property
     def miny(self):
-        return self._get_limit_generic("y", min)
+        return self._get_limit_generic(1, min)
 
     @property
     def maxy(self):
-        return self._get_limit_generic("y", max)
+        return self._get_limit_generic(1, max)
 
     @property
     def minz(self):
-        return self._get_limit_generic("z", min)
+        return self._get_limit_generic(2, min)
 
     @property
     def maxz(self):
-        return self._get_limit_generic("z", max)
+        return self._get_limit_generic(2, max)
 
     def get_meta_data(self):
         meta = self.toolpath_settings.get_string()
@@ -137,12 +139,13 @@ class Toolpath(object):
                     self.last_pos = new_position
                     return True
                 else:
-                    distance = new_position.sub(self.last_pos).norm
+                    distance = pnorm(psub(new_position, self.last_pos))
+                    #distance = new_position.sub(self.last_pos).norm
                     if self.moved_distance + distance > self.max_movement:
                         partial = (self.max_movement - self.moved_distance) / \
                                 distance
-                        partial_dest = self.last_pos.add(new_position.sub(
-                                self.last_pos).mul(partial))
+                        partial_dest = padd(self.last_pos, pmul(psub(new_position, self.last_pos), partial))
+                        #partial_dest = self.last_pos.add(new_position.sub(self.last_pos).mul(partial))
                         self.moves.append((partial_dest, rapid))
                         self.last_pos = partial_dest
                         # we are finished
@@ -163,21 +166,20 @@ class Toolpath(object):
                 continue
             p_next = path.points[0]
             if p_last is None:
-                p_last = Point(p_next.x, p_next.y, safety_height)
+                p_last = (p_next[0], p_next[1], safety_height)
                 if not result.append(p_last, True):
                     return result.moves
-            if ((abs(p_last.x - p_next.x) > epsilon) \
-                    or (abs(p_last.y - p_next.y) > epsilon)):
+            if ((abs(p_last[0] - p_next[0]) > epsilon) \
+                    or (abs(p_last[1] - p_next[1]) > epsilon)):
                 # Draw the connection between the last and the next path.
                 # Respect the safety height.
-                if (abs(p_last.z - p_next.z) > epsilon) \
-                        or (p_last.sub(p_next).norm > \
-                            self._max_safe_distance + epsilon):
+                #if (abs(p_last[2] - p_next[2]) > epsilon) or (p_last.sub(p_next).norm > self._max_safe_distance + epsilon):
+                if (abs(p_last[2] - p_next[2]) > epsilon) or (pnorm(psub(p_last, p_next)) > self._max_safe_distance + epsilon):
                     # The distance between these two points is too far.
                     # This condition helps to prevent moves up/down for
                     # adjacent lines.
-                    safety_last = Point(p_last.x, p_last.y, safety_height)
-                    safety_next = Point(p_next.x, p_next.y, safety_height)
+                    safety_last = (p_last[0], p_last[1], safety_height)
+                    safety_next = (p_next[0], p_next[1], safety_height)
                     if not result.append(safety_last, True):
                         return result.moves
                     if not result.append(safety_next, True):
@@ -187,7 +189,7 @@ class Toolpath(object):
                     return result.moves
             p_last = path.points[-1]
         if not p_last is None:
-            p_last_safety = Point(p_last.x, p_last.y, safety_height)
+            p_last_safety = (p_last[0], p_last[1], safety_height)
             result.append(p_last_safety, True)
         return result.moves
 
@@ -206,7 +208,8 @@ class Toolpath(object):
         # go through all points of the path
         for new_pos, rapid in self.get_moves(safety_height):
             if not current_position is None:
-                result += new_pos.sub(current_position).norm / self._feedrate
+                result += pnorm(psub(new_pos, current_position)) / self._feedrate
+                #result += new_pos.sub(current_position).norm / self._feedrate
             current_position = new_pos
         return result
 
@@ -217,7 +220,8 @@ class Toolpath(object):
         # go through all points of the path
         for new_pos, rapid in self.get_moves(safety_height):
             if not current_position is None:
-                result += new_pos.sub(current_position).norm
+                result += pnorm(psub(new_pos, current_position))
+                #result += new_pos.sub(current_position).norm
             current_position = new_pos
         return result