* freestyle_init.py: Removed all classes for wrapping extension types.

This allows users to test the types of those objects that are returned
by API functions, by means of usual Python idioms such as "type(I) is T"
and "isinstance(I, T)".

* Removed all occurrences of ViewVertex::castToTVertex() in the following
modules and rewrote the code segments using it by means of the "type(I)
is T" idiom mentioned above:

  ChainingIterators.py
  PredicatesU1D.py

* Replaced all occurrences of vector.Vec2, vector.Vec3, Vec2f and Vec3f
by Blender.Mathutils.Vector in the following modules:

  anisotropic_diffusion.py
  Functions0D.py
  shaders.py
  sketchy_topology_broken.py

* shaders.py: Fixed NameError's concerning math.pow().

* shaders.py: Added a Python equivalent of getFEdge function, defined
in source\blender\freestyle\intern\view_map\Functions0D.cpp as follows:

  FEdge* Functions0D::getFEdge(Interface0D& it1, Interface0D& it2) {
    return it1.getFEdge(it2);
  }

* shaders.py: Replaced fe.qi() by fe.viewedge().qi().

* contour.py: Fixed the import statement for freestyle_init.py.

8 files changed, 150 insertions, 619 deletions

diff --git a/release/scripts/freestyle/style_modules/ChainingIterators.py b/release/scripts/freestyle/style_modules/ChainingIterators.py
index 30488c9ef30..968b849f0ae 100755
--- a/release/scripts/freestyle/style_modules/ChainingIterators.py
+++ b/release/scripts/freestyle/style_modules/ChainingIterators.py
@@ -42,9 +42,8 @@ class pyChainSilhouetteIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
@@ -95,9 +94,8 @@ class pyChainSilhouetteGenericIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
@@ -198,9 +196,8 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
@@ -295,9 +292,8 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
 		winnerOrientation = 0
 		print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
@@ -395,9 +391,8 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
 		winnerOrientation = 0
 		#print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
@@ -471,9 +466,8 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
 		winnerOrientation = 0
 		print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
@@ -577,9 +571,8 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
 		winnerOrientation = 0
 		print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
@@ -676,9 +669,8 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		nextVertex = self.getVertex()
-		if(nextVertex.getNature() & Nature.T_VERTEX != 0):
-			tvertex = nextVertex.castToTVertex()
+		tvertex = self.getVertex()
+		if type(tvertex) is TVertex:
 			mateVE = tvertex.mate(self.getCurrentEdge())
 			while(it.isEnd() == 0):
 				ve = it.getObject()
