* Bug fixes by Stéphane Grabli with respect to pyZDependingThicknessShader,
pyMaterialColorShader, pyBluePrintEllipsesShader and pyBluePrintSquaresShader. * Fixes for Vector instantiation that now takes only a sequence object of 2, 3, or 4 elements -- an API change in revision 28417. * Deleted vector.py that is no longer used.
This commit is contained in:
Tamito Kajiyama
parent
ae9b9b43e6
commit
d347a27a97
@ -62,7 +62,7 @@ class pyViewMapGradientVectorF0D(UnaryFunction0DVec2f):
|
||||
p = iter.getObject().getPoint2D()
|
||||
gx = ReadCompleteViewMapPixelCF(self._l, int(p.x()+self._step), int(p.y()))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
|
||||
gy = ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
|
||||
return Vector(gx, gy)
|
||||
return Vector([gx, gy])
|
||||
|
||||
class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
|
||||
def __init__(self, l):
|
||||
@ -75,7 +75,7 @@ class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
|
||||
p = iter.getObject().getPoint2D()
|
||||
gx = ReadCompleteViewMapPixelCF(self._l, int(p.x()+self._step), int(p.y()))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
|
||||
gy = ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
|
||||
grad = Vector(gx, gy)
|
||||
grad = Vector([gx, gy])
|
||||
return grad.length
|
||||
|
||||
|
||||
|
||||
@ -307,11 +307,11 @@ class pyImportance2DThicknessShader(StrokeShader):
|
||||
def getName(self):
|
||||
return "pyImportanceThicknessShader"
|
||||
def shade(self, stroke):
|
||||
origin = Vector(self._x, self._y)
|
||||
origin = Vector([self._x, self._y])
|
||||
it = stroke.strokeVerticesBegin()
|
||||
while it.isEnd() == 0:
|
||||
v = it.getObject()
|
||||
p = Vector(v.getProjectedX(), v.getProjectedY())
|
||||
p = Vector([v.getProjectedX(), v.getProjectedY()])
|
||||
d = (p-origin).length
|
||||
if(d>self._w):
|
||||
k = self._kmin
|
||||
@ -336,11 +336,11 @@ class pyImportance3DThicknessShader(StrokeShader):
|
||||
def getName(self):
|
||||
return "pyImportance3DThicknessShader"
|
||||
def shade(self, stroke):
|
||||
origin = Vector(self._x, self._y, self._z)
|
||||
origin = Vector([self._x, self._y, self._z])
|
||||
it = stroke.strokeVerticesBegin()
|
||||
while it.isEnd() == 0:
|
||||
v = it.getObject()
|
||||
p = Vector(v.getX(), v.getY(), v.getZ())
|
||||
p = Vector([v.getX(), v.getY(), v.getZ()])
|
||||
d = (p-origin).length
|
||||
if(d>self._w):
|
||||
k = self._kmin
|
||||
@ -368,7 +368,7 @@ class pyZDependingThicknessShader(StrokeShader):
|
||||
z = self.__func(it.castToInterface0DIterator())
|
||||
if z < z_min:
|
||||
z_min = z
|
||||
elif z > z_max:
|
||||
if z > z_max:
|
||||
z_max = z
|
||||
it.increment()
|
||||
z_diff = 1 / (z_max - z_min)
|
||||
@ -507,6 +507,10 @@ class pyMaterialColorShader(StrokeShader):
|
||||
g = -0.969256 * X + 1.875991 * Y + 0.041556 * Z
|
||||
b = 0.055648 * X - 0.204043 * Y + 1.057311 * Z
|
||||
|
||||
r = max(0,r)
|
||||
g = max(0,g)
|
||||
b = max(0,b)
|
||||
|
||||
att = it.getObject().attribute()
|
||||
att.setColor(r, g, b)
|
||||
it.increment()
|
||||
@ -592,10 +596,10 @@ class pyBackboneStretcherShader(StrokeShader):
|
||||
v1 = it1.getObject()
|
||||
vn_1 = itn_1.getObject()
|
||||
vn = itn.getObject()
|
||||
p0 = Vector(v0.getProjectedX(), v0.getProjectedY())
|
||||
pn = Vector(vn.getProjectedX(), vn.getProjectedY())
|
||||
p1 = Vector(v1.getProjectedX(), v1.getProjectedY())
|
||||
pn_1 = Vector(vn_1.getProjectedX(), vn_1.getProjectedY())
|
||||
p0 = Vector([v0.getProjectedX(), v0.getProjectedY()])
|
||||
pn = Vector([vn.getProjectedX(), vn.getProjectedY()])
|
||||
p1 = Vector([v1.getProjectedX(), v1.getProjectedY()])
|
||||
pn_1 = Vector([vn_1.getProjectedX(), vn_1.getProjectedY()])
|
||||
d1 = p0-p1
|
||||
d1.normalize()
|
||||
dn = pn-pn_1
|
||||
@ -625,10 +629,10 @@ class pyLengthDependingBackboneStretcherShader(StrokeShader):
|
||||
v1 = it1.getObject()
|
||||
vn_1 = itn_1.getObject()
|
||||
vn = itn.getObject()
|
||||
p0 = Vector(v0.getProjectedX(), v0.getProjectedY())
|
||||
pn = Vector(vn.getProjectedX(), vn.getProjectedY())
|
||||
p1 = Vector(v1.getProjectedX(), v1.getProjectedY())
|
||||
pn_1 = Vector(vn_1.getProjectedX(), vn_1.getProjectedY())
|
||||
p0 = Vector([v0.getProjectedX(), v0.getProjectedY()])
|
||||
pn = Vector([vn.getProjectedX(), vn.getProjectedY()])
|
||||
p1 = Vector([v1.getProjectedX(), v1.getProjectedY()])
|
||||
pn_1 = Vector([vn_1.getProjectedX(), vn_1.getProjectedY()])
|
||||
d1 = p0-p1
|
||||
d1.normalize()
|
||||
dn = pn-pn_1
|
||||
@ -777,8 +781,8 @@ class pyTVertexRemoverShader(StrokeShader):
|
||||
class pyExtremitiesOrientationShader(StrokeShader):
|
||||
def __init__(self, x1,y1,x2=0,y2=0):
|
||||
StrokeShader.__init__(self)
|
||||
self._v1 = Vector(x1,y1)
|
||||
self._v2 = Vector(x2,y2)
|
||||
self._v1 = Vector([x1,y1])
|
||||
self._v2 = Vector([x2,y2])
|
||||
def getName(self):
|
||||
return "pyExtremitiesOrientationShader"
|
||||
def shade(self, stroke):
|
||||
@ -940,7 +944,7 @@ class pyPerlinNoise2DShader(StrokeShader):
|
||||
it = stroke.strokeVerticesBegin()
|
||||
while it.isEnd() == 0:
|
||||
v = it.getObject()
|
||||
vec = Vector(v.getProjectedX(), v.getProjectedY())
|
||||
vec = Vector([v.getProjectedX(), v.getProjectedY()])
|
||||
nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
|
||||
v.setPoint(v.getProjectedX() + nres, v.getProjectedY() + nres)
|
||||
it.increment()
|
||||
@ -952,8 +956,8 @@ class pyBluePrintCirclesShader(StrokeShader):
|
||||
def getName(self):
|
||||
return "pyBluePrintCirclesShader"
|
||||
def shade(self, stroke):
|
||||
p_min = Vector(10000, 10000)
|
||||
p_max = Vector(0, 0)
|
||||
p_min = Vector([10000, 10000])
|
||||
p_max = Vector([0, 0])
|
||||
it = stroke.strokeVerticesBegin()
|
||||
while it.isEnd() == 0:
|
||||
p = it.getObject().getPoint()
|
||||
@ -976,7 +980,7 @@ class pyBluePrintCirclesShader(StrokeShader):
|
||||
sv_nb = sv_nb / self.__turns
|
||||
center = (p_min + p_max) / 2
|
||||
radius = (center.x - p_min.x + center.y - p_min.y) / 2
|
||||
p_new = Vector(0, 0)
|
||||
p_new = Vector([0, 0])
|
||||
#######################################################
|
||||
it = stroke.strokeVerticesBegin()
|
||||
for j in range(self.__turns):
|
||||
@ -994,7 +998,6 @@ class pyBluePrintCirclesShader(StrokeShader):
|
||||
stroke.RemoveVertex(it.getObject())
|
||||
it.increment()
|
||||
|
||||
|
||||
class pyBluePrintEllipsesShader(StrokeShader):
|
||||
def __init__(self, turns = 1):
|
||||
StrokeShader.__init__(self)
|
||||
@ -1002,8 +1005,8 @@ class pyBluePrintEllipsesShader(StrokeShader):
|
||||
def getName(self):
|
||||
return "pyBluePrintEllipsesShader"
|
||||
def shade(self, stroke):
|
||||
p_min = Vector(10000, 10000)
|
||||
p_max = Vector(0, 0)
|
||||
p_min = Vector([10000, 10000])
|
||||
p_max = Vector([0, 0])
|
||||
it = stroke.strokeVerticesBegin()
|
||||
while it.isEnd() == 0:
|
||||
p = it.getObject().getPoint()
|
||||
@ -1018,16 +1021,11 @@ class pyBluePrintEllipsesShader(StrokeShader):
|
||||
it.increment()
|
||||
stroke.Resample(32 * self.__turns)
|
||||
sv_nb = stroke.strokeVerticesSize()
|
||||
# print("min :", p_min.x, p_min.y) # DEBUG
|
||||
# print("mean :", p_sum.x, p_sum.y) # DEBUG
|
||||
# print("max :", p_max.x, p_max.y) # DEBUG
|
||||
# print("----------------------") # DEBUG
|
||||
#######################################################
|
||||
sv_nb = sv_nb / self.__turns
|
||||
center = (p_min + p_max) / 2
|
||||
radius_x = center.x - p_min.x
|
||||
radius_y = center.y - p_min.y
|
||||
p_new = Vector(0, 0)
|
||||
p_new = Vector([0, 0])
|
||||
#######################################################
|
||||
it = stroke.strokeVerticesBegin()
|
||||
for j in range(self.__turns):
|
||||
@ -1036,7 +1034,7 @@ class pyBluePrintEllipsesShader(StrokeShader):
|
||||
center.x = center.x + randint(-5, 5)
|
||||
center.y = center.y + randint(-5, 5)
|
||||
i = 0
|
||||
while i < sv_nb:
|
||||
while i < sv_nb and it.isEnd() == 0:
|
||||
p_new.x = center.x + radius_x * cos(2 * pi * float(i) / float(sv_nb - 1))
|
||||
p_new.y = center.y + radius_y * sin(2 * pi * float(i) / float(sv_nb - 1))
|
||||
it.getObject().setPoint(p_new)
|
||||
@ -1052,11 +1050,13 @@ class pyBluePrintSquaresShader(StrokeShader):
|
||||
StrokeShader.__init__(self)
|
||||
self.__turns = turns
|
||||
self.__bb_len = bb_len
|
||||
|
||||
def getName(self):
|
||||
return "pyBluePrintSquaresShader"
|
||||
|
||||
def shade(self, stroke):
|
||||
p_min = Vector(10000, 10000)
|
||||
p_max = Vector(0, 0)
|
||||
p_min = Vector([10000, 10000])
|
||||
p_max = Vector([0, 0])
|
||||
it = stroke.strokeVerticesBegin()
|
||||
while it.isEnd() == 0:
|
||||
p = it.getObject().getPoint()
|
||||
@ -1077,20 +1077,20 @@ class pyBluePrintSquaresShader(StrokeShader):
|
||||
second = 2 * first
|
||||
third = 3 * first
|
||||
fourth = sv_nb
|
||||
vec_first = Vector(p_max.x - p_min.x + 2 * self.__bb_len, 0)
|
||||
vec_second = Vector(0, p_max.y - p_min.y + 2 * self.__bb_len)
|
||||
vec_first = Vector([p_max.x - p_min.x + 2 * self.__bb_len, 0])
|
||||
vec_second = Vector([0, p_max.y - p_min.y + 2 * self.__bb_len])
|
||||
vec_third = vec_first * -1
|
||||
vec_fourth = vec_second * -1
|
||||
p_first = Vector(p_min.x - self.__bb_len, p_min.y)
|
||||
p_second = Vector(p_max.x, p_min.y - self.__bb_len)
|
||||
p_third = Vector(p_max.x + self.__bb_len, p_max.y)
|
||||
p_fourth = Vector(p_min.x, p_max.y + self.__bb_len)
|
||||
p_first = Vector([p_min.x - self.__bb_len, p_min.y])
|
||||
p_second = Vector([p_max.x, p_min.y - self.__bb_len])
|
||||
p_third = Vector([p_max.x + self.__bb_len, p_max.y])
|
||||
p_fourth = Vector([p_min.x, p_max.y + self.__bb_len])
|
||||
#######################################################
|
||||
it = stroke.strokeVerticesBegin()
|
||||
visible = 1
|
||||
for j in range(self.__turns):
|
||||
i = 0
|
||||
while i < sv_nb:
|
||||
while i < sv_nb and it.isEnd() == 0:
|
||||
if i < first:
|
||||
p_new = p_first + vec_first * float(i)/float(first - 1)
|
||||
if i == first - 1:
|
||||
@ -1107,6 +1107,12 @@ class pyBluePrintSquaresShader(StrokeShader):
|
||||
p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
|
||||
if i == fourth - 1:
|
||||
visible = 0
|
||||
if it.getObject() == None:
|
||||
i = i + 1
|
||||
it.increment()
|
||||
if visible == 0:
|
||||
visible = 1
|
||||
continue
|
||||
it.getObject().setPoint(p_new)
|
||||
it.getObject().attribute().setVisible(visible)
|
||||
if visible == 0:
|
||||
@ -1128,9 +1134,9 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
|
||||
return "pyBluePrintDirectedSquaresShader"
|
||||
def shade(self, stroke):
|
||||
stroke.Resample(32 * self.__turns)
|
||||
p_mean = Vector(0, 0)
|
||||
p_min = Vector(10000, 10000)
|
||||
p_max = Vector(0, 0)
|
||||
p_mean = Vector([0, 0])
|
||||
p_min = Vector([10000, 10000])
|
||||
p_max = Vector([0, 0])
|
||||
it = stroke.strokeVerticesBegin()
|
||||
while it.isEnd() == 0:
|
||||
p = it.getObject().getPoint()
|
||||
@ -1169,11 +1175,11 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
|
||||
theta = atan(2 * p_var_xy / (p_var_xx - p_var_yy)) / 2
|
||||
## print(theta)
|
||||
if p_var_yy > p_var_xx:
|
||||
e1 = Vector(cos(theta + pi / 2), sin(theta + pi / 2)) * sqrt(lambda1) * self.__mult
|
||||
e2 = Vector(cos(theta + pi), sin(theta + pi)) * sqrt(lambda2) * self.__mult
|
||||
e1 = Vector([cos(theta + pi / 2), sin(theta + pi / 2)]) * sqrt(lambda1) * self.__mult
|
||||
e2 = Vector([cos(theta + pi), sin(theta + pi)]) * sqrt(lambda2) * self.__mult
|
||||
else:
|
||||
e1 = Vector(cos(theta), sin(theta)) * sqrt(lambda1) * self.__mult
|
||||
e2 = Vector(cos(theta + pi / 2), sin(theta + pi / 2)) * sqrt(lambda2) * self.__mult
|
||||
e1 = Vector([cos(theta), sin(theta)]) * sqrt(lambda1) * self.__mult
|
||||
e2 = Vector([cos(theta + pi / 2), sin(theta + pi / 2)]) * sqrt(lambda2) * self.__mult
|
||||
#######################################################
|
||||
sv_nb = sv_nb / self.__turns
|
||||
first = sv_nb / 4
|
||||
|
||||
@ -1,241 +0,0 @@
|
||||
# This module defines 3d geometrical vectors with the standard
|
||||
# operations on them.
|
||||
#
|
||||
# Written by: Konrad Hinsen
|
||||
# Last revision: 1996-1-26
|
||||
#
|
||||
|
||||
"""This module defines three-dimensional geometrical vectors. Vectors support
|
||||
the usual mathematical operations (v1, v2: vectors, s: scalar):
|
||||
v1+v2 addition
|
||||
v1-v2 subtraction
|
||||
v1*v2 scalar product
|
||||
s*v1 multiplication with a scalar
|
||||
v1/s division by a scalar
|
||||
v1.cross(v2) cross product
|
||||
v1.length() length
|
||||
v1.normal() normal vector in direction of v1
|
||||
v1.angle(v2) angle between two vectors
|
||||
v1.x(), v1[0] first element
|
||||
v1.y(), v1[1] second element
|
||||
v1.z(), v1[2] third element
|
||||
|
||||
The module offers the following items for export:
|
||||
Vec3D(x,y,z) the constructor for vectors
|
||||
isVector(x) a type check function
|
||||
ex, ey, ez unit vectors along the x-, y-, and z-axes (predefined constants)
|
||||
|
||||
Note: vector elements can be any kind of numbers on which the operations
|
||||
addition, subtraction, multiplication, division, comparison, sqrt, and acos
|
||||
are defined. Integer elements are treated as floating point elements.
|
||||
"""
|
||||
|
||||
import math, types
|
||||
|
||||
class Vec3:
|
||||
|
||||
isVec3 = 1
|
||||
|
||||
def __init__(self, x=0., y=0., z=0.):
|
||||
self.data = [x,y,z]
|
||||
|
||||
def __repr__(self):
|
||||
return 'Vec3(%s,%s,%s)' % (`self.data[0]`,\
|
||||
`self.data[1]`,`self.data[2]`)
|
||||
|
||||
def __str__(self):
|
||||
return `self.data`
|
||||
|
||||
def __add__(self, other):
|
||||
return Vec3(self.data[0]+other.data[0],\
|
||||
self.data[1]+other.data[1],self.data[2]+other.data[2])
|
||||
__radd__ = __add__
|
||||
|
||||
def __neg__(self):
|
||||
return Vec3(-self.data[0], -self.data[1], -self.data[2])
|
||||
|
||||
def __sub__(self, other):
|
||||
return Vec3(self.data[0]-other.data[0],\
|
||||
self.data[1]-other.data[1],self.data[2]-other.data[2])
|
||||
|
||||
def __rsub__(self, other):
|
||||
return Vec3(other.data[0]-self.data[0],\
|
||||
other.data[1]-self.data[1],other.data[2]-self.data[2])
|
||||
|
||||
def __mul__(self, other):
|
||||
if isVec3(other):
|
||||
return reduce(lambda a,b: a+b,
|
||||
map(lambda a,b: a*b, self.data, other.data))
|
||||
else:
|
||||
return Vec3(self.data[0]*other, self.data[1]*other,
|
||||
self.data[2]*other)
|
||||
|
||||
def __rmul__(self, other):
|
||||
if isVec3(other):
|
||||
return reduce(lambda a,b: a+b,
|
||||
map(lambda a,b: a*b, self.data, other.data))
|
||||
else:
|
||||
return Vec3(other*self.data[0], other*self.data[1],
|
||||
other*self.data[2])
|
||||
|
||||
def __div__(self, other):
|
||||
if isVec3(other):
|
||||
raise TypeError, "Can't divide by a vector"
|
||||
else:
|
||||
return Vec3(_div(self.data[0],other), _div(self.data[1],other),
|
||||
_div(self.data[2],other))
|
||||
|
||||
def __rdiv__(self, other):
|
||||
raise TypeError, "Can't divide by a vector"
|
||||
|
||||
def __cmp__(self, other):
|
||||
return cmp(self.data[0],other.data[0]) \
|
||||
or cmp(self.data[1],other.data[1]) \
|
||||
or cmp(self.data[2],other.data[2])
|
||||
|
||||
def __getitem__(self, index):
|
||||
return self.data[index]
|
||||
|
||||
def x(self):
|
||||
return self.data[0]
|
||||
def y(self):
|
||||
return self.data[1]
|
||||
def z(self):
|
||||
return self.data[2]
|
||||
|
||||
def length(self):
|
||||
return math.sqrt(self*self)
|
||||
|
||||
def normal(self):
|
||||
len = self.length()
|
||||
if len == 0:
|
||||
raise ZeroDivisionError, "Can't normalize a zero-length vector"
|
||||
return self/len
|
||||
|
||||
def cross(self, other):
|
||||
if not isVec3(other):
|
||||
raise TypeError, "Cross product with non-vector"
|
||||
return Vec3(self.data[1]*other.data[2]-self.data[2]*other.data[1],
|
||||
self.data[2]*other.data[0]-self.data[0]*other.data[2],
|
||||
self.data[0]*other.data[1]-self.data[1]*other.data[0])
|
||||
|
||||
def angle(self, other):
|
||||
if not isVec3(other):
|
||||
raise TypeError, "Angle between vector and non-vector"
|
||||
cosa = (self*other)/(self.length()*other.length())
|
||||
cosa = max(-1.,min(1.,cosa))
|
||||
return math.acos(cosa)
|
||||
|
||||
|
||||
class Vec2:
|
||||
|
||||
isVec2 = 1
|
||||
|
||||
def __init__(self, x=0., y=0.):
|
||||
self.data = [x,y]
|
||||
|
||||
def __repr__(self):
|
||||
return 'Vec2(%s,%s,%s)' % (`self.data[0]`,\
|
||||
`self.data[1]`)
|
||||
|
||||
def __str__(self):
|
||||
return `self.data`
|
||||
|
||||
def __add__(self, other):
|
||||
return Vec2(self.data[0]+other.data[0],\
|
||||
self.data[1]+other.data[1])
|
||||
__radd__ = __add__
|
||||
|
||||
def __neg__(self):
|
||||
return Vec2(-self.data[0], -self.data[1])
|
||||
|
||||
def __sub__(self, other):
|
||||
return Vec2(self.data[0]-other.data[0],\
|
||||
self.data[1]-other.data[1])
|
||||
|
||||
def __rsub__(self, other):
|
||||
return Vec2(other.data[0]-self.data[0],\
|
||||
other.data[1]-self.data[1])
|
||||
|
||||
def __mul__(self, other):
|
||||
if isVec2(other):
|
||||
return reduce(lambda a,b: a+b,
|
||||
map(lambda a,b: a*b, self.data, other.data))
|
||||
else:
|
||||
return Vec2(self.data[0]*other, self.data[1]*other)
|
||||
|
||||
def __rmul__(self, other):
|
||||
if isVec2(other):
|
||||
return reduce(lambda a,b: a+b,
|
||||
map(lambda a,b: a*b, self.data, other.data))
|
||||
else:
|
||||
return Vec2(other*self.data[0], other*self.data[1])
|
||||
|
||||
def __div__(self, other):
|
||||
if isVec2(other):
|
||||
raise TypeError, "Can't divide by a vector"
|
||||
else:
|
||||
return Vec2(_div(self.data[0],other), _div(self.data[1],other))
|
||||
|
||||
def __rdiv__(self, other):
|
||||
raise TypeError, "Can't divide by a vector"
|
||||
|
||||
def __cmp__(self, other):
|
||||
return cmp(self.data[0],other.data[0]) \
|
||||
or cmp(self.data[1],other.data[1])
|
||||
|
||||
def __getitem__(self, index):
|
||||
return self.data[index]
|
||||
|
||||
def x(self):
|
||||
return self.data[0]
|
||||
def y(self):
|
||||
return self.data[1]
|
||||
|
||||
def length(self):
|
||||
return math.sqrt(self*self)
|
||||
|
||||
def normal(self):
|
||||
len = self.length()
|
||||
if len == 0:
|
||||
raise ZeroDivisionError, "Can't normalize a zero-length vector"
|
||||
return self/len
|
||||
|
||||
#def cross(self, other):
|
||||
# if not isVec2(other):
|
||||
# raise TypeError, "Cross product with non-vector"
|
||||
# return Vec2(self.data[1]*other.data[2]-self.data[2]*other.data[1],
|
||||
# self.data[2]*other.data[0]-self.data[0]*other.data[2],
|
||||
# self.data[0]*other.data[1]-self.data[1]*other.data[0])
|
||||
|
||||
def angle(self, other):
|
||||
if not isVec2(other):
|
||||
raise TypeError, "Angle between vector and non-vector"
|
||||
cosa = (self*other)/(self.length()*other.length())
|
||||
cosa = max(-1.,min(1.,cosa))
|
||||
return math.acos(cosa)
|
||||
|
||||
|
||||
|
||||
# Type check
|
||||
|
||||
def isVec3(x):
|
||||
return hasattr(x,'isVec3')
|
||||
|
||||
def isVec2(x):
|
||||
return hasattr(x,'isVec2')
|
||||
|
||||
# "Correct" division for arbitrary number types
|
||||
|
||||
def _div(a,b):
|
||||
if type(a) == types.IntType and type(b) == types.IntType:
|
||||
return float(a)/float(b)
|
||||
else:
|
||||
return a/b
|
||||
|
||||
|
||||
# Some useful constants
|
||||
|
||||
ex = Vec3(1.,0.,0.)
|
||||
ey = Vec3(0.,1.,0.)
|
||||
ez = Vec3(0.,0.,1.)
|
||||
Loading…
Reference in New Issue
Block a user