77d04ceab8
Updated build script to create win32/linux/macos versions. Fixed the defaults to they work with PLA. Fixed the temperature plugin default "ON" problem. Removed all profiles except for PLA.
336 lines
9.4 KiB
Python
336 lines
9.4 KiB
Python
"""
|
|
Vector3 is a three dimensional vector class.
|
|
|
|
Below are examples of Vector3 use.
|
|
|
|
>>> from vector3 import Vector3
|
|
>>> origin = Vector3()
|
|
>>> origin
|
|
0.0, 0.0, 0.0
|
|
>>> pythagoras = Vector3( 3, 4, 0 )
|
|
>>> pythagoras
|
|
3.0, 4.0, 0.0
|
|
>>> pythagoras.magnitude()
|
|
5.0
|
|
>>> pythagoras.magnitudeSquared()
|
|
25
|
|
>>> triplePythagoras = pythagoras * 3.0
|
|
>>> triplePythagoras
|
|
9.0, 12.0, 0.0
|
|
>>> plane = pythagoras.dropAxis()
|
|
>>> plane
|
|
(3+4j)
|
|
"""
|
|
|
|
from __future__ import absolute_import
|
|
try:
|
|
import psyco
|
|
psyco.full()
|
|
except:
|
|
pass
|
|
#Init has to be imported first because it has code to workaround the python bug where relative imports don't work if the module is imported as a main module.
|
|
import __init__
|
|
|
|
from fabmetheus_utilities import xml_simple_writer
|
|
import math
|
|
import operator
|
|
|
|
|
|
__author__ = 'Enrique Perez (perez_enrique@yahoo.com)'
|
|
__credits__ = 'Nophead <http://forums.reprap.org/profile.php?12,28>\nArt of Illusion <http://www.artofillusion.org/>'
|
|
__date__ = '$Date: 2008/21/04 $'
|
|
__license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html'
|
|
|
|
|
|
class Vector3:
|
|
'A three dimensional vector class.'
|
|
__slots__ = ['x', 'y', 'z']
|
|
|
|
def __init__(self, x=0.0, y=0.0, z=0.0):
|
|
self.x = x
|
|
self.y = y
|
|
self.z = z
|
|
|
|
def __abs__(self):
|
|
'Get the magnitude of the Vector3.'
|
|
return math.sqrt( self.x * self.x + self.y * self.y + self.z * self.z )
|
|
|
|
magnitude = __abs__
|
|
|
|
def __add__(self, other):
|
|
'Get the sum of this Vector3 and other one.'
|
|
return Vector3( self.x + other.x, self.y + other.y, self.z + other.z )
|
|
|
|
def __copy__(self):
|
|
'Get the copy of this Vector3.'
|
|
return Vector3( self.x, self.y, self.z )
|
|
|
|
__pos__ = __copy__
|
|
|
|
copy = __copy__
|
|
|
|
def __div__(self, other):
|
|
'Get a new Vector3 by dividing each component of this one.'
|
|
return Vector3( self.x / other, self.y / other, self.z / other )
|
|
|
|
def __eq__(self, other):
|
|
'Determine whether this vector is identical to other one.'
|
|
if other == None:
|
|
return False
|
|
if other.__class__ != self.__class__:
|
|
return False
|
|
return self.x == other.x and self.y == other.y and self.z == other.z
|
|
|
|
def __floordiv__(self, other):
|
|
'Get a new Vector3 by floor dividing each component of this one.'
|
|
return Vector3( self.x // other, self.y // other, self.z // other )
|
|
|
|
def __hash__(self):
|
|
'Determine whether this vector is identical to other one.'
|
|
return self.__repr__().__hash__()
|
|
|
|
def __iadd__(self, other):
|
|
'Add other Vector3 to this one.'
|
|
self.x += other.x
|
|
self.y += other.y
|
|
self.z += other.z
|
|
return self
|
|
|
|
def __idiv__(self, other):
|
|
'Divide each component of this Vector3.'
|
|
self.x /= other
|
|
self.y /= other
|
|
self.z /= other
|
|
return self
|
|
|
|
def __ifloordiv__(self, other):
|
|
'Floor divide each component of this Vector3.'
|
|
self.x //= other
|
|
self.y //= other
|
|
self.z //= other
|
|
return self
|
|
|
|
def __imul__(self, other):
|
|
'Multiply each component of this Vector3.'
|
|
self.x *= other
|
|
self.y *= other
|
|
self.z *= other
|
|
return self
|
|
|
|
def __isub__(self, other):
|
|
'Subtract other Vector3 from this one.'
|
|
self.x -= other.x
|
|
self.y -= other.y
|
|
self.z -= other.z
|
|
return self
|
|
|
|
def __itruediv__(self, other):
|
|
'True divide each component of this Vector3.'
|
|
self.x = operator.truediv( self.x, other )
|
|
self.y = operator.truediv( self.y, other )
|
|
self.z = operator.truediv( self.z, other )
|
|
return self
|
|
|
|
def __mul__(self, other):
|
|
'Get a new Vector3 by multiplying each component of this one.'
|
|
return Vector3( self.x * other, self.y * other, self.z * other )
|
|
|
|
def __ne__(self, other):
|
|
'Determine whether this vector is not identical to other one.'
|
|
return not self.__eq__(other)
|
|
|
|
def __neg__(self):
|
|
return Vector3( - self.x, - self.y, - self.z )
|
|
|
|
def __nonzero__(self):
|
|
return self.x != 0 or self.y != 0 or self.z != 0
|
|
|
|
def __rdiv__(self, other):
|
|
'Get a new Vector3 by dividing each component of this one.'
|
|
return Vector3( other / self.x, other / self.y, other / self.z )
|
|
|
|
def __repr__(self):
|
|
'Get the string representation of this Vector3.'
|
|
return '(%s, %s, %s)' % ( self.x, self.y, self.z )
|
|
|
|
def __rfloordiv__(self, other):
|
|
'Get a new Vector3 by floor dividing each component of this one.'
|
|
return Vector3( other // self.x, other // self.y, other // self.z )
|
|
|
|
def __rmul__(self, other):
|
|
'Get a new Vector3 by multiplying each component of this one.'
|
|
return Vector3( self.x * other, self.y * other, self.z * other )
|
|
|
|
def __rtruediv__(self, other):
|
|
'Get a new Vector3 by true dividing each component of this one.'
|
|
return Vector3( operator.truediv( other , self.x ), operator.truediv( other, self.y ), operator.truediv( other, self.z ) )
|
|
|
|
def __sub__(self, other):
|
|
'Get the difference between the Vector3 and other one.'
|
|
return Vector3( self.x - other.x, self.y - other.y, self.z - other.z )
|
|
|
|
def __truediv__(self, other):
|
|
'Get a new Vector3 by true dividing each component of this one.'
|
|
return Vector3( operator.truediv( self.x, other ), operator.truediv( self.y, other ), operator.truediv( self.z, other ) )
|
|
|
|
def _getAccessibleAttribute(self, attributeName):
|
|
'Get the accessible attribute.'
|
|
if attributeName in globalGetAccessibleAttributeSet:
|
|
return getattr(self, attributeName, None)
|
|
return None
|
|
|
|
def _setAccessibleAttribute(self, attributeName, value):
|
|
'Set the accessible attribute.'
|
|
if attributeName in globalSetAccessibleAttributeSet:
|
|
setattr(self, attributeName, value)
|
|
|
|
def cross(self, other):
|
|
'Calculate the cross product of this vector with other one.'
|
|
return Vector3(self.y * other.z - self.z * other.y, -self.x * other.z + self.z * other.x, self.x * other.y - self.y * other.x)
|
|
|
|
def distance(self, other):
|
|
'Get the Euclidean distance between this vector and other one.'
|
|
return math.sqrt( self.distanceSquared(other) )
|
|
|
|
def distanceSquared(self, other):
|
|
'Get the square of the Euclidean distance between this vector and other one.'
|
|
separationX = self.x - other.x
|
|
separationY = self.y - other.y
|
|
separationZ = self.z - other.z
|
|
return separationX * separationX + separationY * separationY + separationZ * separationZ
|
|
|
|
def dot(self, other):
|
|
'Calculate the dot product of this vector with other one.'
|
|
return self.x * other.x + self.y * other.y + self.z * other.z
|
|
|
|
def dropAxis( self, which = 2 ):
|
|
'Get a complex by removing one axis of the vector3.'
|
|
if which == 0:
|
|
return complex( self.y, self.z )
|
|
if which == 1:
|
|
return complex( self.x, self.z )
|
|
if which == 2:
|
|
return complex( self.x, self.y )
|
|
|
|
def getFloatList(self):
|
|
'Get the vector as a list of floats.'
|
|
return [ float( self.x ), float( self.y ), float( self.z ) ]
|
|
|
|
def getIsDefault(self):
|
|
'Determine if this is the zero vector.'
|
|
if self.x != 0.0:
|
|
return False
|
|
if self.y != 0.0:
|
|
return False
|
|
return self.z == 0.0
|
|
|
|
def getNormalized(self):
|
|
'Get the normalized Vector3.'
|
|
magnitude = abs(self)
|
|
if magnitude == 0.0:
|
|
return self.copy()
|
|
return self / magnitude
|
|
|
|
def magnitudeSquared(self):
|
|
'Get the square of the magnitude of the Vector3.'
|
|
return self.x * self.x + self.y * self.y + self.z * self.z
|
|
|
|
def maximize(self, other):
|
|
'Maximize the Vector3.'
|
|
self.x = max(other.x, self.x)
|
|
self.y = max(other.y, self.y)
|
|
self.z = max(other.z, self.z)
|
|
|
|
def minimize(self, other):
|
|
'Minimize the Vector3.'
|
|
self.x = min(other.x, self.x)
|
|
self.y = min(other.y, self.y)
|
|
self.z = min(other.z, self.z)
|
|
|
|
def normalize(self):
|
|
'Scale each component of this Vector3 so that it has a magnitude of 1. If this Vector3 has a magnitude of 0, this method has no effect.'
|
|
magnitude = abs(self)
|
|
if magnitude != 0.0:
|
|
self /= magnitude
|
|
|
|
def reflect( self, normal ):
|
|
'Reflect the Vector3 across the normal, which is assumed to be normalized.'
|
|
distance = 2 * ( self.x * normal.x + self.y * normal.y + self.z * normal.z )
|
|
return Vector3( self.x - distance * normal.x, self.y - distance * normal.y, self.z - distance * normal.z )
|
|
|
|
def setToVector3(self, other):
|
|
'Set this Vector3 to be identical to other one.'
|
|
self.x = other.x
|
|
self.y = other.y
|
|
self.z = other.z
|
|
|
|
def setToXYZ( self, x, y, z ):
|
|
'Set the x, y, and z components of this Vector3.'
|
|
self.x = x
|
|
self.y = y
|
|
self.z = z
|
|
|
|
|
|
globalGetAccessibleAttributeSet = 'x y z'.split()
|
|
globalSetAccessibleAttributeSet = globalGetAccessibleAttributeSet
|
|
|
|
"""
|
|
class Vector3:
|
|
__slots__ = ['x', 'y', 'z']
|
|
|
|
|
|
copy = __copy__
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, Vector3):
|
|
return self.x == other.x and \
|
|
self.y == other.y and \
|
|
self.z == other.z
|
|
else:
|
|
assert hasattr(other, '__len__') and len(other) == 3
|
|
return self.x == other[0] and \
|
|
self.y == other[1] and \
|
|
self.z == other[2]
|
|
|
|
def __getattr__(self, name):
|
|
try:
|
|
return tuple([(self.x, self.y, self.z)['xyz'.index(c)] \
|
|
for c in name])
|
|
except ValueError:
|
|
raise AttributeError, name
|
|
|
|
def __getitem__(self, key):
|
|
return (self.x, self.y, self.z)[key]
|
|
|
|
def __iter__(self):
|
|
return iter((self.x, self.y, self.z))
|
|
|
|
def __len__(self):
|
|
return 3
|
|
|
|
def __repr__(self):
|
|
return 'Vector3(%.2f, %.2f, %.2f)' % (self.x,
|
|
self.y,
|
|
self.z)
|
|
|
|
if _enable_swizzle_set:
|
|
# This has detrimental performance on ordinary setattr as well
|
|
# if enabled
|
|
def __setattr__(self, name, value):
|
|
if len(name) == 1:
|
|
object.__setattr__(self, name, value)
|
|
else:
|
|
try:
|
|
l = [self.x, self.y, self.z]
|
|
for c, v in map(None, name, value):
|
|
l['xyz'.index(c)] = v
|
|
self.x, self.y, self.z = l
|
|
except ValueError:
|
|
raise AttributeError, name
|
|
|
|
def __setitem__(self, key, value):
|
|
l = [self.x, self.y, self.z]
|
|
l[key] = value
|
|
self.x, self.y, self.z = l
|
|
|
|
"""
|