From d347a27a977db20c0437578f6505432cec3775fb Mon Sep 17 00:00:00 2001 From: Tamito Kajiyama Date: Tue, 6 Jul 2010 20:07:07 +0000 Subject: [PATCH] =?UTF-8?q?*=20Bug=20fixes=20by=20St=C3=A9phane=20Grabli?= =?UTF-8?q?=20with=20respect=20to=20pyZDependingThicknessShader,=20pyMater?= =?UTF-8?q?ialColorShader,=20pyBluePrintEllipsesShader=20and=20pyBluePrint?= =?UTF-8?q?SquaresShader.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 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. --- .../freestyle/style_modules/Functions0D.py | 4 +- .../freestyle/style_modules/shaders.py | 96 +++---- .../scripts/freestyle/style_modules/vector.py | 241 ------------------ 3 files changed, 53 insertions(+), 288 deletions(-) delete mode 100755 release/scripts/freestyle/style_modules/vector.py 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.)