Fix for __repr__() depending on .getName() and .getExactTypeName().
authorTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Sat, 23 Feb 2013 12:17:40 +0000 (12:17 +0000)
committerTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Sat, 23 Feb 2013 12:17:40 +0000 (12:17 +0000)
API users no longer need to define them in user-defined Functions, Predicates and StrokeShaders.
Also removed all .getName() and .getExactTypeName() definitions in pre-defined Functions,
Predicates and StrokeShaders subclasses.

14 files changed:
release/scripts/freestyle/style_modules/ChainingIterators.py
release/scripts/freestyle/style_modules/Functions0D.py
release/scripts/freestyle/style_modules/Functions1D.py
release/scripts/freestyle/style_modules/PredicatesB1D.py
release/scripts/freestyle/style_modules/PredicatesU0D.py
release/scripts/freestyle/style_modules/PredicatesU1D.py
release/scripts/freestyle/style_modules/logical_operators.py
release/scripts/freestyle/style_modules/long_anisotropically_dense.py
release/scripts/freestyle/style_modules/parameter_editor.py
release/scripts/freestyle/style_modules/shaders.py
source/blender/freestyle/intern/python/BPy_Iterator.cpp
source/blender/freestyle/intern/python/BPy_StrokeShader.cpp
source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp
source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp

index 4c6343d5059fb6a58851cd9317b5dd1a420f6f48..97654e0bf88a4360ba97597f506d01f2428c4d32 100644 (file)
@@ -35,8 +35,6 @@ from freestyle_init import *
 class pyChainSilhouetteIterator(ChainingIterator):
        def __init__(self, stayInSelection=True):
                ChainingIterator.__init__(self, stayInSelection, True, None, True)
-       def getExactTypeName(self):
-               return "pyChainSilhouetteIterator"
        def init(self):
                pass
        def traverse(self, iter):
@@ -87,8 +85,6 @@ class pyChainSilhouetteIterator(ChainingIterator):
 class pyChainSilhouetteGenericIterator(ChainingIterator):
        def __init__(self, stayInSelection=True, stayInUnvisited=True):
                ChainingIterator.__init__(self, stayInSelection, stayInUnvisited, None, True)
-       def getExactTypeName(self):
-               return "pyChainSilhouetteGenericIterator"
        def init(self):
                pass
        def traverse(self, iter):
@@ -137,8 +133,6 @@ class pyExternalContourChainingIterator(ChainingIterator):
        def __init__(self):
                ChainingIterator.__init__(self, False, True, None, True)
                self._isExternalContour = ExternalContourUP1D()
-       def getExactTypeName(self):
-               return "pyExternalContourIterator"
        def init(self):
                self._nEdges = 0
                self._isInSelection = 1
@@ -186,8 +180,6 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
                ChainingIterator.__init__(self, stayInSelection, False, None, True)
                self._timeStamp = GetTimeStampCF()+nRounds
                self._nRounds = nRounds
-       def getExactTypeName(self):
-               return "pySketchyChainSilhouetteIterator"
        def init(self):
                self._timeStamp = GetTimeStampCF()+self._nRounds
        def traverse(self, iter):
@@ -245,8 +237,6 @@ class pySketchyChainingIterator(ChainingIterator):
                ChainingIterator.__init__(self, stayInSelection, False, None, True)
                self._timeStamp = GetTimeStampCF()+nRounds
                self._nRounds = nRounds
-       def getExactTypeName(self):
-               return "pySketchyChainingIterator"
        def init(self):
                self._timeStamp = GetTimeStampCF()+self._nRounds
        def traverse(self, iter):
@@ -275,8 +265,6 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
                ChainingIterator.__init__(self, False, True, None, True)
                self._length = 0
                self._percent = float(percent)
-       def getExactTypeName(self):
-               return "pyFillOcclusionsChainingIterator"
        def init(self):
                # each time we're evaluating a chain length 
                # we try to do it once. Thus we reinit 
@@ -377,8 +365,6 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
        def __init__(self, length):
                ChainingIterator.__init__(self, False, True, None, True)
                self._length = float(length)
-       def getExactTypeName(self):
-               return "pySmallFillOcclusionsChainingIterator"
        def init(self):
                pass
        def traverse(self, iter):
@@ -449,8 +435,6 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
                self._length = 0
                self._absLength = l
                self._percent = float(percent)
-       def getExactTypeName(self):
-               return "pyFillOcclusionsChainingIterator"
        def init(self):
                # each time we're evaluating a chain length 
                # we try to do it once. Thus we reinit 
@@ -554,8 +538,6 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
                self._length = 0
                self._absLength = l
                self._percent = float(percent)
-       def getExactTypeName(self):
-               return "pyFillOcclusionsChainingIterator"
        def init(self):
                # each time we're evaluating a chain length 
                # we try to do it once. Thus we reinit 
@@ -657,8 +639,6 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
 class pyNoIdChainSilhouetteIterator(ChainingIterator):
        def __init__(self, stayInSelection=True):
                ChainingIterator.__init__(self, stayInSelection, True, None, True)
-       def getExactTypeName(self):
-               return "pyChainSilhouetteIterator"
        def init(self):
                pass
        def traverse(self, iter):
index 2cd852180f8d1569acb445ef37def05ecb7556ab..ffdddaa4a1ff8fbde3c433cab53b113e7c15e557 100644 (file)
@@ -3,8 +3,6 @@ from freestyle_init import *
 class CurveMaterialF0D(UnaryFunction0DMaterial):
        # A replacement of the built-in MaterialF0D for stroke creation.
        # MaterialF0D does not work with Curves and Strokes.
-       def getName(self):
-               return "CurveMaterialF0D"
        def __call__(self, inter):
                cp = inter.object
                assert(isinstance(cp, CurvePoint))
@@ -13,18 +11,12 @@ class CurveMaterialF0D(UnaryFunction0DMaterial):
                return fe.material if fe.is_smooth else fe.material_left
 
 class pyInverseCurvature2DAngleF0D(UnaryFunction0DDouble):
-       def getName(self):
-               return "InverseCurvature2DAngleF0D"
-
        def __call__(self, inter):
                func = Curvature2DAngleF0D()
                c = func(inter)
                return (3.1415 - c)
 
 class pyCurvilinearLengthF0D(UnaryFunction0DDouble):
-       def getName(self):
-               return "CurvilinearLengthF0D"
-
        def __call__(self, inter):
                cp = inter.object               
                assert(isinstance(cp, CurvePoint))
@@ -39,8 +31,6 @@ class pyDensityAnisotropyF0D(UnaryFunction0DDouble):
                self.d1Density = ReadSteerableViewMapPixelF0D(1, level)
                self.d2Density = ReadSteerableViewMapPixelF0D(2, level)
                self.d3Density = ReadSteerableViewMapPixelF0D(3, level)
-       def getName(self):
-               return "pyDensityAnisotropyF0D"
        def __call__(self, inter):
                c_iso = self.IsoDensity(inter) 
                c_0 = self.d0Density(inter) 
@@ -63,8 +53,6 @@ class pyViewMapGradientVectorF0D(UnaryFunction0DVec2f):
                UnaryFunction0DVec2f.__init__(self)
                self._l = l
                self._step = pow(2,self._l)
-       def getName(self):
-               return "pyViewMapGradientVectorF0D"
        def __call__(self, iter):
                p = iter.object.point_2d
                gx = ReadCompleteViewMapPixelCF(self._l, int(p.x+self._step), int(p.y))- ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y))
@@ -76,8 +64,6 @@ class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
                UnaryFunction0DDouble.__init__(self)
                self._l = l
                self._step = pow(2,self._l)
-       def getName(self):
-               return "pyViewMapGradientNormF0D"
        def __call__(self, iter):
                p = iter.object.point_2d
                gx = ReadCompleteViewMapPixelCF(self._l, int(p.x+self._step), int(p.y))- ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y))
index aaf115356cb5575020e242ea5a6eb17cb0bca079..6482d0ae7f57d7ce7287647713dfe6bf61eb7a79 100644 (file)
@@ -3,18 +3,12 @@ from Functions0D import *
 import string 
 
 class pyGetInverseProjectedZF1D(UnaryFunction1DDouble):
-       def getName(self):
-               return "pyGetInverseProjectedZF1D"
-
        def __call__(self, inter):
                func = GetProjectedZF1D()
                z = func(inter)
                return (1.0 - z)
 
 class pyGetSquareInverseProjectedZF1D(UnaryFunction1DDouble):
-       def getName(self):
-               return "pyGetInverseProjectedZF1D"
-
        def __call__(self, inter):
                func = GetProjectedZF1D()
                z = func(inter)
@@ -26,8 +20,6 @@ class pyDensityAnisotropyF1D(UnaryFunction1DDouble):
                self._func = pyDensityAnisotropyF0D(level)
                self._integration = integrationType
                self._sampling = sampling
-       def getName(self):
-               return "pyDensityAnisotropyF1D"
        def __call__(self, inter):
                v = integrate(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
                return v
@@ -38,8 +30,6 @@ class pyViewMapGradientNormF1D(UnaryFunction1DDouble):
                self._func = pyViewMapGradientNormF0D(l)
                self._integration = integrationType
                self._sampling = sampling
-       def getName(self):
-               return "pyViewMapGradientNormF1D"
        def __call__(self, inter):
                v = integrate(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
                return v
index 6b7872702339490f812ef494ac300fc7e338d633..7fee9a15e8aa01efa7e1566fcad084ce82fcda28 100644 (file)
@@ -3,8 +3,6 @@ from Functions1D import *
 from random import *
 
 class pyZBP1D(BinaryPredicate1D):
-       def getName(self):
-               return "pyZBP1D"
        def __call__(self, i1, i2):
                func = GetZF1D()
                return (func(i1) > func(i2))
@@ -13,20 +11,14 @@ class pyZDiscontinuityBP1D(BinaryPredicate1D):
        def __init__(self, iType = IntegrationType.MEAN):
                BinaryPredicate1D.__init__(self)
                self._GetZDiscontinuity = ZDiscontinuityF1D(iType)
-       def getName(self):
-               return "pyZDiscontinuityBP1D"
        def __call__(self, i1, i2):
                return (self._GetZDiscontinuity(i1) > self._GetZDiscontinuity(i2))
 
 class pyLengthBP1D(BinaryPredicate1D):
-       def getName(self):
-               return "LengthBP1D"
        def __call__(self, i1, i2):
                return (i1.length_2d > i2.length_2d)
 
 class pySilhouetteFirstBP1D(BinaryPredicate1D):
-       def getName(self):
-               return "SilhouetteFirstBP1D"
        def __call__(self, inter1, inter2):
                bpred = SameShapeIdBP1D()
                if (bpred(inter1, inter2) != 1):
@@ -36,8 +28,6 @@ class pySilhouetteFirstBP1D(BinaryPredicate1D):
                return (inter1.nature == inter2.nature)
 
 class pyNatureBP1D(BinaryPredicate1D):
-       def getName(self):
-               return "NatureBP1D"
        def __call__(self, inter1, inter2):
                return (inter1.nature & inter2.nature)
 
@@ -45,8 +35,6 @@ class pyViewMapGradientNormBP1D(BinaryPredicate1D):
        def __init__(self,l, sampling=2.0):
                BinaryPredicate1D.__init__(self)
                self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
-       def getName(self):
-               return "pyViewMapGradientNormBP1D"
        def __call__(self, i1,i2):
                print("compare gradient")
                return (self._GetGradient(i1) > self._GetGradient(i2))
@@ -55,8 +43,6 @@ class pyShuffleBP1D(BinaryPredicate1D):
        def __init__(self):
                BinaryPredicate1D.__init__(self)
                seed(1)
-       def getName(self):
-               return "pyNearAndContourFirstBP1D"
        def __call__(self, inter1, inter2):
                r1 = uniform(0,1)
                r2 = uniform(0,1)
index 1f657235d998f3ffca35da6a675171d26404323a..65cfbefb8028f3d0c73761e03d341af511945ed4 100644 (file)
@@ -5,8 +5,6 @@ class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):
        def __init__(self,a):
                UnaryPredicate0D.__init__(self)
                self._a = a
-       def getName(self):
-               return "HigherCurvature2DAngleUP0D"
        def __call__(self, inter):
                func = Curvature2DAngleF0D()
                a = func(inter)
@@ -17,8 +15,6 @@ class pyUEqualsUP0D(UnaryPredicate0D):
                UnaryPredicate0D.__init__(self)
                self._u = u
                self._w = w
-       def getName(self):
-               return "UEqualsUP0D"
        def __call__(self, inter):
                func = pyCurvilinearLengthF0D()
                u = func(inter)
@@ -28,8 +24,6 @@ class pyVertexNatureUP0D(UnaryPredicate0D):
        def __init__(self,nature):
                UnaryPredicate0D.__init__(self)
                self._nature = nature
-       def getName(self):
-               return "pyVertexNatureUP0D"
        def __call__(self, inter):
                v = inter.object
                return (v.nature & self._nature) != 0
@@ -41,8 +35,6 @@ class pyBackTVertexUP0D(UnaryPredicate0D):
        def __init__(self):
                UnaryPredicate0D.__init__(self)
                self._getQI = QuantitativeInvisibilityF0D()
-       def getName(self):
-               return "pyBackTVertexUP0D"
        def __call__(self, iter):
                if (iter.object.nature & Nature.T_VERTEX) == 0:
                        return 0
@@ -58,8 +50,6 @@ class pyParameterUP0DGoodOne(UnaryPredicate0D):
                self._m = pmin
                self._M = pmax
                #self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
-       def getName(self):
-               return "pyCurvilinearAbscissaHigherThanUP0D"
        def __call__(self, inter):
                #s = self.getCurvilinearAbscissa(inter)
                u = inter.u
@@ -72,8 +62,6 @@ class pyParameterUP0D(UnaryPredicate0D):
                self._m = pmin
                self._M = pmax
                #self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
-       def getName(self):
-               return "pyCurvilinearAbscissaHigherThanUP0D"
        def __call__(self, inter):
                func = Curvature2DAngleF0D()
                c = func(inter)
index 3938bbb2d02a1d1f66bf9cef8a24628065f816cf..d4c1e01306115c0749934547173cef81ca14c23f 100644 (file)
@@ -17,8 +17,6 @@ class pyHigherLengthUP1D(UnaryPredicate1D):
        def __init__(self,l):
                UnaryPredicate1D.__init__(self)
                self._l = l
-       def getName(self):
-               return "HigherLengthUP1D"
        def __call__(self, inter):
                return (inter.length_2d > self._l)
 
@@ -27,8 +25,6 @@ class pyNatureUP1D(UnaryPredicate1D):
                UnaryPredicate1D.__init__(self)
                self._nature = nature
                self._getNature = CurveNatureF1D()
-       def getName(self):
-               return "pyNatureUP1D"
        def __call__(self, inter):
                if(self._getNature(inter) & self._nature):
                        return 1
@@ -39,8 +35,6 @@ class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
                UnaryPredicate1D.__init__(self)
                self._n = n
                self._a = a
-       def getName(self):
-               return "HigherNumberOfTurnsUP1D"
        def __call__(self, inter):
                count = 0
                func = Curvature2DAngleF0D()
@@ -60,8 +54,6 @@ class pyDensityUP1D(UnaryPredicate1D):
                self._threshold = threshold
                self._integration = integration
                self._func = DensityF1D(self._wsize, self._integration, sampling)
-       def getName(self):
-               return "pyDensityUP1D"
        def __call__(self, inter):
                if self._func(inter) < self._threshold:
                        return 1
@@ -73,8 +65,6 @@ class pyLowSteerableViewMapDensityUP1D(UnaryPredicate1D):
                self._threshold = threshold
                self._level = level
                self._integration = integration
-       def getName(self):
-               return "pyLowSteerableViewMapDensityUP1D"
        def __call__(self, inter):
                func = GetSteerableViewMapDensityF1D(self._level, self._integration)
                v = func(inter)
@@ -90,8 +80,6 @@ class pyLowDirectionalViewMapDensityUP1D(UnaryPredicate1D):
                self._orientation = orientation
                self._level = level
                self._integration = integration
-       def getName(self):
-               return "pyLowDirectionalViewMapDensityUP1D"
        def __call__(self, inter):
                func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration)
                v = func(inter)
@@ -107,8 +95,6 @@ class pyHighSteerableViewMapDensityUP1D(UnaryPredicate1D):
                self._level = level
                self._integration = integration
                self._func = GetSteerableViewMapDensityF1D(self._level, self._integration)      
-       def getName(self):
-               return "pyHighSteerableViewMapDensityUP1D"
        def __call__(self, inter):
                v = self._func(inter)
                if v > self._threshold:
@@ -123,8 +109,6 @@ class pyHighDirectionalViewMapDensityUP1D(UnaryPredicate1D):
                self._level = level
                self._integration = integration
                self._sampling = sampling               
-       def getName(self):
-               return "pyLowDirectionalViewMapDensityUP1D"
        def __call__(self, inter):
                func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration, self._sampling)
                v = func(inter)
@@ -140,12 +124,10 @@ class pyHighViewMapDensityUP1D(UnaryPredicate1D):
                self._integration = integration
                self._sampling = sampling
                self._func = GetCompleteViewMapDensityF1D(self._level, self._integration, self._sampling) # 2.0 is the smpling
-       def getName(self):
-               return "pyHighViewMapDensityUP1D"
        def __call__(self, inter):
                #print("toto")
-               #print(func.getName())
-               #print(inter.getExactTypeName())
+               #print(func.name)
+               #print(inter.name)
                v= self._func(inter)
                if v > self._threshold:
                        return 1
@@ -160,8 +142,6 @@ class pyDensityFunctorUP1D(UnaryPredicate1D):
                self._funcmin = float(funcmin)
                self._funcmax = float(funcmax)
                self._integration = integration
-       def getName(self):
-               return "pyDensityFunctorUP1D"
        def __call__(self, inter):
                func = DensityF1D(self._wsize, self._integration)
                res = self._functor(inter)
@@ -175,8 +155,6 @@ class pyZSmallerUP1D(UnaryPredicate1D):
                UnaryPredicate1D.__init__(self)
                self._z = z
                self._integration = integration
-       def getName(self):
-               return "pyZSmallerUP1D"
        def __call__(self, inter):
                func = GetProjectedZF1D(self._integration)
                if func(inter) < self._z:
@@ -187,8 +165,6 @@ class pyIsOccludedByUP1D(UnaryPredicate1D):
        def __init__(self,id):
                UnaryPredicate1D.__init__(self)
                self._id = id
-       def getName(self):
-               return "pyIsOccludedByUP1D"
        def __call__(self, inter):
                func = GetShapeF1D()
                shapes = func(inter)
@@ -226,8 +202,6 @@ class pyIsInOccludersListUP1D(UnaryPredicate1D):
        def __init__(self,id):
                UnaryPredicate1D.__init__(self)
                self._id = id
-       def getName(self):
-               return "pyIsInOccludersListUP1D"
        def __call__(self, inter):
                func = GetOccludersF1D()
                occluders = func(inter)
@@ -241,8 +215,6 @@ class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
                UnaryPredicate1D.__init__(self)
                self.__func1 = GetOccludersF1D()
                self.__func2 = GetShapeF1D()
-       def getName(self):
-               return "pyIsOccludedByItselfUP1D"
        def __call__(self, inter):
                lst1 = self.__func1(inter)
                lst2 = self.__func2(inter)
@@ -257,8 +229,6 @@ class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
                UnaryPredicate1D.__init__(self)
                self._idlist = idlist
                self.__func1 = GetOccludersF1D()
-       def getName(self):
-               return "pyIsOccludedByIdListUP1D"
        def __call__(self, inter):
                lst1 = self.__func1(inter)
                for vs1 in lst1:
@@ -274,8 +244,6 @@ class pyShapeIdListUP1D(UnaryPredicate1D):
                self._funcs = []
                for _id in idlist :
                        self._funcs.append(ShapeUP1D(_id.first, _id.second))
-       def getName(self):
-               return "pyShapeIdUP1D"
        def __call__(self, inter):
                for func in self._funcs :
                        if func(inter) == 1:
@@ -287,8 +255,6 @@ class pyShapeIdUP1D(UnaryPredicate1D):
        def __init__(self, _id):
                UnaryPredicate1D.__init__(self)
                self._id = _id
-       def getName(self):
-               return "pyShapeIdUP1D"
        def __call__(self, inter):
                func = GetShapeF1D()
                shapes = func(inter)
@@ -302,8 +268,6 @@ class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):
                UnaryPredicate1D.__init__(self)
                self._l = threshold
                self.func = pyDensityAnisotropyF1D(level, IntegrationType.MEAN, sampling)
-       def getName(self):
-               return "pyHighDensityAnisotropyUP1D"
        def __call__(self, inter):
                return (self.func(inter) > self._l)
 
@@ -312,8 +276,6 @@ class pyHighViewMapGradientNormUP1D(UnaryPredicate1D):
                UnaryPredicate1D.__init__(self)
                self._threshold = threshold
                self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
-       def getName(self):
-               return "pyHighViewMapGradientNormUP1D"
        def __call__(self, inter):
                gn = self._GetGradient(inter)
                #print(gn)
@@ -331,8 +293,6 @@ class pyDensityVariableSigmaUP1D(UnaryPredicate1D):
                self._tmax = tmax
                self._integration = integration
                self._sampling = sampling