diff --git a/release/scripts/freestyle/style_modules/Functions0D.py b/release/scripts/freestyle/style_modules/Functions0D.py
index f5ff106c340..872b4e10286 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 Vec2f(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 = Vec2f(gx, gy)
-		return grad.norm()
+		grad = Vector(gx, gy)
+		return grad.length
 
 
diff --git a/release/scripts/freestyle/style_modules/PredicatesU1D.py b/release/scripts/freestyle/style_modules/PredicatesU1D.py
index 5d1b594a109..f39aa99a5a3 100755
--- a/release/scripts/freestyle/style_modules/PredicatesU1D.py
+++ b/release/scripts/freestyle/style_modules/PredicatesU1D.py
@@ -220,25 +220,25 @@ class pyIsOccludedByUP1D(UnaryPredicate1D):
 		itlast.decrement()
 		v =  it.getObject()
 		vlast = itlast.getObject()
-		tvertex = v.castToTVertex()
-		if(tvertex != None):
-			#print "TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]"
+		tvertex = v.viewvertex()
+		if type(tvertex) is TVertex:
+			print "TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]"
 			eit = tvertex.edgesBegin()
 			while(eit.isEnd() == 0):
-				ve = eit.getObject().first
-				if(ve.shape_id() == self._id):
+				ve, incoming = eit.getObject()
+				if(ve.getId() == self._id):
 					return 1
-				#print "-------", ve.getId().getFirst(), "-", ve.getId().getSecond()
+				print "-------", ve.getId().getFirst(), "-", ve.getId().getSecond()
 				eit.increment()
-		tvertex = vlast.castToTVertex()
-		if(tvertex != None):
-			#print "TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]"
+		tvertex = vlast.viewvertex()
+		if type(tvertex) is TVertex:
+			print "TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]"
 			eit = tvertex.edgesBegin()
 			while(eit.isEnd() == 0):
-				ve = eit.getObject().first
-				if(ve.shape_id() == self._id):
+				ve, incoming = eit.getObject()
+				if(ve.getId() == self._id):
 					return 1
-				#print "-------", ve.getId().getFirst(), "-", ve.getId().getSecond()
+				print "-------", ve.getId().getFirst(), "-", ve.getId().getSecond()
 				eit.increment()
 		return 0
 
diff --git a/release/scripts/freestyle/style_modules/anisotropic_diffusion.py b/release/scripts/freestyle/style_modules/anisotropic_diffusion.py
index 2f8739329b9..7e7ebf647bd 100755
--- a/release/scripts/freestyle/style_modules/anisotropic_diffusion.py
+++ b/release/scripts/freestyle/style_modules/anisotropic_diffusion.py
@@ -29,7 +29,6 @@ from freestyle_init import *
 from logical_operators import *
 from PredicatesB1D import *
 from shaders import *
-from vector import *
 from PredicatesU0D import *
 from math import *
 
diff --git a/release/scripts/freestyle/style_modules/contour.py b/release/scripts/freestyle/style_modules/contour.py
index ddf186d27ce..c4b3a0f0827 100755
--- a/release/scripts/freestyle/style_modules/contour.py
+++ b/release/scripts/freestyle/style_modules/contour.py
@@ -25,7 +25,7 @@
 #
 #############################################################################
 
-import freestyle_init
+from freestyle_init import *
 from logical_operators import *
 from PredicatesB1D import *
 from PredicatesU1D import *
diff --git a/release/scripts/freestyle/style_modules/freestyle_init.py b/release/scripts/freestyle/style_modules/freestyle_init.py
index a586f887a97..5103cde1048 100644
--- a/release/scripts/freestyle/style_modules/freestyle_init.py
+++ b/release/scripts/freestyle/style_modules/freestyle_init.py
@@ -1,460 +1,2 @@
+from Blender.Freestyle import *
 from Blender.Mathutils import Vector
-import Blender.Freestyle
-
-class BBox(Blender.Freestyle.BBox):
-	pass
-
-class BinaryPredicate0D(Blender.Freestyle.BinaryPredicate0D):
-	pass
-
-class BinaryPredicate1D(Blender.Freestyle.BinaryPredicate1D):
-	pass
-
-class FrsMaterial(Blender.Freestyle.FrsMaterial):
-	pass
-
-class Id(Blender.Freestyle.Id):
-	pass
-
-class IntegrationType(Blender.Freestyle.IntegrationType):
-	pass
-
-class Interface0D(Blender.Freestyle.Interface0D):
-	pass
-
-class Interface1D(Blender.Freestyle.Interface1D):
-	pass
-
-class Iterator(Blender.Freestyle.Iterator):
-	pass
-
-class MediumType(Blender.Freestyle.MediumType):
-	pass
-
-class Nature(Blender.Freestyle.Nature):
-	pass
-
-class FrsNoise(Blender.Freestyle.FrsNoise):
-	pass
-
-class Operators(Blender.Freestyle.Operators):
-	pass
-
-class SShape(Blender.Freestyle.SShape):
-	pass
-
-class StrokeAttribute(Blender.Freestyle.StrokeAttribute):
-	pass
-
-class StrokeShader(Blender.Freestyle.StrokeShader):
-	def getName(self):
-                return self.__class__.__name__
-
-class UnaryFunction0D(Blender.Freestyle.UnaryFunction0D):
-	pass
-
-class UnaryFunction1D(Blender.Freestyle.UnaryFunction1D):
-	pass
-
-class UnaryPredicate0D(Blender.Freestyle.UnaryPredicate0D):
-	pass
-
-class UnaryPredicate1D(Blender.Freestyle.UnaryPredicate1D):
-	pass
-
-class ViewMap(Blender.Freestyle.ViewMap):
-	pass
-
-class ViewShape(Blender.Freestyle.ViewShape):
-	pass
-
-class FalseBP1D(Blender.Freestyle.FalseBP1D):
-	pass
-
-class Length2DBP1D(Blender.Freestyle.Length2DBP1D):
-	pass
-
-class SameShapeIdBP1D(Blender.Freestyle.SameShapeIdBP1D):
-	pass
-
-class TrueBP1D(Blender.Freestyle.TrueBP1D):
-	pass
-
-class ViewMapGradientNormBP1D(Blender.Freestyle.ViewMapGradientNormBP1D):
-	pass
-
-class CurvePoint(Blender.Freestyle.CurvePoint):
-	pass
-
-class SVertex(Blender.Freestyle.SVertex):
-	pass
-
-class ViewVertex(Blender.Freestyle.ViewVertex):
-	pass
-
-class FrsCurve(Blender.Freestyle.FrsCurve):
-	pass
-
-class FEdge(Blender.Freestyle.FEdge):
-	pass
-
-class Stroke(Blender.Freestyle.Stroke):
-	pass
-
-class ViewEdge(Blender.Freestyle.ViewEdge):
-	pass
-
-class AdjacencyIterator(Blender.Freestyle.AdjacencyIterator):
-	pass
-
-class ChainingIterator(Blender.Freestyle.ChainingIterator):
-	pass
-
-class ChainPredicateIterator(Blender.Freestyle.ChainPredicateIterator):
-	pass
-
-class ChainSilhouetteIterator(Blender.Freestyle.ChainSilhouetteIterator):
-	pass
-
-class CurvePointIterator(Blender.Freestyle.CurvePointIterator):
-	pass
-
-class Interface0DIterator(Blender.Freestyle.Interface0DIterator):
-	pass
-
-class orientedViewEdgeIterator(Blender.Freestyle.orientedViewEdgeIterator):
-	pass
-
-class StrokeVertexIterator(Blender.Freestyle.StrokeVertexIterator):
-	pass
-
-class SVertexIterator(Blender.Freestyle.SVertexIterator):
-	pass
-
-class ViewEdgeIterator(Blender.Freestyle.ViewEdgeIterator):
-	pass
-
-class BackboneStretcherShader(Blender.Freestyle.BackboneStretcherShader):
-	pass
-
-class BezierCurveShader(Blender.Freestyle.BezierCurveShader):
-	pass
-
-class CalligraphicShader(Blender.Freestyle.CalligraphicShader):
-	pass
-
-class ColorNoiseShader(Blender.Freestyle.ColorNoiseShader):
-	pass
-
-class ColorVariationPatternShader(Blender.Freestyle.ColorVariationPatternShader):
-	pass
-
-class ConstantColorShader(Blender.Freestyle.ConstantColorShader):
-	pass
-
-class ConstantThicknessShader(Blender.Freestyle.ConstantThicknessShader):
-	pass
-
-class ConstrainedIncreasingThicknessShader(Blender.Freestyle.ConstrainedIncreasingThicknessShader):
-	pass
-
-class fstreamShader(Blender.Freestyle.fstreamShader):
-	pass
-
-class GuidingLinesShader(Blender.Freestyle.GuidingLinesShader):
-	pass
-
-class IncreasingColorShader(Blender.Freestyle.IncreasingColorShader):
-	pass
-
-class IncreasingThicknessShader(Blender.Freestyle.IncreasingThicknessShader):
-	pass
-
-class PolygonalizationShader(Blender.Freestyle.PolygonalizationShader):
-	pass
-
-class SamplingShader(Blender.Freestyle.SamplingShader):
-	pass
-
-class SmoothingShader(Blender.Freestyle.SmoothingShader):
-	pass
-
-class SpatialNoiseShader(Blender.Freestyle.SpatialNoiseShader):
-	pass
-
-class streamShader(Blender.Freestyle.streamShader):
-	pass
-
-class StrokeTextureShader(Blender.Freestyle.StrokeTextureShader):
-	pass
-
-class TextureAssignerShader(Blender.Freestyle.TextureAssignerShader):
-	pass
-
-class ThicknessNoiseShader(Blender.Freestyle.ThicknessNoiseShader):
-	pass
-
-class ThicknessVariationPatternShader(Blender.Freestyle.ThicknessVariationPatternShader):
-	pass
-
-class TipRemoverShader(Blender.Freestyle.TipRemoverShader):
-	pass
-
-class UnaryFunction0DDouble(Blender.Freestyle.UnaryFunction0DDouble):
-	pass
-
-class UnaryFunction0DEdgeNature(Blender.Freestyle.UnaryFunction0DEdgeNature):
-	pass
-
-class UnaryFunction0DFloat(Blender.Freestyle.UnaryFunction0DFloat):
-	pass
-
-class UnaryFunction0DId(Blender.Freestyle.UnaryFunction0DId):
-	pass
-
-class UnaryFunction0DMaterial(Blender.Freestyle.UnaryFunction0DMaterial):
-	pass
-
-class UnaryFunction0DUnsigned(Blender.Freestyle.UnaryFunction0DUnsigned):
-	pass
-
-class UnaryFunction0DVec2f(Blender.Freestyle.UnaryFunction0DVec2f):
-	pass
-
-class UnaryFunction0DVec3f(Blender.Freestyle.UnaryFunction0DVec3f):
-	pass
-
-class UnaryFunction0DVectorViewShape(Blender.Freestyle.UnaryFunction0DVectorViewShape):
-	pass
-
-class UnaryFunction0DViewShape(Blender.Freestyle.UnaryFunction0DViewShape):
-	pass
-
-class UnaryFunction1DDouble(Blender.Freestyle.UnaryFunction1DDouble):
-	pass
-
-class UnaryFunction1DEdgeNature(Blender.Freestyle.UnaryFunction1DEdgeNature):
-	pass
-
-class UnaryFunction1DFloat(Blender.Freestyle.UnaryFunction1DFloat):
-	pass
-
-class UnaryFunction1DUnsigned(Blender.Freestyle.UnaryFunction1DUnsigned):
-	pass
-
-class UnaryFunction1DVec2f(Blender.Freestyle.UnaryFunction1DVec2f):
-	pass
-
-class UnaryFunction1DVec3f(Blender.Freestyle.UnaryFunction1DVec3f):
-	pass
-
-class UnaryFunction1DVectorViewShape(Blender.Freestyle.UnaryFunction1DVectorViewShape):
-	pass
-
-class UnaryFunction1DVoid(Blender.Freestyle.UnaryFunction1DVoid):
-	pass
-
-class FalseUP0D(Blender.Freestyle.FalseUP0D):
-	pass
-
-class TrueUP0D(Blender.Freestyle.TrueUP0D):
-	pass
-
-class ContourUP1D(Blender.Freestyle.ContourUP1D):
-	pass
-
-class DensityLowerThanUP1D(Blender.Freestyle.DensityLowerThanUP1D):
-	pass
-
-class EqualToChainingTimeStampUP1D(Blender.Freestyle.EqualToChainingTimeStampUP1D):
-	pass
-
-class EqualToTimeStampUP1D(Blender.Freestyle.EqualToTimeStampUP1D):
-	pass
-
-class ExternalContourUP1D(Blender.Freestyle.ExternalContourUP1D):
-	pass
-
-class FalseUP1D(Blender.Freestyle.FalseUP1D):
-	pass
-
-class QuantitativeInvisibilityUP1D(Blender.Freestyle.QuantitativeInvisibilityUP1D):
-	pass
-
-class ShapeUP1D(Blender.Freestyle.ShapeUP1D):
-	pass
-
-class TrueUP1D(Blender.Freestyle.TrueUP1D):
-	pass
-
-class StrokeVertex(Blender.Freestyle.StrokeVertex):
-	pass
-
-class NonTVertex(Blender.Freestyle.NonTVertex):
-	pass
-
-class TVertex(Blender.Freestyle.TVertex):
-	pass
-
-class Chain(Blender.Freestyle.Chain):
-	pass
-
-class FEdgeSharp(Blender.Freestyle.FEdgeSharp):
-	pass
-
-class FEdgeSmooth(Blender.Freestyle.FEdgeSmooth):
-	pass
-
-class Curvature2DAngleF0D(Blender.Freestyle.Curvature2DAngleF0D):
-	pass
-
-class DensityF0D(Blender.Freestyle.DensityF0D):
-	pass
-
-class GetProjectedXF0D(Blender.Freestyle.GetProjectedXF0D):
-	pass
-
-class GetProjectedYF0D(Blender.Freestyle.GetProjectedYF0D):
-	pass
-
-class GetProjectedZF0D(Blender.Freestyle.GetProjectedZF0D):
-	pass
-
-class GetXF0D(Blender.Freestyle.GetXF0D):
-	pass
-
-class GetYF0D(Blender.Freestyle.GetYF0D):
-	pass
-
-class GetZF0D(Blender.Freestyle.GetZF0D):
-	pass
-
-class LocalAverageDepthF0D(Blender.Freestyle.LocalAverageDepthF0D):
-	pass
-
-class ZDiscontinuityF0D(Blender.Freestyle.ZDiscontinuityF0D):
-	pass
-
-class GetCurvilinearAbscissaF0D(Blender.Freestyle.GetCurvilinearAbscissaF0D):
-	pass
-
-class GetParameterF0D(Blender.Freestyle.GetParameterF0D):
-	pass
-
-class GetViewMapGradientNormF0D(Blender.Freestyle.GetViewMapGradientNormF0D):
-	pass
-
-class ReadCompleteViewMapPixelF0D(Blender.Freestyle.ReadCompleteViewMapPixelF0D):
-	pass
-
-class ReadMapPixelF0D(Blender.Freestyle.ReadMapPixelF0D):
-	pass
-
-class ReadSteerableViewMapPixelF0D(Blender.Freestyle.ReadSteerableViewMapPixelF0D):
-	pass
-
-class ShapeIdF0D(Blender.Freestyle.ShapeIdF0D):
-	pass
-
-class MaterialF0D(Blender.Freestyle.MaterialF0D):
-	pass
-
-class CurveNatureF0D(Blender.Freestyle.CurveNatureF0D):
-	pass
-
-class QuantitativeInvisibilityF0D(Blender.Freestyle.QuantitativeInvisibilityF0D):
-	pass
-
-class Normal2DF0D(Blender.Freestyle.Normal2DF0D):
-	pass
-
-class VertexOrientation2DF0D(Blender.Freestyle.VertexOrientation2DF0D):
-	pass
-
-class VertexOrientation3DF0D(Blender.Freestyle.VertexOrientation3DF0D):
-	pass
-
-class GetOccludersF0D(Blender.Freestyle.GetOccludersF0D):
-	pass
-
-class GetOccludeeF0D(Blender.Freestyle.GetOccludeeF0D):
-	pass
-
-class GetShapeF0D(Blender.Freestyle.GetShapeF0D):
-	pass
-
-class Curvature2DAngleF1D(Blender.Freestyle.Curvature2DAngleF1D):
-	pass
-
-class DensityF1D(Blender.Freestyle.DensityF1D):
-	pass
-
-class GetCompleteViewMapDensityF1D(Blender.Freestyle.GetCompleteViewMapDensityF1D):
-	pass
-
-class GetDirectionalViewMapDensityF1D(Blender.Freestyle.GetDirectionalViewMapDensityF1D):
-	pass
-
-class GetProjectedXF1D(Blender.Freestyle.GetProjectedXF1D):
-	pass
-
-class GetProjectedYF1D(Blender.Freestyle.GetProjectedYF1D):
-	pass
-
-class GetProjectedZF1D(Blender.Freestyle.GetProjectedZF1D):
-	pass
-
-class GetSteerableViewMapDensityF1D(Blender.Freestyle.GetSteerableViewMapDensityF1D):
-	pass
-
-class GetViewMapGradientNormF1D(Blender.Freestyle.GetViewMapGradientNormF1D):
-	pass
-
-class GetXF1D(Blender.Freestyle.GetXF1D):
-	pass
-
-class GetYF1D(Blender.Freestyle.GetYF1D):
-	pass
-
-class GetZF1D(Blender.Freestyle.GetZF1D):
-	pass
-
-class LocalAverageDepthF1D(Blender.Freestyle.LocalAverageDepthF1D):
-	pass
-
-class ZDiscontinuityF1D(Blender.Freestyle.ZDiscontinuityF1D):
-	pass
-
-class CurveNatureF1D(Blender.Freestyle.CurveNatureF1D):
-	pass
-
-class QuantitativeInvisibilityF1D(Blender.Freestyle.QuantitativeInvisibilityF1D):
-	pass
-
-class Normal2DF1D(Blender.Freestyle.Normal2DF1D):
-	pass
-
-class Orientation2DF1D(Blender.Freestyle.Orientation2DF1D):
-	pass
-
-class Orientation3DF1D(Blender.Freestyle.Orientation3DF1D):
-	pass
-
-class GetOccludeeF1D(Blender.Freestyle.GetOccludeeF1D):
-	pass
-
-class GetOccludersF1D(Blender.Freestyle.GetOccludersF1D):
-	pass
-
-class GetShapeF1D(Blender.Freestyle.GetShapeF1D):
-	pass
-
-class ChainingTimeStampF1D(Blender.Freestyle.ChainingTimeStampF1D):
-	pass
-
-class IncrementChainingTimeStampF1D(Blender.Freestyle.IncrementChainingTimeStampF1D):
-	pass
-
-class TimeStampF1D(Blender.Freestyle.TimeStampF1D):
-	pass
-
diff --git a/release/scripts/freestyle/style_modules/shaders.py b/release/scripts/freestyle/style_modules/shaders.py
index 610e1d2a943..f07e5b5ad12 100755
--- a/release/scripts/freestyle/style_modules/shaders.py
+++ b/release/scripts/freestyle/style_modules/shaders.py
@@ -6,7 +6,6 @@ from logical_operators import *
 from ChainingIterators import *
 from random import *
 from math import *
-from vector import *
 
 ## thickness modifiers
 ######################
@@ -308,12 +307,12 @@ class pyImportance2DThicknessShader(StrokeShader):
 	def getName(self):
 		return "pyImportanceThicknessShader"
 	def shade(self, stroke):
-		origin = Vec2(self._x, self._y)
+		origin = Vector(self._x, self._y)
 		it = stroke.strokeVerticesBegin()
 		while it.isEnd() == 0:
 			v = it.getObject()
-			p = Vec2(v.getProjectedX(), v.getProjectedY())
-			d = (p-origin).length()
+			p = Vector(v.getProjectedX(), v.getProjectedY())
+			d = (p-origin).length
 			if(d>self._w):
 				k = self._kmin
 			else:
@@ -337,12 +336,12 @@ class pyImportance3DThicknessShader(StrokeShader):
 	def getName(self):
 		return "pyImportance3DThicknessShader"
 	def shade(self, stroke):
-		origin = Vec3(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 = Vec3(v.getX(), v.getY(), v.getZ())
-			d = (p-origin).length()
+			p = Vector(v.getX(), v.getY(), v.getZ())
+			d = (p-origin).length
 			if(d>self._w):
 				k = self._kmin
 			else:
@@ -486,7 +485,7 @@ class pyMaterialColorShader(StrokeShader):
 			u = 4.*X / (X + 15.*Y + 3.*Z)
 			v = 9.*Y / (X + 15.*Y + 3.*Z)
 			
-			L= 116. * math.pow((Y/Yn),(1./3.)) -16
+			L= 116. * pow((Y/Yn),(1./3.)) -16
 			U = 13. * L * (u - un)
 			V = 13. * L * (v - vn)
 			
@@ -500,7 +499,7 @@ class pyMaterialColorShader(StrokeShader):
 			u = U / (13. * L) + un
 			v = V / (13. * L) + vn
 			
-			Y = Yn * math.pow( ((L+16.)/116.), 3.)
+			Y = Yn * pow( ((L+16.)/116.), 3.)
 			X = -9. * Y * u / ((u - 4.)* v - u * v)
 			Z = (9. * Y - 15*v*Y - v*X) /( 3. * v)
 			
@@ -593,14 +592,14 @@ class pyBackboneStretcherShader(StrokeShader):
 		v1 = it1.getObject()
 		vn_1 = itn_1.getObject()
 		vn = itn.getObject()
-		p0 = Vec2f(v0.getProjectedX(), v0.getProjectedY())
-		pn = Vec2f(vn.getProjectedX(), vn.getProjectedY())
-		p1 = Vec2f(v1.getProjectedX(), v1.getProjectedY())
-		pn_1 = Vec2f(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 = d1/d1.norm()
+		d1.normalize()
 		dn = pn-pn_1
-		dn = dn/dn.norm()
+		dn.normalize()
 		newFirst = p0+d1*float(self._l)
 		newLast = pn+dn*float(self._l)
 		v0.setPoint(newFirst)
@@ -626,14 +625,14 @@ class pyLengthDependingBackboneStretcherShader(StrokeShader):
 		v1 = it1.getObject()
 		vn_1 = itn_1.getObject()
 		vn = itn.getObject()
-		p0 = Vec2f(v0.getProjectedX(), v0.getProjectedY())
-		pn = Vec2f(vn.getProjectedX(), vn.getProjectedY())
-		p1 = Vec2f(v1.getProjectedX(), v1.getProjectedY())
-		pn_1 = Vec2f(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 = d1/d1.norm()
+		d1.normalize()
 		dn = pn-pn_1
-		dn = dn/dn.norm()
+		dn.normalize()
 		newFirst = p0+d1*float(stretch)
 		newLast = pn+dn*float(stretch)
 		v0.setPoint(newFirst)
@@ -688,7 +687,7 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
 			p0 = v0.getPoint()
 			p1 = v1.getPoint()
 			d1 = p0-p1
-			d1 = d1/d1.norm()
+			d1.normalize()
 			newFirst = p0+d1*float(self._l)
 			v0.setPoint(newFirst)
 		vn_1 = itn_1.getObject()
@@ -697,7 +696,7 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
 			pn = vn.getPoint()
 			pn_1 = vn_1.getPoint()
 			dn = pn-pn_1
-			dn = dn/dn.norm()
+			dn.normalize()
 			newLast = pn+dn*float(self._l)	
 			vn.setPoint(newLast)
 
@@ -778,14 +777,17 @@ class pyTVertexRemoverShader(StrokeShader):
 class pyExtremitiesOrientationShader(StrokeShader):
 	def __init__(self, x1,y1,x2=0,y2=0):
 		StrokeShader.__init__(self)
-		self._v1 = Vec2(x1,y1)
-		self._v2 = Vec2(x2,y2)
+		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())
-		stroke.setEndingOrientation(self._v2.x(),self._v2.y())
+		print self._v1.x,self._v1.y
+		stroke.setBeginningOrientation(self._v1.x,self._v1.y)
+		stroke.setEndingOrientation(self._v2.x,self._v2.y)
+
+def getFEdge(it1, it2):
+	return it1.getFEdge(it2)
 
 class pyHLRShader(StrokeShader):
 	def getName(self):
@@ -799,7 +801,7 @@ class pyHLRShader(StrokeShader):
 		it2 = StrokeVertexIterator(it)
 		it2.increment()
 		fe = getFEdge(it.getObject(), it2.getObject())
-		if(fe.qi() != 0):
+		if(fe.viewedge().qi() != 0):
 			invisible = 1
 		while(it2.isEnd() == 0):
 			v = it.getObject()
@@ -807,7 +809,7 @@ class pyHLRShader(StrokeShader):
 			if(v.getNature() & Nature.VIEW_VERTEX):
 				#if(v.getNature() & Nature.T_VERTEX):
 				fe = getFEdge(v,vnext)
-				qi = fe.qi()
+				qi = fe.viewedge().qi()
 				if(qi != 0):
 					invisible = 1
 				else:
@@ -856,7 +858,7 @@ class pyTVertexOrientationShader(StrokeShader):
 			ve = getFEdge(v, it2.getObject()).viewedge()
 			if(tv != None):			
 				dir = self.findOrientation(tv, ve)
-				#print dir.x(), dir.y()
+				#print dir.x, dir.y
 				v.attribute().setAttributeVec2f("orientation", dir)
 		while(it2.isEnd() == 0):
 			vprevious = it.getObject()
@@ -866,7 +868,7 @@ class pyTVertexOrientationShader(StrokeShader):
 				ve = getFEdge(vprevious, v).viewedge()
 				if(tv != None):	
 					dir = self.findOrientation(tv, ve)
-					#print dir.x(), dir.y()
+					#print dir.x, dir.y
 					v.attribute().setAttributeVec2f("orientation", dir)			
 			it.increment()
 			it2.increment()
@@ -879,7 +881,7 @@ class pyTVertexOrientationShader(StrokeShader):
 			ve = getFEdge(itPrevious.getObject(), v).viewedge()
 			if(tv != None):			
 				dir = self.findOrientation(tv, ve)
-				#print dir.x(), dir.y()
+				#print dir.x, dir.y
 				v.attribute().setAttributeVec2f("orientation", dir)
 
 class pySinusDisplacementShader(StrokeShader):
@@ -901,7 +903,7 @@ class pySinusDisplacementShader(StrokeShader):
 			u = v.u()
 			a = self._a*(1-2*(fabs(u-0.5)))
 			n = n*a*cos(self._f*u*6.28)
-			#print n.x(), n.y()
+			#print n.x, n.y
 			v.setPoint(p+n)
 			#v.setPoint(v.getPoint()+n*a*cos(f*v.u()))
 			it.increment()
@@ -938,7 +940,7 @@ class pyPerlinNoise2DShader(StrokeShader):
 		it = stroke.strokeVerticesBegin()
 		while it.isEnd() == 0:
 			v = it.getObject()
-			vec = Vec2f(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()
@@ -950,44 +952,42 @@ class pyBluePrintCirclesShader(StrokeShader):
 	def getName(self):
 		return "pyBluePrintCirclesShader"
 	def shade(self, stroke):
-		p_min = Vec2f(10000, 10000)
-		p_max = Vec2f(0, 0)
+		p_min = Vector(10000, 10000)
+		p_max = Vector(0, 0)
 		it = stroke.strokeVerticesBegin()
 		while it.isEnd() == 0:
 			p = it.getObject().getPoint()
-			if (p.x() < p_min.x()):
-				p_min.setX(p.x())
-			if (p.x() > p_max.x()):
-				p_max.setX(p.x())
-			if (p.y() < p_min.y()):
-				p_min.setY(p.y())
-			if (p.y() > p_max.y()):
-				p_max.setY(p.y())
+			if (p.x < p_min.x):
+				p_min.x = p.x
+			if (p.x > p_max.x):
+				p_max.x = p.x
+			if (p.y < p_min.y):
+				p_min.y = p.y
+			if (p.y > p_max.y):
+				p_max.y = p.y
 			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 "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 = (center.x() - p_min.x() + center.y() - p_min.y()) / 2
-		p_new = Vec2f()
+		radius = (center.x - p_min.x + center.y - p_min.y) / 2
+		p_new = Vector(0, 0)
 #######################################################
 		it = stroke.strokeVerticesBegin()
 		for j in range(self.__turns):
 			radius = radius + randint(-3, 3)
-			center_x = center.x() + randint(-5, 5)
-			center_y = center.y() + randint(-5, 5)
-			center.setX(center_x)
-			center.setY(center_y)
+			center.x = center.x + randint(-5, 5)
+			center.y = center.y + randint(-5, 5)
 			i = 0
 			while i < sv_nb:
-				p_new.setX(center.x() + radius * cos(2 * pi * float(i) / float(sv_nb - 1)))
-   				p_new.setY(center.y() + radius * sin(2 * pi * float(i) / float(sv_nb - 1)))
-				it.getObject().setPoint(p_new.x(), p_new.y())
+				p_new.x = center.x + radius * cos(2 * pi * float(i) / float(sv_nb - 1))
+   				p_new.y = center.y + radius * sin(2 * pi * float(i) / float(sv_nb - 1))
+				it.getObject().setPoint(p_new)
 				i = i + 1
 				it.increment()
 		while it.isEnd() == 0:
@@ -1002,46 +1002,44 @@ class pyBluePrintEllipsesShader(StrokeShader):
 	def getName(self):
 		return "pyBluePrintEllipsesShader"
 	def shade(self, stroke):
-		p_min = Vec2f(10000, 10000)
-		p_max = Vec2f(0, 0)
+		p_min = Vector(10000, 10000)
+		p_max = Vector(0, 0)
 		it = stroke.strokeVerticesBegin()
 		while it.isEnd() == 0:
 			p = it.getObject().getPoint()
-			if (p.x() < p_min.x()):
-				p_min.setX(p.x())
-			if (p.x() > p_max.x()):
-				p_max.setX(p.x())
-			if (p.y() < p_min.y()):
-				p_min.setY(p.y())
-			if (p.y() > p_max.y()):
-				p_max.setY(p.y())
+			if (p.x < p_min.x):
+				p_min.x = p.x
+			if (p.x > p_max.x):
+				p_max.x = p.x
+			if (p.y < p_min.y):
+				p_min.y = p.y
+			if (p.y > p_max.y):
+				p_max.y = p.y
 			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 "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 = Vec2f()
+		radius_x = center.x - p_min.x
+		radius_y = center.y - p_min.y
+		p_new = Vector(0, 0)
 #######################################################
 		it = stroke.strokeVerticesBegin()
 		for j in range(self.__turns):
 			radius_x = radius_x + randint(-3, 3)
 			radius_y = radius_y + randint(-3, 3)
-			center_x = center.x() + randint(-5, 5)
-			center_y = center.y() + randint(-5, 5)
-			center.setX(center_x)
-			center.setY(center_y)
+			center.x = center.x + randint(-5, 5)
+			center.y = center.y + randint(-5, 5)
 			i = 0
 			while i < sv_nb:
-				p_new.setX(center.x() + radius_x * cos(2 * pi * float(i) / float(sv_nb - 1)))
-   				p_new.setY(center.y() + radius_y * sin(2 * pi * float(i) / float(sv_nb - 1)))
-				it.getObject().setPoint(p_new.x(), p_new.y())
+				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)
 				i = i + 1
 				it.increment()
 		while it.isEnd() == 0:
@@ -1057,19 +1055,19 @@ class pyBluePrintSquaresShader(StrokeShader):
 	def getName(self):
 		return "pyBluePrintSquaresShader"
 	def shade(self, stroke):
-		p_min = Vec2f(10000, 10000)
-		p_max = Vec2f(0, 0)
+		p_min = Vector(10000, 10000)
+		p_max = Vector(0, 0)
 		it = stroke.strokeVerticesBegin()
 		while it.isEnd() == 0:
 			p = it.getObject().getPoint()
-			if (p.x() < p_min.x()):
-				p_min.setX(p.x())
-			if (p.x() > p_max.x()):
-				p_max.setX(p.x())
-			if (p.y() < p_min.y()):
-				p_min.setY(p.y())
-			if (p.y() > p_max.y()):
-				p_max.setY(p.y())
+			if (p.x < p_min.x):
+				p_min.x = p.x
+			if (p.x > p_max.x):
+				p_max.x = p.x
+			if (p.y < p_min.y):
+				p_min.y = p.y
+			if (p.y > p_max.y):
+				p_max.y = p.y
 			it.increment()
 		stroke.Resample(32 * self.__turns)
 		sv_nb = stroke.strokeVerticesSize()
@@ -1079,14 +1077,14 @@ class pyBluePrintSquaresShader(StrokeShader):
 		second = 2 * first
 		third = 3 * first
 		fourth = sv_nb
-		vec_first = Vec2f(p_max.x() - p_min.x() + 2 * self.__bb_len, 0)
-		vec_second = Vec2f(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 = Vec2f(p_min.x() - self.__bb_len, p_min.y())
-		p_second = Vec2f(p_max.x(), p_min.y() - self.__bb_len)
-		p_third = Vec2f(p_max.x() + self.__bb_len, p_max.y())
-		p_fourth = Vec2f(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
@@ -1109,7 +1107,7 @@ class pyBluePrintSquaresShader(StrokeShader):
 					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
 					if i == fourth - 1:
 						visible = 0
-				it.getObject().setPoint(p_new.x(), p_new.y())
+				it.getObject().setPoint(p_new)
 				it.getObject().attribute().setVisible(visible)
 				if visible == 0:
 					visible = 1
@@ -1130,21 +1128,21 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
 		return "pyBluePrintDirectedSquaresShader"
 	def shade(self, stroke):
 		stroke.Resample(32 * self.__turns)
-		p_mean = Vec2f(0, 0)
-		p_min = Vec2f(10000, 10000)
-		p_max = Vec2f(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()
 			p_mean = p_mean + p
-## 			if (p.x() < p_min.x()):
-## 				p_min.setX(p.x())
-## 			if (p.x() > p_max.x()):
-## 				p_max.setX(p.x())
-## 			if (p.y() < p_min.y()):
-## 				p_min.setY(p.y())
-## 			if (p.y() > p_max.y()):
-## 				p_max.setY(p.y())
+## 			if (p.x < p_min.x):
+## 				p_min.x = p.x
+## 			if (p.x > p_max.x):
+## 				p_max.x = p.x
+## 			if (p.y < p_min.y):
+## 				p_min.y = p.y
+## 			if (p.y > p_max.y):
+## 				p_max.y = p.y
 			it.increment()
 		sv_nb = stroke.strokeVerticesSize()
 		p_mean = p_mean / sv_nb
@@ -1154,9 +1152,9 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
 		it = stroke.strokeVerticesBegin()
 		while it.isEnd() == 0:
 			p = it.getObject().getPoint()
-			p_var_xx = p_var_xx + pow(p.x() - p_mean.x(), 2)
-			p_var_yy = p_var_yy + pow(p.y() - p_mean.y(), 2)
-			p_var_xy = p_var_xy + (p.x() - p_mean.x()) * (p.y() - p_mean.y())
+			p_var_xx = p_var_xx + pow(p.x - p_mean.x, 2)
+			p_var_yy = p_var_yy + pow(p.y - p_mean.y, 2)
+			p_var_xy = p_var_xy + (p.x - p_mean.x) * (p.y - p_mean.y)
 			it.increment()
 		p_var_xx = p_var_xx / sv_nb
 		p_var_yy = p_var_yy / sv_nb
@@ -1171,11 +1169,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 = Vec2f(cos(theta + pi / 2), sin(theta + pi / 2)) * sqrt(lambda1) * self.__mult
-			e2 = Vec2f(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 = Vec2f(cos(theta), sin(theta)) * sqrt(lambda1) * self.__mult
-			e2 = Vec2f(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
@@ -1214,7 +1212,7 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
 					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
 					if i == fourth - 1:
 						visible = 0
-				it.getObject().setPoint(p_new.x(), p_new.y())
+				it.getObject().setPoint(p_new)
 				it.getObject().attribute().setVisible(visible)
 				if visible == 0:
 					visible = 1
@@ -1236,7 +1234,7 @@ class pyModulateAlphaShader(StrokeShader):
 		while it.isEnd() == 0:
 			alpha = it.getObject().attribute().getAlpha()
 			p = it.getObject().getPoint()
-			alpha = alpha * p.y() / 400
+			alpha = alpha * p.y / 400
 			if alpha < self.__min:
 				alpha = self.__min
 			elif alpha > self.__max:
diff --git a/release/scripts/freestyle/style_modules/sketchy_topology_broken.py b/release/scripts/freestyle/style_modules/sketchy_topology_broken.py
index 5c151cfe837..9cbb2725132 100755
--- a/release/scripts/freestyle/style_modules/sketchy_topology_broken.py
+++ b/release/scripts/freestyle/style_modules/sketchy_topology_broken.py
@@ -53,7 +53,7 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
 			p0 = v0.getPoint()
 			p1 = v1.getPoint()
 			d1 = p0-p1
-			d1 = d1/d1.norm()
+			d1.normalize()
 			newFirst = p0+d1*float(self._l)
 			v0.setPoint(newFirst)
 		else:
@@ -64,7 +64,7 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
 			pn = vn.getPoint()
 			pn_1 = vn_1.getPoint()
 			dn = pn-pn_1
-			dn = dn/dn.norm()
+			dn.normalize()
 			newLast = pn+dn*float(self._l)	
 			vn.setPoint(newLast)
 		else: