* 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.

3 files changed, 53 insertions, 288 deletions

diff --git a/release/scripts/freestyle/style_modules/Functions0D.py b/release/scripts/freestyle/style_modules/Functions0D.py
index fd7346df7df..2881a80c386 100755
--- a/release/scripts/freestyle/style_modules/Functions0D.py
+++ b/release/scripts/freestyle/style_modules/Functions0D.py
@@ -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
 
 
diff --git a/release/scripts/freestyle/style_modules/shaders.py b/release/scripts/freestyle/style_modules/shaders.py
index 26093595f7a..4d8ddeb0ce8 100755
--- a/release/scripts/freestyle/style_modules/shaders.py
+++ b/release/scripts/freestyle/style_modules/shaders.py
@@ -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
diff --git a/release/scripts/freestyle/style_modules/vector.py b/release/scripts/freestyle/style_modules/vector.py
deleted file mode 100755
index 039f262546b..00000000000
--- a/release/scripts/freestyle/style_modules/vector.py
+++ /dev/null
@@ -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.)