-       def getName(self):
-               return "pyDensityUP1D"
        def __call__(self, inter):
                sigma = (self._sigmaMax-self._sigmaMin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._sigmaMin
                t = (self._tmax-self._tmin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._tmin
index 0ecf6623697abaff61f1a9ae1fb8d72378919aeb..d9a43f435509d2d2a91b4bad2c4253145ef63668 100644 (file)
@@ -5,10 +5,6 @@ class AndUP1D(UnaryPredicate1D):
         UnaryPredicate1D.__init__(self)
         self.__pred1 = pred1
         self.__pred2 = pred2
-
-    def getName(self):
-        return "AndUP1D"
-
     def __call__(self, inter):
         return self.__pred1(inter) and self.__pred2(inter)
     
@@ -17,10 +13,6 @@ class OrUP1D(UnaryPredicate1D):
         UnaryPredicate1D.__init__(self)
         self.__pred1 = pred1
         self.__pred2 = pred2
-
-    def getName(self):
-        return "OrUP1D"
-
     def __call__(self, inter):
         return self.__pred1(inter) or self.__pred2(inter)
 
@@ -28,9 +20,5 @@ class NotUP1D(UnaryPredicate1D):
        def __init__(self, pred):
                UnaryPredicate1D.__init__(self)
                self.__pred = pred
-
-       def getName(self):
-               return "NotUP1D"
-
        def __call__(self, inter):
                return self.__pred(inter) == 0
index 155ee48968062740f95c688b3278ad015de6eb24..565519642f72a36154066a4cfd30c79fbc86b078 100644 (file)
@@ -50,10 +50,6 @@ class pyDensityUP1D(UnaryPredicate1D):
                self._integration = integration
                self._func = DensityF1D(self._wsize, self._integration, sampling)
                self._func2 = DensityF1D(self._wsize, IntegrationType.MAX, sampling)
-   
-       def getName(self):
-               return "pyDensityUP1D"
-
        def __call__(self, inter):
                c = self._func(inter)
                m = self._func2(inter)
index ad710118688bb4a5d5282c53cb9dc69c6bb2ff57..8ec33732eeaeee0fb1e9007424c573d900331537 100644 (file)
@@ -134,8 +134,7 @@ class ThicknessBlenderMixIn(ThicknessModifierMixIn):
         return outer, inner
 
 class BaseColorShader(ConstantColorShader):
-    def getName(self):
-        return "BaseColorShader"
+    pass
 
 class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
     def __init__(self, thickness, position, ratio):
@@ -155,8 +154,6 @@ class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
             self.__inner = thickness * (1 - ratio)
         else:
             raise ValueError("unknown thickness position: " + self.position)
-    def getName(self):
-        return "BaseThicknessShader"
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
         while not it.is_end:
@@ -180,8 +177,6 @@ def iter_t2d_along_stroke(stroke):
         it.increment()
 
 class ColorAlongStrokeShader(ColorRampModifier):
-    def getName(self):
-        return "ColorAlongStrokeShader"
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
             sv = it.object
@@ -190,8 +185,6 @@ class ColorAlongStrokeShader(ColorRampModifier):
             sv.attribute.color = self.blend_ramp(a, b)
 
 class AlphaAlongStrokeShader(CurveMappingModifier):
-    def getName(self):
-        return "AlphaAlongStrokeShader"
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
             sv = it.object
@@ -206,8 +199,6 @@ class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
         self.__value_min = value_min
         self.__value_max = value_max
-    def getName(self):
-        return "ThicknessAlongStrokeShader"
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
             sv = it.object
@@ -238,8 +229,6 @@ class ColorDistanceFromCameraShader(ColorRampModifier):
         ColorRampModifier.__init__(self, blend, influence, ramp)
         self.__range_min = range_min
         self.__range_max = range_max
-    def getName(self):
-        return "ColorDistanceFromCameraShader"
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
             sv = it.object
@@ -252,8 +241,6 @@ class AlphaDistanceFromCameraShader(CurveMappingModifier):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
         self.__range_min = range_min
         self.__range_max = range_max
-    def getName(self):
-        return "AlphaDistanceFromCameraShader"
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
             sv = it.object
@@ -270,8 +257,6 @@ class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModif
         self.__range_max = range_max
         self.__value_min = value_min
         self.__value_max = value_max
-    def getName(self):
-        return "ThicknessDistanceFromCameraShader"
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
             sv = it.object
@@ -307,8 +292,6 @@ class ColorDistanceFromObjectShader(ColorRampModifier):
         self.__target = target
         self.__range_min = range_min
         self.__range_max = range_max
-    def getName(self):
-        return "ColorDistanceFromObjectShader"
     def shade(self, stroke):
         if self.__target is None:
             return
@@ -324,8 +307,6 @@ class AlphaDistanceFromObjectShader(CurveMappingModifier):
         self.__target = target
         self.__range_min = range_min
         self.__range_max = range_max
-    def getName(self):
-        return "AlphaDistanceFromObjectShader"
     def shade(self, stroke):
         if self.__target is None:
             return
@@ -345,8 +326,6 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
         self.__range_max = range_max
         self.__value_min = value_min
         self.__value_max = value_max
-    def getName(self):
-        return "ThicknessDistanceFromObjectShader"
     def shade(self, stroke):
         if self.__target is None:
             return
@@ -418,8 +397,6 @@ class ColorMaterialShader(ColorRampModifier):
         ColorRampModifier.__init__(self, blend, influence, ramp)
         self.__material_attr = material_attr
         self.__use_ramp = use_ramp
-    def getName(self):
-        return "ColorMaterialShader"
     def shade(self, stroke):
         if self.__material_attr in ["DIFF", "SPEC"] and not self.__use_ramp:
             for it, b in iter_material_color(stroke, self.__material_attr):
@@ -437,8 +414,6 @@ class AlphaMaterialShader(CurveMappingModifier):
     def __init__(self, blend, influence, mapping, invert, curve, material_attr):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
         self.__material_attr = material_attr
-    def getName(self):
-        return "AlphaMaterialShader"
     def shade(self, stroke):
         for it, t in iter_material_value(stroke, self.__material_attr):
             sv = it.object
@@ -454,8 +429,6 @@ class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
         self.__material_attr = material_attr
         self.__value_min = value_min
         self.__value_max = value_max
-    def getName(self):
-        return "ThicknessMaterialShader"
     def shade(self, stroke):
         for it, t in iter_material_value(stroke, self.__material_attr):
             sv = it.object
@@ -510,8 +483,6 @@ class SinusDisplacementShader(StrokeShader):
         self._amplitude = amplitude
         self._phase = phase / wavelength * 2 * math.pi
         self._getNormal = Normal2DF0D()
-    def getName(self):
-        return "SinusDisplacementShader"
     def shade(self, stroke):
         for it, distance in iter_distance_along_stroke(stroke):
             v = it.object
@@ -528,8 +499,6 @@ class PerlinNoise1DShader(StrokeShader):
         self.__amp = amp
         self.__oct = oct
         self.__dir = Vector([cos(angle), sin(angle)])
-    def getName(self):
-        return "PerlinNoise1DShader"
     def shade(self, stroke):
         length = stroke.length_2d
         it = stroke.stroke_vertices_begin()
@@ -548,8 +517,6 @@ class PerlinNoise2DShader(StrokeShader):
         self.__amp = amp
         self.__oct = oct
         self.__dir = Vector([cos(angle), sin(angle)])
-    def getName(self):
-        return "PerlinNoise2DShader"
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
         while not it.is_end:
@@ -567,8 +534,6 @@ class Offset2DShader(StrokeShader):
         self.__end = end
         self.__xy = Vector([x, y])
         self.__getNormal = Normal2DF0D()
-    def getName(self):
-        return "Offset2DShader"
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
         while not it.is_end:
@@ -591,8 +556,6 @@ class Transform2DShader(StrokeShader):
         self.__pivot_u = pivot_u
         self.__pivot_x = pivot_x
         self.__pivot_y = pivot_y
-    def getName(self):
-        return "Transform2DShader"
     def shade(self, stroke):
         # determine the pivot of scaling and rotation operations
         if self.__pivot == "START":
@@ -655,8 +618,6 @@ class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D):
         self.__getQI = QuantitativeInvisibilityF1D()
         self.__qi_start = qi_start
         self.__qi_end = qi_end
-    def getName(self):
-        return "QuantitativeInvisibilityRangeUP1D"
     def __call__(self, inter):
         qi = self.__getQI(inter)
         return self.__qi_start <= qi <= self.__qi_end
@@ -674,8 +635,6 @@ class ObjectNamesUP1D(UnaryPredicate1D):
         UnaryPredicate1D.__init__(self)
         self._names = names
         self._negative = negative
-    def getName(self):
-        return "ObjectNamesUP1D"
     def __call__(self, viewEdge):
         found = viewEdge.viewshape.name in self._names
         if self._negative:
@@ -840,8 +799,6 @@ class DashedLineShader(StrokeShader):
     def __init__(self, pattern):
         StrokeShader.__init__(self)
         self._pattern = pattern
-    def getName(self):
-        return "DashedLineShader"
     def shade(self, stroke):
         index = 0 # pattern index
         start = 0.0 # 2D curvilinear length
@@ -869,8 +826,6 @@ class AngleLargerThanBP1D(BinaryPredicate1D):
     def __init__(self, angle):
         BinaryPredicate1D.__init__(self)
         self._angle = angle
-    def getName(self):
-        return "AngleLargerThanBP1D"
     def __call__(self, i1, i2):
         sv1a = i1.first_fedge.first_svertex.point_2d
         sv1b = i1.last_fedge.second_svertex.point_2d
@@ -901,8 +856,6 @@ class AndBP1D(BinaryPredicate1D):
         BinaryPredicate1D.__init__(self)
         self.__pred1 = pred1
         self.__pred2 = pred2
-    def getName(self):
-        return "AndBP1D"
     def __call__(self, i1, i2):
         return self.__pred1(i1, i2) and self.__pred2(i1, i2)
 
@@ -913,8 +866,6 @@ class LengthThresholdUP1D(UnaryPredicate1D):
         UnaryPredicate1D.__init__(self)
         self._min_length = min_length
         self._max_length = max_length
-    def getName(self):
-        return "LengthThresholdUP1D"
     def __call__(self, inter):
         length = inter.length_2d
         if self._min_length is not None and length < self._min_length:
@@ -952,8 +903,6 @@ class FaceMarkOneUP1D(UnaryPredicate1D):
 # predicates for splitting
 
 class MaterialBoundaryUP0D(UnaryPredicate0D):
-    def getName(self):
-        return "MaterialBoundaryUP0D"
     def __call__(self, it):
         if it.is_begin:
             return False
@@ -975,8 +924,6 @@ class Curvature2DAngleThresholdUP0D(UnaryPredicate0D):
         self._min_angle = min_angle
         self._max_angle = max_angle
         self._func = Curvature2DAngleF0D()
-    def getName(self):
-        return "Curvature2DAngleThresholdUP0D"
     def __call__(self, inter):
         angle = math.pi - self._func(inter)
         if self._min_angle is not None and angle < self._min_angle:
@@ -990,8 +937,6 @@ class Length2DThresholdUP0D(UnaryPredicate0D):
         UnaryPredicate0D.__init__(self)
         self._length_limit = length_limit
         self._t = 0.0
-    def getName(self):
-        return "Length2DThresholdUP0D"
     def __call__(self, inter):
         t = inter.t # curvilinear abscissa
         if t < self._t:
index 31f22aad55724f445c86fd340fd790758359884b..73fddc2abf4b6589826ade1ba5183aa66bc8b057 100644 (file)
@@ -16,8 +16,6 @@ class pyDepthDiscontinuityThicknessShader(StrokeShader):
                self.__min = float(min)
                self.__max = float(max)
                self.__func = ZDiscontinuityF0D()
-       def getName(self):
-               return "pyDepthDiscontinuityThicknessShader"
        def shade(self, stroke):
                z_min=0.0
                z_max=1.0
@@ -34,8 +32,6 @@ class pyConstantThicknessShader(StrokeShader):
        def __init__(self, thickness):
                StrokeShader.__init__(self)
                self._thickness = thickness
-       def getName(self):
-               return "pyConstantThicknessShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
@@ -47,8 +43,6 @@ class pyFXSThicknessShader(StrokeShader):
        def __init__(self, thickness):
                StrokeShader.__init__(self)
                self._thickness = thickness
-       def getName(self):
-               return "pyFXSThicknessShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
@@ -64,8 +58,6 @@ class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
                self.threshold_max= threshold_max
                self._thicknessMin = thicknessMin
                self._thicknessMax = thicknessMax
-       def getName(self):
-               return "pyVaryingThicknessWithDensityShader"
        def shade(self, stroke):
                n = stroke.stroke_vertices_size()
                i = 0
@@ -88,8 +80,6 @@ class pyIncreasingThicknessShader(StrokeShader):
                StrokeShader.__init__(self)
                self._thicknessMin = thicknessMin
                self._thicknessMax = thicknessMax
-       def getName(self):
-               return "pyIncreasingThicknessShader"
        def shade(self, stroke):
                n = stroke.stroke_vertices_size()
                i = 0
@@ -110,8 +100,6 @@ class pyConstrainedIncreasingThicknessShader(StrokeShader):
                self._thicknessMin = thicknessMin
                self._thicknessMax = thicknessMax
                self._ratio = ratio
-       def getName(self):
-               return "pyConstrainedIncreasingThicknessShader"
        def shade(self, stroke):
                slength = stroke.length_2d
                tmp = self._ratio*slength
@@ -141,8 +129,6 @@ class pyDecreasingThicknessShader(StrokeShader):
                StrokeShader.__init__(self)
                self._thicknessMin = thicknessMin
                self._thicknessMax = thicknessMax
-       def getName(self):
-               return "pyDecreasingThicknessShader"
        def shade(self, stroke):
                l = stroke.length_2d
                tMax = self._thicknessMax
@@ -171,8 +157,6 @@ class pyNonLinearVaryingThicknessShader(StrokeShader):
                self._thicknessMin = thicknessMiddle
                self._thicknessMax = thicknessExtremity
                self._exponent = exponent
-       def getName(self):
-               return "pyNonLinearVaryingThicknessShader"
        def shade(self, stroke):
                n = stroke.stroke_vertices_size()
                i = 0
@@ -195,8 +179,6 @@ class pySLERPThicknessShader(StrokeShader):
                self._thicknessMin = thicknessMin
                self._thicknessMax = thicknessMax
                self._omega = omega
-       def getName(self):
-               return "pySLERPThicknessShader"
        def shade(self, stroke):
                slength = stroke.length_2d
                tmp = 0.33*slength
@@ -221,8 +203,6 @@ class pyTVertexThickenerShader(StrokeShader): ## FIXME
                StrokeShader.__init__(self)
                self._a = a
                self._n = n
-       def getName(self):
-               return "pyTVertexThickenerShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)
@@ -273,8 +253,6 @@ class pyImportance2DThicknessShader(StrokeShader):
                self._w = float(w)
                self._kmin = float(kmin)
                self._kmax = float(kmax)
-       def getName(self):
-               return "pyImportanceThicknessShader"
        def shade(self, stroke):
                origin = Vector([self._x, self._y])
                it = stroke.stroke_vertices_begin()
@@ -300,8 +278,6 @@ class pyImportance3DThicknessShader(StrokeShader):
                self._w = float(w)
                self._kmin = float(kmin)
                self._kmax = float(kmax)
-       def getName(self):
-               return "pyImportance3DThicknessShader"
        def shade(self, stroke):
                origin = Vector([self._x, self._y, self._z])
                it = stroke.stroke_vertices_begin()
@@ -324,8 +300,6 @@ class pyZDependingThicknessShader(StrokeShader):
                self.__min = min
                self.__max = max
                self.__func = GetProjectedZF0D()
-       def getName(self):
-               return "pyZDependingThicknessShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                z_min = 1
@@ -356,8 +330,6 @@ class pyConstantColorShader(StrokeShader):
                self._g = g
                self._b = b
                self._a = a
-       def getName(self):
-               return "pyConstantColorShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
@@ -372,8 +344,6 @@ class pyIncreasingColorShader(StrokeShader):
                StrokeShader.__init__(self)
                self._c1 = [r1,g1,b1,a1]
                self._c2 = [r2,g2,b2,a2]
-       def getName(self):
-               return "pyIncreasingColorShader"
        def shade(self, stroke):
                n = stroke.stroke_vertices_size() - 1
                inc = 0
@@ -395,8 +365,6 @@ class pyInterpolateColorShader(StrokeShader):
                StrokeShader.__init__(self)
                self._c1 = [r1,g1,b1,a1]
                self._c2 = [r2,g2,b2,a2]
-       def getName(self):
-               return "pyInterpolateColorShader"
        def shade(self, stroke):
                n = stroke.stroke_vertices_size() - 1
                inc = 0
@@ -416,8 +384,6 @@ class pyMaterialColorShader(StrokeShader):
        def __init__(self, threshold=50):
                StrokeShader.__init__(self)
                self._threshold = threshold
-       def getName(self):
-               return "pyMaterialColorShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                func = MaterialF0D()
@@ -477,8 +443,6 @@ class pyRandomColorShader(StrokeShader):
        def __init__(self, s=1):
                StrokeShader.__init__(self)
                seed(s)
-       def getName(self):
-               return "pyRandomColorShader"
        def shade(self, stroke):
                ## pick a random color
                c0 = float(uniform(15,75))/100.0
@@ -491,8 +455,6 @@ class pyRandomColorShader(StrokeShader):
                        it.increment()
 
 class py2DCurvatureColorShader(StrokeShader):
-       def getName(self):
-               return "py2DCurvatureColorShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                func = Curvature2DAngleF0D()
@@ -523,8 +485,6 @@ class pySamplingShader(StrokeShader):
        def __init__(self, sampling):
                StrokeShader.__init__(self)
                self._sampling = sampling
-       def getName(self):
-               return "pySamplingShader"
        def shade(self, stroke):
                stroke.resample(float(self._sampling)) 
                stroke.update_length()
@@ -533,8 +493,6 @@ class pyBackboneStretcherShader(StrokeShader):
        def __init__(self, l):
                StrokeShader.__init__(self)
                self._l = l
-       def getName(self):
-               return "pyBackboneStretcherShader"
        def shade(self, stroke):
                it0 = stroke.stroke_vertices_begin()
                it1 = StrokeVertexIterator(it0)
@@ -565,8 +523,6 @@ class pyLengthDependingBackboneStretcherShader(StrokeShader):
        def __init__(self, l):
                StrokeShader.__init__(self)
                self._l = l
-       def getName(self):
-               return "pyBackboneStretcherShader"
        def shade(self, stroke):
                l = stroke.length_2d
                stretch = self._l*l 
@@ -598,9 +554,6 @@ class pyLengthDependingBackboneStretcherShader(StrokeShader):
 
 ## Shader to replace a stroke by its corresponding tangent
 class pyGuidingLineShader(StrokeShader):
-       def getName(self):
-               return "pyGuidingLineShader"
-       ## shading method
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()     ## get the first vertex
                itlast = stroke.stroke_vertices_end()   ## 
@@ -629,8 +582,6 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
        def __init__(self, l):
                StrokeShader.__init__(self)
                self._l = l
-       def getName(self):
-               return "pyBackboneStretcherNoCuspShader"
        def shade(self, stroke):
                it0 = stroke.stroke_vertices_begin()
                it1 = StrokeVertexIterator(it0)
@@ -670,8 +621,6 @@ class pyDiffusion2Shader(StrokeShader):
                self._nbIter = nbIter
                self._normalInfo = Normal2DF0D()
                self._curvatureInfo = Curvature2DAngleF0D()
-       def getName(self):
-               return "pyDiffusionShader"
        def shade(self, stroke):
                for i in range (1, self._nbIter):
                        it = stroke.stroke_vertices_begin()
@@ -687,8 +636,6 @@ class pyTipRemoverShader(StrokeShader):
        def __init__(self, l):
                StrokeShader.__init__(self)
                self._l = l
-       def getName(self):
-               return "pyTipRemoverShader"
        def shade(self, stroke):
                originalSize = stroke.stroke_vertices_size()
                if originalSize < 4:
@@ -719,8 +666,6 @@ class pyTipRemoverShader(StrokeShader):
                stroke.update_length()
 
 class pyTVertexRemoverShader(StrokeShader):
-       def getName(self):
-               return "pyTVertexRemoverShader"
        def shade(self, stroke):
                if stroke.stroke_vertices_size() <= 3:
                        return
@@ -739,8 +684,6 @@ class pyExtremitiesOrientationShader(StrokeShader):
                StrokeShader.__init__(self)
                self._v1 = Vector([x1,y1])
                self._v2 = Vector([x2,y2])
-       def getName(self):
-               return "pyExtremitiesOrientationShader"
        def shade(self, stroke):
                #print(self._v1.x,self._v1.y)
                stroke.setBeginningOrientation(self._v1.x,self._v1.y)
@@ -750,8 +693,6 @@ def get_fedge(it1, it2):
        return it1.get_fedge(it2)
 
 class pyHLRShader(StrokeShader):
-       def getName(self):
-               return "pyHLRShader"
        def shade(self, stroke):
                originalSize = stroke.stroke_vertices_size()
                if originalSize < 4:
@@ -783,8 +724,6 @@ class pyTVertexOrientationShader(StrokeShader):
        def __init__(self):
                StrokeShader.__init__(self)
                self._Get2dDirection = Orientation2DF1D()
-       def getName(self):
-               return "pyTVertexOrientationShader"
        ## finds the TVertex orientation from the TVertex and 
        ## the previous or next edge
        def findOrientation(self, tv, ve):
@@ -860,13 +799,11 @@ class pySinusDisplacementShader(StrokeShader):
                self._f = f
                self._a = a
                self._getNormal = Normal2DF0D()
-       def getName(self):
-               return "pySinusDisplacementShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
                        v = it.object
-                       #print(self._getNormal.getName())
+                       #print(self._getNormal.name)
                        n = self._getNormal(Interface0DIterator(it))
                        p = v.point
                        u = v.u
@@ -885,8 +822,6 @@ class pyPerlinNoise1DShader(StrokeShader):
                self.__freq = freq
                self.__amp = amp
                self.__oct = oct
-       def getName(self):
-               return "pyPerlinNoise1DShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
@@ -904,8 +839,6 @@ class pyPerlinNoise2DShader(StrokeShader):
                self.__freq = freq
                self.__amp = amp
                self.__oct = oct
-       def getName(self):
-               return "pyPerlinNoise2DShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
@@ -922,8 +855,6 @@ class pyBluePrintCirclesShader(StrokeShader):
                self.__turns = turns
                self.__random_center = random_center
                self.__random_radius = random_radius
-       def getName(self):
-               return "pyBluePrintCirclesShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                if it.is_end:
@@ -986,8 +917,6 @@ class pyBluePrintEllipsesShader(StrokeShader):
                self.__turns = turns
                self.__random_center = random_center
                self.__random_radius = random_radius
-       def getName(self):
-               return "pyBluePrintEllipsesShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                if it.is_end:
@@ -1046,8 +975,6 @@ class pyBluePrintSquaresShader(StrokeShader):
                self.__turns = turns
                self.__bb_len = bb_len
                self.__bb_rand = bb_rand
-       def getName(self):
-               return "pyBluePrintSquaresShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                if it.is_end:
@@ -1144,8 +1071,6 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
                self.__mult = mult
                self.__turns = turns
                self.__bb_len = 1 + float(bb_len) / 100
-       def getName(self):
-               return "pyBluePrintDirectedSquaresShader"
        def shade(self, stroke):
                stroke.resample(32 * self.__turns)
                p_mean = Vector([0, 0])
@@ -1241,8 +1166,6 @@ class pyModulateAlphaShader(StrokeShader):
                StrokeShader.__init__(self)
                self.__min = min
                self.__max = max
-       def getName(self):
-               return "pyModulateAlphaShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
@@ -1258,8 +1181,6 @@ class pyModulateAlphaShader(StrokeShader):
 
 ## various
 class pyDummyShader(StrokeShader):
-       def getName(self):
-               return "pyDummyShader"
        def shade(self, stroke):
                it = stroke.stroke_vertices_begin()
                while not it.is_end:
@@ -1270,8 +1191,6 @@ class pyDummyShader(StrokeShader):
                        it.increment()
 
 class pyDebugShader(StrokeShader):
-       def getName(self):
-               return "pyDebugShader"
        def shade(self, stroke):
                fe = GetSelectedFEdgeCF()
                id1 = fe.first_svertex.id
index df9f462eba9058153acaf35237aef7737e7735f3..09918e71d67c684d3be05694110aa6740abb04c2 100644 (file)
@@ -110,7 +110,7 @@ static void Iterator_dealloc(BPy_Iterator* self)
 
 static PyObject * Iterator_repr(BPy_Iterator* self)
 {
-       return PyUnicode_FromFormat("type: %s - address: %p", self->it->getExactTypeName().c_str(), self->it);
+       return PyUnicode_FromFormat("type: %s - address: %p", Py_TYPE(self)->tp_name, self->it);
 }
 
 PyDoc_STRVAR(Iterator_increment_doc,
index f4a2501547bc4959620164e9189a8c5ebe4ae9ac..82ad1f85633397ffd4ef1ef46d98ef5e723e1fff 100644 (file)
@@ -197,7 +197,7 @@ static void StrokeShader___dealloc__(BPy_StrokeShader* self)
 
 static PyObject * StrokeShader___repr__(BPy_StrokeShader* self)
 {
-       return PyUnicode_FromFormat("type: %s - address: %p", self->ss->getName().c_str(), self->ss);
+       return PyUnicode_FromFormat("type: %s - address: %p", Py_TYPE(self)->tp_name, self->ss);
 }
 
 static char StrokeShader_shade___doc__[] =
index add32897740dfe446d4f5eb61fb634590068bf9e..28ce90cc51259f4fdf33b4b08f257ee40e7b63be 100644 (file)
@@ -93,8 +93,8 @@ static PyObject * UnaryPredicate0D___call__(BPy_UnaryPredicate0D *self, PyObject
        Interface0DIterator *if0D_it = ((BPy_Interface0DIterator *)py_if0D_it)->if0D_it;
 
        if (!if0D_it) {
-               string msg(self->up0D->getName() + " has no Interface0DIterator");
-               PyErr_SetString(PyExc_RuntimeError, msg.c_str());
+               string class_name(Py_TYPE(self)->tp_name);
+               PyErr_SetString(PyExc_RuntimeError, (class_name + " has no Interface0DIterator").c_str());
                return NULL;
        }
        if (typeid(*(self->up0D)) == typeid(UnaryPredicate0D)) {
index 75577246c44a29a316e8c1415c2ccfe6690ec3ce..d1f4f05598d544f7c5df9ca964a472cebe4c8f9b 100644 (file)
@@ -141,8 +141,8 @@ static PyObject * UnaryPredicate1D___call__(BPy_UnaryPredicate1D *self, PyObject
        Interface1D *if1D = ((BPy_Interface1D *)py_if1D)->if1D;
        
        if (!if1D) {
-               string msg(self->up1D->getName() + " has no Interface0DIterator");
-               PyErr_SetString(PyExc_RuntimeError, msg.c_str());
+               string class_name(Py_TYPE(self)->tp_name);
+               PyErr_SetString(PyExc_RuntimeError, (class_name + " has no Interface1D").c_str());
                return NULL;
        }
        if (typeid(*(self->up1D)) == typeid(UnaryPredicate1D)) {