Reorganized the Freestyle Python API in a hierarchical package structure.

Both C- and Python-coded API components were rearranged into logical groups.
New Python modules are packaged as follows:

freestyle - Top-level package
freestyle.types - Classes for core data structues (e.g., view map)
freestyle.chainingiterators - Pre-defined chaining iterators
freestyle.functions - Pre-defined 0D and 1D functions
freestyle.predicates - Pre-defined 0D and 1D predicates
freestyle.shaders - Pre-defined stroke shaders
freestyle.utils - Utility functions

The Python modules are installed in scripts/freestyle/modules.  Pre-defined
styles are installed in scripts/freestyle/styles.

To-do: update styles according to the new Freestyle API package structure.

48 files changed, 0 insertions, 5636 deletions

diff --git a/release/scripts/freestyle/style_modules/ChainingIterators.py b/release/scripts/freestyle/style_modules/ChainingIterators.py
deleted file mode 100644
index 9be5a0ef03f..00000000000
--- a/release/scripts/freestyle/style_modules/ChainingIterators.py
+++ /dev/null
@@ -1,713 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : ChainingIterators.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Chaining Iterators to be used with chaining operators
-
-from freestyle import AdjacencyIterator, ChainingIterator, ExternalContourUP1D, Nature, TVertex
-from freestyle import ContextFunctions as CF
-
-import bpy
-
-## the natural chaining iterator
-## It follows the edges of same nature following the topology of
-## objects with  preseance on silhouettes, then borders, 
-## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
-## You can specify whether to stay in the selection or not.
-class pyChainSilhouetteIterator(ChainingIterator):
-	def __init__(self, stayInSelection=True):
-		ChainingIterator.__init__(self, stayInSelection, True, None, True)
-	def init(self):
-		pass
-	def traverse(self, iter):
-		winner = None
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				if ve.id == mateVE.id:
-					winner = ve
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for i in range(len(natures)):
-				currentNature = self.current_edge.nature
-				if (natures[i] & currentNature) != 0:
-					count=0
-					while not it.is_end:
-						visitNext = 0
-						oNature = it.object.nature
-						if (oNature & natures[i]) != 0:
-							if natures[i] != oNature:
-								for j in range(i):
-									if (natures[j] & oNature) != 0:
-										visitNext = 1
-										break
-								if visitNext != 0:
-									break	 
-							count = count+1
-							winner = it.object
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		return winner
-
-## the natural chaining iterator
-## It follows the edges of same nature on the same
-## objects with  preseance on silhouettes, then borders, 
-## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
-## You can specify whether to stay in the selection or not.
-## You can specify whether to chain iterate over edges that were 
-## already visited or not.
-class pyChainSilhouetteGenericIterator(ChainingIterator):
-	def __init__(self, stayInSelection=True, stayInUnvisited=True):
-		ChainingIterator.__init__(self, stayInSelection, stayInUnvisited, None, True)
-	def init(self):
-		pass
-	def traverse(self, iter):
-		winner = None
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				if ve.id == mateVE.id:
-					winner = ve
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for i in range(len(natures)):
-				currentNature = self.current_edge.nature
-				if (natures[i] & currentNature) != 0:
-					count=0
-					while not it.is_end:
-						visitNext = 0
-						oNature = it.object.nature
-						ve = it.object
-						if ve.id == self.current_edge.id:
-							it.increment()
-							continue
-						if (oNature & natures[i]) != 0:
-							if natures[i] != oNature:
-								for j in range(i):
-									if (natures[j] & oNature) != 0:
-										visitNext = 1
-										break
-								if visitNext != 0:
-									break	 
-							count = count+1
-							winner = ve
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		return winner
-			
-class pyExternalContourChainingIterator(ChainingIterator):
-	def __init__(self):
-		ChainingIterator.__init__(self, False, True, None, True)
-		self._isExternalContour = ExternalContourUP1D()
-	def init(self):
-		self._nEdges = 0
-		self._isInSelection = 1
-	def checkViewEdge(self, ve, orientation):
-		if orientation != 0:
-			vertex = ve.second_svertex()
-		else:
-			vertex = ve.first_svertex()
-		it = AdjacencyIterator(vertex,1,1)
-		while not it.is_end:
-			ave = it.object
-			if self._isExternalContour(ave):
-				return 1
-			it.increment()
-		print("pyExternlContourChainingIterator : didn't find next edge")
-		return 0
-	def traverse(self, iter):
-		winner = None
-		it = AdjacencyIterator(iter)
-		while not it.is_end:
-			ve = it.object
-			if self._isExternalContour(ve):
-				if ve.time_stamp == CF.get_time_stamp():
-					winner = ve
-			it.increment()
-		
-		self._nEdges = self._nEdges+1
-		if winner is None:
-			orient = 1
-			it = AdjacencyIterator(iter)
-			while not it.is_end:
-				ve = it.object
-				if it.is_incoming:
-					orient = 0
-				good = self.checkViewEdge(ve,orient)
-				if good != 0:
-					winner = ve
-				it.increment()
-		return winner
-
-## the natural chaining iterator
-## with a sketchy multiple touch
-class pySketchyChainSilhouetteIterator(ChainingIterator):
-	def __init__(self, nRounds=3,stayInSelection=True):
-		ChainingIterator.__init__(self, stayInSelection, False, None, True)
-		self._timeStamp = CF.get_time_stamp()+nRounds
-		self._nRounds = nRounds
-	def init(self):
-		self._timeStamp = CF.get_time_stamp()+self._nRounds
-	def traverse(self, iter):
-		winner = None
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				if ve.id == mateVE.id:
-					winner = ve
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for i in range(len(natures)):
-				currentNature = self.current_edge.nature
-				if (natures[i] & currentNature) != 0:
-					count=0
-					while not it.is_end:
-						visitNext = 0
-						oNature = it.object.nature
-						ve = it.object
-						if ve.id == self.current_edge.id:
-							it.increment()
-							continue
-						if (oNature & natures[i]) != 0:
-							if (natures[i] != oNature) != 0:
-								for j in range(i):
-									if (natures[j] & oNature) != 0:
-										visitNext = 1
-										break
-								if visitNext != 0:
-									break
-							count = count+1
-							winner = ve
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		if winner is None:
-			winner = self.current_edge
-		if winner.chaining_time_stamp == self._timeStamp:
-			winner = None
-		return winner
-
-
-# Chaining iterator designed for sketchy style.
-# can chain several times the same ViewEdge
-# in order to produce multiple strokes per ViewEdge.
-class pySketchyChainingIterator(ChainingIterator):
-	def __init__(self, nRounds=3, stayInSelection=True):
-		ChainingIterator.__init__(self, stayInSelection, False, None, True)
-		self._timeStamp = CF.get_time_stamp()+nRounds
-		self._nRounds = nRounds
-	def init(self):
-		self._timeStamp = CF.get_time_stamp()+self._nRounds
-	def traverse(self, iter):
-		winner = None
-		found = False
-		it = AdjacencyIterator(iter)
-		while not it.is_end:
-			ve = it.object
-			if ve.id == self.current_edge.id:
-				found = True
-				it.increment()
-				continue
-			winner = ve
-			it.increment()
-		if not found:
-			# This is a fatal error condition: self.current_edge must be found
-			# among the edges seen by the AdjacencyIterator [bug #35695].
-			if bpy.app.debug_freestyle:
-				print('pySketchyChainingIterator: current edge not found')
-			return None
-		if winner is None:
-			winner = self.current_edge
-		if winner.chaining_time_stamp == self._timeStamp:
-			return None
-		return winner
-
-
-## Chaining iterator that fills small occlusions
-## 	percent
-##		The max length of the occluded part 
-##		expressed in % of the total chain length
-class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
-	def __init__(self, percent):
-		ChainingIterator.__init__(self, False, True, None, True)
-		self._length = 0
-		self._percent = float(percent)
-	def init(self):
-		# each time we're evaluating a chain length 
-		# we try to do it once. Thus we reinit 
-		# the chain length here:
-		self._length = 0
-	def traverse(self, iter):
-		winner = None
-		winnerOrientation = 0
-		#print(self.current_edge.id.first, self.current_edge.id.second)
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				if ve.id == mateVE.id:
-					winner = ve
-					if not it.is_incoming:
-						winnerOrientation = 1
-					else:
-						winnerOrientation = 0
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for nat in natures:
-				if (self.current_edge.nature & nat) != 0:
-					count=0
-					while not it.is_end:
-						ve = it.object
-						if (ve.nature & nat) != 0:
-							count = count+1
-							winner = ve
-							if not it.is_incoming:
-								winnerOrientation = 1
-							else:
-								winnerOrientation = 0
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		if winner is not None:
-			# check whether this edge was part of the selection
-			if winner.time_stamp != CF.get_time_stamp():
-				#print("---", winner.id.first, winner.id.second)
-				# if not, let's check whether it's short enough with
-				# respect to the chain made without staying in the selection
-				#------------------------------------------------------------
-				# Did we compute the prospective chain length already ?
-				if self._length == 0:
-					#if not, let's do it
-					_it = pyChainSilhouetteGenericIterator(0,0)
-					_it.begin = winner
-					_it.current_edge = winner
-					_it.orientation = winnerOrientation
-					_it.init()
-					while not _it.is_end:
-						ve = _it.object
-						#print("--------", ve.id.first, ve.id.second)
-						self._length = self._length + ve.length_2d
-						_it.increment()
-						if _it.is_begin:
-							break;
-					_it.begin = winner
-					_it.current_edge = winner
-					_it.orientation = winnerOrientation
-					if not _it.is_begin:
-						_it.decrement()
-						while (not _it.is_end) and (not _it.is_begin):
-							ve = _it.object
-							#print("--------", ve.id.first, ve.id.second)
-							self._length = self._length + ve.length_2d
-							_it.decrement()
-
-				# let's do the comparison:
-				# nw let's compute the length of this connex non selected part:
-				connexl = 0
-				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.begin = winner
-				_cit.current_edge = winner
-				_cit.orientation = winnerOrientation
-				_cit.init()
-				while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():
-					ve = _cit.object
-					#print("-------- --------", ve.id.first, ve.id.second)
-					connexl = connexl + ve.length_2d
-					_cit.increment()
-				if connexl > self._percent * self._length:
-					winner = None
-		return winner
-
-## Chaining iterator that fills small occlusions
-## 	size
-##		The max length of the occluded part 
-##		expressed in pixels
-class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
-	def __init__(self, length):
-		ChainingIterator.__init__(self, False, True, None, True)
-		self._length = float(length)
-	def init(self):
-		pass
-	def traverse(self, iter):
-		winner = None
-		winnerOrientation = 0
-		#print(self.current_edge.id.first, self.current_edge.id.second)
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				if ve.id == mateVE.id:
-					winner = ve
-					if not it.is_incoming:
-						winnerOrientation = 1
-					else:
-						winnerOrientation = 0
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for nat in natures:
-				if (self.current_edge.nature & nat) != 0:
-					count=0
-					while not it.is_end:
-						ve = it.object
-						if (ve.nature & nat) != 0:
-							count = count+1
-							winner = ve
-							if not it.is_incoming:
-								winnerOrientation = 1
-							else:
-								winnerOrientation = 0
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		if winner is not None:
-			# check whether this edge was part of the selection
-			if winner.time_stamp != CF.get_time_stamp():
-				#print("---", winner.id.first, winner.id.second)
-				# nw let's compute the length of this connex non selected part:
-				connexl = 0
-				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.begin = winner
-				_cit.current_edge = winner
-				_cit.orientation = winnerOrientation
-				_cit.init()
-				while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():
-					ve = _cit.object
-					#print("-------- --------", ve.id.first, ve.id.second)
-					connexl = connexl + ve.length_2d
-					_cit.increment()
-				if connexl > self._length:
-					winner = None
-		return winner
-
-
-## Chaining iterator that fills small occlusions
-## 	percent
-##		The max length of the occluded part 
-##		expressed in % of the total chain length
-class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
-	def __init__(self, percent, l):
-		ChainingIterator.__init__(self, False, True, None, True)
-		self._length = 0
-		self._absLength = l
-		self._percent = float(percent)
-	def init(self):
-		# each time we're evaluating a chain length 
-		# we try to do it once. Thus we reinit 
-		# the chain length here:
-		self._length = 0
-	def traverse(self, iter):
-		winner = None
-		winnerOrientation = 0
-		#print(self.current_edge.id.first, self.current_edge.id.second)
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				if ve.id == mateVE.id:
-					winner = ve
-					if not it.is_incoming:
-						winnerOrientation = 1
-					else:
-						winnerOrientation = 0
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for nat in natures:
-				if (self.current_edge.nature & nat) != 0:
-					count=0
-					while not it.is_end:
-						ve = it.object
-						if (ve.nature & nat) != 0:
-							count = count+1
-							winner = ve
-							if not it.is_incoming:
-								winnerOrientation = 1
-							else:
-								winnerOrientation = 0
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		if winner is not None:
-			# check whether this edge was part of the selection
-			if winner.time_stamp != CF.get_time_stamp():
-				#print("---", winner.id.first, winner.id.second)
-				# if not, let's check whether it's short enough with
-				# respect to the chain made without staying in the selection
-				#------------------------------------------------------------
-				# Did we compute the prospective chain length already ?
-				if self._length == 0:
-					#if not, let's do it
-					_it = pyChainSilhouetteGenericIterator(0,0)
-					_it.begin = winner
-					_it.current_edge = winner
-					_it.orientation = winnerOrientation
-					_it.init()
-					while not _it.is_end:
-						ve = _it.object
-						#print("--------", ve.id.first, ve.id.second)
-						self._length = self._length + ve.length_2d
-						_it.increment()
-						if _it.is_begin:
-							break;
-					_it.begin = winner
-					_it.current_edge = winner
-					_it.orientation = winnerOrientation
-					if not _it.is_begin:
-						_it.decrement()
-						while (not _it.is_end) and (not _it.is_begin):
-							ve = _it.object
-							#print("--------", ve.id.first, ve.id.second)
-							self._length = self._length + ve.length_2d
-							_it.decrement()
-
-				# let's do the comparison:
-				# nw let's compute the length of this connex non selected part:
-				connexl = 0
-				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.begin = winner
-				_cit.current_edge = winner
-				_cit.orientation = winnerOrientation
-				_cit.init()
-				while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():
-					ve = _cit.object
-					#print("-------- --------", ve.id.first, ve.id.second)
-					connexl = connexl + ve.length_2d
-					_cit.increment()
-				if (connexl > self._percent * self._length) or (connexl > self._absLength):
-					winner = None
-		return winner
-
-## Chaining iterator that fills small occlusions without caring about the 
-## actual selection
-## 	percent
-##		The max length of the occluded part 
-##		expressed in % of the total chain length
-class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
-	def __init__(self, percent, l):
-		ChainingIterator.__init__(self, False, True, None, True)
-		self._length = 0
-		self._absLength = l
-		self._percent = float(percent)
-	def init(self):
-		# each time we're evaluating a chain length 
-		# we try to do it once. Thus we reinit 
-		# the chain length here:
-		self._length = 0
-	def traverse(self, iter):
-		winner = None
-		winnerOrientation = 0
-		#print(self.current_edge.id.first, self.current_edge.id.second)
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				if ve.id == mateVE.id:
-					winner = ve
-					if not it.is_incoming:
-						winnerOrientation = 1
-					else:
-						winnerOrientation = 0
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for nat in natures:
-				if (self.current_edge.nature & nat) != 0:
-					count=0
-					while not it.is_end:
-						ve = it.object
-						if (ve.nature & nat) != 0:
-							count = count+1
-							winner = ve
-							if not it.is_incoming:
-								winnerOrientation = 1
-							else:
-								winnerOrientation = 0
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		if winner is not None:
-			# check whether this edge was part of the selection
-			if winner.qi != 0:
-				#print("---", winner.id.first, winner.id.second)
-				# if not, let's check whether it's short enough with
-				# respect to the chain made without staying in the selection
-				#------------------------------------------------------------
-				# Did we compute the prospective chain length already ?
-				if self._length == 0:
-					#if not, let's do it
-					_it = pyChainSilhouetteGenericIterator(0,0)
-					_it.begin = winner
-					_it.current_edge = winner
-					_it.orientation = winnerOrientation
-					_it.init()
-					while not _it.is_end:
-						ve = _it.object
-						#print("--------", ve.id.first, ve.id.second)
-						self._length = self._length + ve.length_2d
-						_it.increment()
-						if _it.is_begin:
-							break;
-					_it.begin = winner
-					_it.current_edge = winner
-					_it.orientation = winnerOrientation
-					if not _it.is_begin:
-						_it.decrement()
-						while (not _it.is_end) and (not _it.is_begin):
-							ve = _it.object
-							#print("--------", ve.id.first, ve.id.second)
-							self._length = self._length + ve.length_2d
-							_it.decrement()
-
-				# let's do the comparison:
-				# nw let's compute the length of this connex non selected part:
-				connexl = 0
-				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.begin = winner
-				_cit.current_edge = winner
-				_cit.orientation = winnerOrientation
-				_cit.init()
-				while not _cit.is_end and _cit.object.qi != 0:
-					ve = _cit.object
-					#print("-------- --------", ve.id.first, ve.id.second)
-					connexl = connexl + ve.length_2d
-					_cit.increment()
-				if (connexl > self._percent * self._length) or (connexl > self._absLength):
-					winner = None
-		return winner
-
-
-## the natural chaining iterator
-## It follows the edges of same nature on the same
-## objects with  preseance on silhouettes, then borders, 
-## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
-## You can specify whether to stay in the selection or not.
-class pyNoIdChainSilhouetteIterator(ChainingIterator):
-	def __init__(self, stayInSelection=True):
-		ChainingIterator.__init__(self, stayInSelection, True, None, True)
-	def init(self):
-		pass
-	def traverse(self, iter):
-		winner = None
-		it = AdjacencyIterator(iter)
-		tvertex = self.next_vertex
-		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.current_edge)
-			while not it.is_end:
-				ve = it.object
-				feB = self.current_edge.last_fedge
-				feA = ve.first_fedge
-				vB = feB.second_svertex
-				vA = feA.first_svertex
-				if vA.id.first == vB.id.first:
-					winner = ve
-					break
-				feA = self.current_edge.first_fedge
-				feB = ve.last_fedge
-				vB = feB.second_svertex
-				vA = feA.first_svertex
-				if vA.id.first == vB.id.first:
-					winner = ve
-					break
-				feA = self.current_edge.last_fedge
-				feB = ve.last_fedge
-				vB = feB.second_svertex
-				vA = feA.second_svertex
-				if vA.id.first == vB.id.first:
-					winner = ve
-					break
-				feA = self.current_edge.first_fedge
-				feB = ve.first_fedge
-				vB = feB.first_svertex
-				vA = feA.first_svertex
-				if vA.id.first == vB.id.first:
-					winner = ve
-					break
-				it.increment()
-		else:
-			## case of NonTVertex
-			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
-			for i in range(len(natures)):
-				currentNature = self.current_edge.nature
-				if (natures[i] & currentNature) != 0:
-					count=0
-					while not it.is_end:
-						visitNext = 0
-						oNature = it.object.nature
-						if (oNature & natures[i]) != 0:
-							if natures[i] != oNature:
-								for j in range(i):
-									if (natures[j] & oNature) != 0:
-										visitNext = 1
-										break
-								if visitNext != 0:
-									break	 
-							count = count+1
-							winner = it.object
-						it.increment()
-					if count != 1:
-						winner = None
-					break
-		return winner
-
diff --git a/release/scripts/freestyle/style_modules/Functions0D.py b/release/scripts/freestyle/style_modules/Functions0D.py
deleted file mode 100644
index eac168a3b6d..00000000000
--- a/release/scripts/freestyle/style_modules/Functions0D.py
+++ /dev/null
@@ -1,105 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : Functions0D.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 30/06/2005
-#  Purpose  : Functions (functors) to be used for 0D elements
-
-from freestyle import Curvature2DAngleF0D, CurvePoint, ReadCompleteViewMapPixelF0D, \
-    ReadSteerableViewMapPixelF0D, UnaryFunction0DDouble, UnaryFunction0DMaterial, \
-    UnaryFunction0DVec2f
-from freestyle import ContextFunctions as CF
-
-import math
-import mathutils
-
-class CurveMaterialF0D(UnaryFunction0DMaterial):
-	# A replacement of the built-in MaterialF0D for stroke creation.
-	# MaterialF0D does not work with Curves and Strokes.
-	def __call__(self, inter):
-		cp = inter.object
-		assert(isinstance(cp, CurvePoint))
-		fe = cp.first_svertex.get_fedge(cp.second_svertex)
-		assert(fe is not None)
-		return fe.material if fe.is_smooth else fe.material_left
-
-class pyInverseCurvature2DAngleF0D(UnaryFunction0DDouble):
-	def __call__(self, inter):
-		func = Curvature2DAngleF0D()
-		c = func(inter)
-		return (3.1415 - c)
-
-class pyCurvilinearLengthF0D(UnaryFunction0DDouble):
-	def __call__(self, inter):
-		cp = inter.object		
-		assert(isinstance(cp, CurvePoint))
-		return cp.t2d
-
-## estimate anisotropy of density
-class pyDensityAnisotropyF0D(UnaryFunction0DDouble):
-	def __init__(self,level):
-		UnaryFunction0DDouble.__init__(self)
-		self.IsoDensity = ReadCompleteViewMapPixelF0D(level)
-		self.d0Density = ReadSteerableViewMapPixelF0D(0, level)
-		self.d1Density = ReadSteerableViewMapPixelF0D(1, level)
-		self.d2Density = ReadSteerableViewMapPixelF0D(2, level)
-		self.d3Density = ReadSteerableViewMapPixelF0D(3, level)
-	def __call__(self, inter):
-		c_iso = self.IsoDensity(inter) 
-		c_0 = self.d0Density(inter) 
-		c_1 = self.d1Density(inter) 
-		c_2 = self.d2Density(inter) 
-		c_3 = self.d3Density(inter) 
-		cMax = max(max(c_0,c_1), max(c_2,c_3))
-		cMin = min(min(c_0,c_1), min(c_2,c_3))
-		if c_iso == 0:
-			v = 0
-		else:
-			v = (cMax-cMin)/c_iso
-		return v
-
-## Returns the gradient vector for a pixel 
-## 	l
-##	  the level at which one wants to compute the gradient
-class pyViewMapGradientVectorF0D(UnaryFunction0DVec2f):
-	def __init__(self, l):
-		UnaryFunction0DVec2f.__init__(self)
-		self._l = l
-		self._step = math.pow(2,self._l)
-	def __call__(self, iter):
-		p = iter.object.point_2d
-		gx = CF.read_complete_view_map_pixel(self._l, int(p.x+self._step), int(p.y)) - \
-		    CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
-		gy = CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y+self._step)) - \
-		    CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
-		return mathutils.Vector([gx, gy])
-
-class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
-	def __init__(self, l):
-		UnaryFunction0DDouble.__init__(self)
-		self._l = l
-		self._step = math.pow(2,self._l)
-	def __call__(self, iter):
-		p = iter.object.point_2d
-		gx = CF.read_complete_view_map_pixel(self._l, int(p.x+self._step), int(p.y)) - \
-		    CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
-		gy = CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y+self._step)) - \
-		    CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
-		grad = mathutils.Vector([gx, gy])
-		return grad.length
diff --git a/release/scripts/freestyle/style_modules/Functions1D.py b/release/scripts/freestyle/style_modules/Functions1D.py
deleted file mode 100644
index 3e74b1817eb..00000000000
--- a/release/scripts/freestyle/style_modules/Functions1D.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : Functions1D.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 08/04/2005
-#  Purpose  : Functions (functors) to be used for 1D elements
-
-from freestyle import GetProjectedZF1D, IntegrationType, UnaryFunction1DDouble, integrate
-from Functions0D import pyDensityAnisotropyF0D, pyViewMapGradientNormF0D
-import string 
-
-class pyGetInverseProjectedZF1D(UnaryFunction1DDouble):
-	def __call__(self, inter):
-		func = GetProjectedZF1D()
-		z = func(inter)
-		return (1.0 - z)
-
-class pyGetSquareInverseProjectedZF1D(UnaryFunction1DDouble):
-	def __call__(self, inter):
-		func = GetProjectedZF1D()
-		z = func(inter)
-		return (1.0 - z*z)
-
-class pyDensityAnisotropyF1D(UnaryFunction1DDouble):
-	def __init__(self,level,  integrationType=IntegrationType.MEAN, sampling=2.0):
-		UnaryFunction1DDouble.__init__(self, integrationType)
-		self._func = pyDensityAnisotropyF0D(level)
-		self._integration = integrationType
-		self._sampling = sampling
-	def __call__(self, inter):
-		v = integrate(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
-		return v
-
-class pyViewMapGradientNormF1D(UnaryFunction1DDouble):
-	def __init__(self,l, integrationType, sampling=2.0):
-		UnaryFunction1DDouble.__init__(self, integrationType)
-		self._func = pyViewMapGradientNormF0D(l)
-		self._integration = integrationType
-		self._sampling = sampling
-	def __call__(self, inter):
-		v = integrate(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
-		return v
diff --git a/release/scripts/freestyle/style_modules/PredicatesB1D.py b/release/scripts/freestyle/style_modules/PredicatesB1D.py
deleted file mode 100644
index 604692a999f..00000000000
--- a/release/scripts/freestyle/style_modules/PredicatesB1D.py
+++ /dev/null
@@ -1,73 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : PredicatesB1D.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 08/04/2005
-#  Purpose  : Binary predicates (functors) to be used for 1D elements
-
-from freestyle import BinaryPredicate1D, GetZF1D, IntegrationType, Nature, SameShapeIdBP1D, ZDiscontinuityF1D
-from Functions1D import pyViewMapGradientNormF1D
-
-import random
-
-class pyZBP1D(BinaryPredicate1D):
-	def __call__(self, i1, i2):
-		func = GetZF1D()
-		return (func(i1) > func(i2))
-
-class pyZDiscontinuityBP1D(BinaryPredicate1D):
-	def __init__(self, iType = IntegrationType.MEAN):
-		BinaryPredicate1D.__init__(self)
-		self._GetZDiscontinuity = ZDiscontinuityF1D(iType)
-	def __call__(self, i1, i2):
-		return (self._GetZDiscontinuity(i1) > self._GetZDiscontinuity(i2))
-
-class pyLengthBP1D(BinaryPredicate1D):
-	def __call__(self, i1, i2):
-		return (i1.length_2d > i2.length_2d)
-
-class pySilhouetteFirstBP1D(BinaryPredicate1D):
-	def __call__(self, inter1, inter2):
-		bpred = SameShapeIdBP1D()
-		if (bpred(inter1, inter2) != 1):
-			return 0
-		if (inter1.nature & Nature.SILHOUETTE):
-			return (inter2.nature & Nature.SILHOUETTE) != 0
-		return (inter1.nature == inter2.nature)
-
-class pyNatureBP1D(BinaryPredicate1D):
-	def __call__(self, inter1, inter2):
-		return (inter1.nature & inter2.nature)
-
-class pyViewMapGradientNormBP1D(BinaryPredicate1D):
-	def __init__(self,l, sampling=2.0):
-		BinaryPredicate1D.__init__(self)
-		self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
-	def __call__(self, i1,i2):
-		#print("compare gradient")
-		return (self._GetGradient(i1) > self._GetGradient(i2))
-
-class pyShuffleBP1D(BinaryPredicate1D):
-	def __init__(self):
-		BinaryPredicate1D.__init__(self)
-		random.seed(1)
-	def __call__(self, inter1, inter2):
-		r1 = random.uniform(0,1)
-		r2 = random.uniform(0,1)
-		return (r1<r2)
diff --git a/release/scripts/freestyle/style_modules/PredicatesU0D.py b/release/scripts/freestyle/style_modules/PredicatesU0D.py
deleted file mode 100644
index 7119740ce49..00000000000
--- a/release/scripts/freestyle/style_modules/PredicatesU0D.py
+++ /dev/null
@@ -1,96 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : PredicatesU0D.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 08/04/2005
-#  Purpose  : Unary predicates (functors) to be used for 0D elements
-
-from freestyle import Curvature2DAngleF0D, Nature, QuantitativeInvisibilityF0D, UnaryPredicate0D
-from Functions0D import pyCurvilinearLengthF0D
-
-class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):
-	def __init__(self,a):
-		UnaryPredicate0D.__init__(self)
-		self._a = a
-	def __call__(self, inter):
-		func = Curvature2DAngleF0D()
-		a = func(inter)
-		return (a > self._a)
-
-class pyUEqualsUP0D(UnaryPredicate0D):
-	def __init__(self,u, w):
-		UnaryPredicate0D.__init__(self)
-		self._u = u
-		self._w = w
-	def __call__(self, inter):
-		func = pyCurvilinearLengthF0D()
-		u = func(inter)
-		return (u > (self._u-self._w)) and (u < (self._u+self._w))
-
-class pyVertexNatureUP0D(UnaryPredicate0D):
-	def __init__(self,nature):
-		UnaryPredicate0D.__init__(self)
-		self._nature = nature
-	def __call__(self, inter):
-		v = inter.object
-		return (v.nature & self._nature) != 0
-
-## check whether an Interface0DIterator
-## is a TVertex and is the one that is 
-## hidden (inferred from the context)
-class pyBackTVertexUP0D(UnaryPredicate0D):
-	def __init__(self):
-		UnaryPredicate0D.__init__(self)
-		self._getQI = QuantitativeInvisibilityF0D()
-	def __call__(self, iter):
-		if (iter.object.nature & Nature.T_VERTEX) == 0:
-			return 0
-		if iter.is_end:
-			return 0
-		if self._getQI(iter) != 0:
-			return 1
-		return 0
-
-class pyParameterUP0DGoodOne(UnaryPredicate0D):
-	def __init__(self,pmin,pmax):
-		UnaryPredicate0D.__init__(self)
-		self._m = pmin
-		self._M = pmax
-		#self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
-	def __call__(self, inter):
-		#s = self.getCurvilinearAbscissa(inter)
-		u = inter.u
-		#print(u)
-		return ((u>=self._m) and (u<=self._M))
-
-class pyParameterUP0D(UnaryPredicate0D):
-	def __init__(self,pmin,pmax):
-		UnaryPredicate0D.__init__(self)
-		self._m = pmin
-		self._M = pmax
-		#self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
-	def __call__(self, inter):
-		func = Curvature2DAngleF0D()
-		c = func(inter)
-		b1 = (c>0.1)
-		#s = self.getCurvilinearAbscissa(inter)
-		u = inter.u
-		#print(u)
-		b = ((u>=self._m) and (u<=self._M))
-		return b and b1
diff --git a/release/scripts/freestyle/style_modules/PredicatesU1D.py b/release/scripts/freestyle/style_modules/PredicatesU1D.py
deleted file mode 100644
index 54f920d0563..00000000000
--- a/release/scripts/freestyle/style_modules/PredicatesU1D.py
+++ /dev/null
@@ -1,342 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : PredicatesU1D.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 08/04/2005
-#  Purpose  : Unary predicates (functors) to be used for 1D elements
-
-from freestyle import Curvature2DAngleF0D, CurveNatureF1D, DensityF1D, GetCompleteViewMapDensityF1D, \
-    GetDirectionalViewMapDensityF1D, GetOccludersF1D, GetProjectedZF1D, GetShapeF1D, GetSteerableViewMapDensityF1D, \
-    IntegrationType, ShapeUP1D, TVertex, UnaryPredicate1D
-from Functions1D import pyDensityAnisotropyF1D, pyViewMapGradientNormF1D
-
-class pyNFirstUP1D(UnaryPredicate1D):
-	def __init__(self, n):
-		UnaryPredicate1D.__init__(self)
-		self.__n = n
-		self.__count = 0
-	def __call__(self, inter):
-		self.__count = self.__count + 1
-		if self.__count <= self.__n:
-			return 1
-		return 0
-
-class pyHigherLengthUP1D(UnaryPredicate1D):
-	def __init__(self,l):
-		UnaryPredicate1D.__init__(self)
-		self._l = l
-	def __call__(self, inter):
-		return (inter.length_2d > self._l)
-
-class pyNatureUP1D(UnaryPredicate1D):
-	def __init__(self,nature):
-		UnaryPredicate1D.__init__(self)
-		self._nature = nature
-		self._getNature = CurveNatureF1D()
-	def __call__(self, inter):
-		if(self._getNature(inter) & self._nature):
-			return 1
-		return 0
-
-class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
-	def __init__(self,n,a):
-		UnaryPredicate1D.__init__(self)
-		self._n = n
-		self._a = a
-	def __call__(self, inter):
-		count = 0
-		func = Curvature2DAngleF0D()
-		it = inter.vertices_begin()
-		while not it.is_end:
-			if func(it) > self._a:
-				count = count+1
-			if count > self._n:
-				return 1
-			it.increment()
-		return 0
-
-class pyDensityUP1D(UnaryPredicate1D):
-	def __init__(self,wsize,threshold, integration = IntegrationType.MEAN, sampling=2.0):
-		UnaryPredicate1D.__init__(self)
-		self._wsize = wsize
-		self._threshold = threshold
-		self._integration = integration
-		self._func = DensityF1D(self._wsize, self._integration, sampling)
-	def __call__(self, inter):
-		if self._func(inter) < self._threshold:
-			return 1
-		return 0
-
-class pyLowSteerableViewMapDensityUP1D(UnaryPredicate1D):
-	def __init__(self,threshold, level,integration = IntegrationType.MEAN):
-		UnaryPredicate1D.__init__(self)
-		self._threshold = threshold
-		self._level = level
-		self._integration = integration
-	def __call__(self, inter):
-		func = GetSteerableViewMapDensityF1D(self._level, self._integration)
-		v = func(inter)
-		#print(v)
-		if v < self._threshold:
-			return 1
-		return 0
-
-class pyLowDirectionalViewMapDensityUP1D(UnaryPredicate1D):
-	def __init__(self,threshold, orientation, level,integration = IntegrationType.MEAN):
-		UnaryPredicate1D.__init__(self)
-		self._threshold = threshold
-		self._orientation = orientation
-		self._level = level
-		self._integration = integration
-	def __call__(self, inter):
-		func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration)
-		v = func(inter)
-		#print(v)
-		if v < self._threshold:
-			return 1
-		return 0
-
-class pyHighSteerableViewMapDensityUP1D(UnaryPredicate1D):
-	def __init__(self,threshold, level,integration = IntegrationType.MEAN):
-		UnaryPredicate1D.__init__(self)
-		self._threshold = threshold
-		self._level = level
-		self._integration = integration
-		self._func = GetSteerableViewMapDensityF1D(self._level, self._integration)	
-	def __call__(self, inter):
-		v = self._func(inter)
-		if v > self._threshold:
-			return 1
-		return 0
-
-class pyHighDirectionalViewMapDensityUP1D(UnaryPredicate1D):
-	def __init__(self,threshold, orientation, level,integration = IntegrationType.MEAN, sampling=2.0):
-		UnaryPredicate1D.__init__(self)
-		self._threshold = threshold
-		self._orientation = orientation
-		self._level = level
-		self._integration = integration
-		self._sampling = sampling		
-	def __call__(self, inter):
-		func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration, self._sampling)
-		v = func(inter)
-		if v > self._threshold:
-			return 1
-		return 0
-
-class pyHighViewMapDensityUP1D(UnaryPredicate1D):
-	def __init__(self,threshold, level,integration = IntegrationType.MEAN, sampling=2.0):
-		UnaryPredicate1D.__init__(self)
-		self._threshold = threshold
-		self._level = level
-		self._integration = integration
-		self._sampling = sampling
-		self._func = GetCompleteViewMapDensityF1D(self._level, self._integration, self._sampling) # 2.0 is the smpling
-	def __call__(self, inter):
-		#print("toto")
-		#print(func.name)
-		#print(inter.name)
-		v= self._func(inter)
-		if v > self._threshold:
-			return 1
-		return 0
-
-class pyDensityFunctorUP1D(UnaryPredicate1D):
-	def __init__(self,wsize,threshold, functor, funcmin=0.0, funcmax=1.0, integration = IntegrationType.MEAN):
-		UnaryPredicate1D.__init__(self)
-		self._wsize = wsize
-		self._threshold = float(threshold)
-		self._functor = functor
-		self._funcmin = float(funcmin)
-		self._funcmax = float(funcmax)
-		self._integration = integration
-	def __call__(self, inter):
-		func = DensityF1D(self._wsize, self._integration)
-		res = self._functor(inter)
-		k = (res-self._funcmin)/(self._funcmax-self._funcmin)
-		if func(inter) < self._threshold*k:
-			return 1
-		return 0
-
-class pyZSmallerUP1D(UnaryPredicate1D):
-	def __init__(self,z, integration=IntegrationType.MEAN):
-		UnaryPredicate1D.__init__(self)
-		self._z = z
-		self._integration = integration
-	def __call__(self, inter):
-		func = GetProjectedZF1D(self._integration)
-		if func(inter) < self._z:
-			return 1
-		return 0
-
-class pyIsOccludedByUP1D(UnaryPredicate1D):
-	def __init__(self,id):
-		UnaryPredicate1D.__init__(self)
-		self._id = id
-	def __call__(self, inter):
-		func = GetShapeF1D()
-		shapes = func(inter)
-		for s in shapes:
-			if(s.id == self._id):
-				return 0
-		it = inter.vertices_begin()
-		itlast = inter.vertices_end()
-		itlast.decrement()
-		v =  it.object
-		vlast = itlast.object
-		tvertex = v.viewvertex
-		if type(tvertex) is TVertex:
-			#print("TVertex: [ ", tvertex.id.first, ",",  tvertex.id.second," ]")
-			eit = tvertex.edges_begin()
-			while not eit.is_end:
-				ve, incoming = eit.object
-				if ve.id == self._id:
-					return 1
-				#print("-------", ve.id.first, "-", ve.id.second)
-				eit.increment()
-		tvertex = vlast.viewvertex
-		if type(tvertex) is TVertex:
-			#print("TVertex: [ ", tvertex.id.first, ",",  tvertex.id.second," ]")
-			eit = tvertex.edges_begin()
-			while not eit.is_end:
-				ve, incoming = eit.object
-				if ve.id == self._id:
-					return 1
-				#print("-------", ve.id.first, "-", ve.id.second)
-				eit.increment()
-		return 0
-
-class pyIsInOccludersListUP1D(UnaryPredicate1D):
-	def __init__(self,id):
-		UnaryPredicate1D.__init__(self)
-		self._id = id
-	def __call__(self, inter):
-		func = GetOccludersF1D()
-		occluders = func(inter)
-		for a in occluders:
-			if a.id == self._id:
-				return 1
-		return 0
-
-class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
-	def __init__(self):
-		UnaryPredicate1D.__init__(self)
-		self.__func1 = GetOccludersF1D()
-		self.__func2 = GetShapeF1D()
-	def __call__(self, inter):
-		lst1 = self.__func1(inter)
-		lst2 = self.__func2(inter)
-		for vs1 in lst1:
-			for vs2 in lst2:
-				if vs1.id == vs2.id:
-					return 1
-		return 0
-
-class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
-	def __init__(self, idlist):
-		UnaryPredicate1D.__init__(self)
-		self._idlist = idlist
-		self.__func1 = GetOccludersF1D()
-	def __call__(self, inter):
-		lst1 = self.__func1(inter)
-		for vs1 in lst1:
-			for _id in self._idlist:
-				if vs1.id == _id:
-					return 1
-		return 0
-
-class pyShapeIdListUP1D(UnaryPredicate1D):
-	def __init__(self,idlist):
-		UnaryPredicate1D.__init__(self)
-		self._idlist = idlist
-		self._funcs = []
-		for _id in idlist :
-			self._funcs.append(ShapeUP1D(_id.first, _id.second))
-	def __call__(self, inter):
-		for func in self._funcs :
-			if func(inter) == 1:
-				return 1
-		return 0
-
-## deprecated
-class pyShapeIdUP1D(UnaryPredicate1D):
-	def __init__(self, _id):
-		UnaryPredicate1D.__init__(self)
-		self._id = _id
-	def __call__(self, inter):
-		func = GetShapeF1D()
-		shapes = func(inter)
-		for a in shapes:
-			if a.id == self._id:
-				return 1
-		return 0
-
-class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):
-	def __init__(self,threshold, level, sampling=2.0):
-		UnaryPredicate1D.__init__(self)
-		self._l = threshold
-		self.func = pyDensityAnisotropyF1D(level, IntegrationType.MEAN, sampling)
-	def __call__(self, inter):
-		return (self.func(inter) > self._l)
-
-class pyHighViewMapGradientNormUP1D(UnaryPredicate1D):
-	def __init__(self,threshold, l, sampling=2.0):
-		UnaryPredicate1D.__init__(self)
-		self._threshold = threshold
-		self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
-	def __call__(self, inter):
-		gn = self._GetGradient(inter)
-		#print(gn)
-		return (gn > self._threshold)
-
-class pyDensityVariableSigmaUP1D(UnaryPredicate1D):
-	def __init__(self,functor, sigmaMin,sigmaMax, lmin, lmax, tmin, tmax, integration = IntegrationType.MEAN, sampling=2.0):
-		UnaryPredicate1D.__init__(self)
-		self._functor = functor
-		self._sigmaMin = float(sigmaMin)
-		self._sigmaMax = float(sigmaMax)
-		self._lmin = float(lmin)
-		self._lmax = float(lmax)
-		self._tmin = tmin
-		self._tmax = tmax
-		self._integration = integration
-		self._sampling = sampling
-	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
-		if sigma < self._sigmaMin:
-			sigma = self._sigmaMin
-		self._func = DensityF1D(sigma, self._integration, self._sampling)
-		d = self._func(inter)
-		if d < t:
-			return 1
-		return 0
-
-class pyClosedCurveUP1D(UnaryPredicate1D):
-	def __call__(self, inter):
-		it = inter.vertices_begin()
-		itlast = inter.vertices_end()
-		itlast.decrement()	
-		vlast = itlast.object
-		v = it.object
-		#print(v.id.first, v.id.second)
-		#print(vlast.id.first, vlast.id.second)
-		if v.id == vlast.id:
-			return 1
-		return 0
diff --git a/release/scripts/freestyle/style_modules/anisotropic_diffusion.py b/release/scripts/freestyle/style_modules/anisotropic_diffusion.py
deleted file mode 100644
index 274381a9a89..00000000000
--- a/release/scripts/freestyle/style_modules/anisotropic_diffusion.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : anisotropic_diffusion.py
-#  Author   : Fredo Durand
-#  Date     : 12/08/2004
-#  Purpose  : Smoothes lines using an anisotropic diffusion scheme
-
-from freestyle import ChainPredicateIterator, ConstantThicknessShader, ExternalContourUP1D, IncreasingColorShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, Stroke, StrokeTextureShader, TrueBP1D, TrueUP1D
-from logical_operators import AndUP1D, NotUP1D
-from shaders import pyDiffusion2Shader
-
-# pyDiffusion2Shader parameters
-offset = 0.25
-nbIter = 30
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
-Operators.select(upred)
-bpred = TrueBP1D()
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
-shaders_list = [
-    ConstantThicknessShader(4),
-    StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, False),
-    SamplingShader(2),
-    pyDiffusion2Shader(offset, nbIter),
-    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/apriori_and_causal_density.py b/release/scripts/freestyle/style_modules/apriori_and_causal_density.py
deleted file mode 100644
index 501c5169be9..00000000000
--- a/release/scripts/freestyle/style_modules/apriori_and_causal_density.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : apriori_and_causal_density.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Selects the lines with high a priori density and 
-#             subjects them to the causal density so as to avoid 
-#             cluttering
-
-from freestyle import ChainPredicateIterator, ConstantColorShader, ConstantThicknessShader, IntegrationType, \
-    Operators, QuantitativeInvisibilityUP1D, TrueBP1D
-from PredicatesU1D import pyDensityUP1D, pyHighViewMapDensityUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.3, IntegrationType.LAST))
-Operators.select(upred)
-bpred = TrueBP1D()
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    ConstantThicknessShader(2),
-    ConstantColorShader(0, 0, 0, 1),
-    ]
-Operators.create(pyDensityUP1D(1, 0.1, IntegrationType.MEAN), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/apriori_density.py b/release/scripts/freestyle/style_modules/apriori_density.py
deleted file mode 100644
index f59dd5cd36d..00000000000
--- a/release/scripts/freestyle/style_modules/apriori_density.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : apriori_density.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws lines having a high a priori density
-
-from freestyle import ChainPredicateIterator, ConstantColorShader, ConstantThicknessShader, Operators, \
-    QuantitativeInvisibilityUP1D, TrueBP1D, TrueUP1D
-from PredicatesU1D import pyHighViewMapDensityUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.1,5)))
-bpred = TrueBP1D()
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.0007,5))
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = 	[
-		ConstantThicknessShader(2), 
-		ConstantColorShader(0.0, 0.0, 0.0,1)
-		]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/backbone_stretcher.py b/release/scripts/freestyle/style_modules/backbone_stretcher.py
deleted file mode 100644
index c920d66328e..00000000000
--- a/release/scripts/freestyle/style_modules/backbone_stretcher.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : backbone_stretcher.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Stretches the geometry of visible lines
-
-from freestyle import BackboneStretcherShader, ChainSilhouetteIterator, ConstantColorShader, \
-    Operators, QuantitativeInvisibilityUP1D, TextureAssignerShader, TrueUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    TextureAssignerShader(4),
-    ConstantColorShader(0.5, 0.5, 0.5),
-    BackboneStretcherShader(20),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/blueprint_circles.py b/release/scripts/freestyle/style_modules/blueprint_circles.py
deleted file mode 100644
index 8d80893a6c3..00000000000
--- a/release/scripts/freestyle/style_modules/blueprint_circles.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : blueprint_circles.py
-#  Author   : Emmanuel Turquin
-#  Date     : 04/08/2005
-#  Purpose  : Produces a blueprint using circular contour strokes
-
-from freestyle import ChainPredicateIterator, ConstantThicknessShader, ContourUP1D, IncreasingColorShader, \
-    Operators, QuantitativeInvisibilityUP1D, SameShapeIdBP1D, TextureAssignerShader, TrueUP1D
-from PredicatesU1D import pyHigherLengthUP1D
-from logical_operators import AndUP1D, NotUP1D
-from shaders import pyBluePrintCirclesShader, pyPerlinNoise1DShader
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
-bpred = SameShapeIdBP1D()
-Operators.select(upred)
-Operators.bidirectional_chain(ChainPredicateIterator(upred,bpred), NotUP1D(upred))
-Operators.select(pyHigherLengthUP1D(200))
-shaders_list = [
-    ConstantThicknessShader(5),
-    pyBluePrintCirclesShader(3),
-    pyPerlinNoise1DShader(0.1, 15, 8),
-    TextureAssignerShader(4),
-    IncreasingColorShader(0.8, 0.8, 0.3, 0.4, 0.3, 0.3, 0.3, 0.1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/blueprint_ellipses.py b/release/scripts/freestyle/style_modules/blueprint_ellipses.py
deleted file mode 100644
index d5e9f385c12..00000000000
--- a/release/scripts/freestyle/style_modules/blueprint_ellipses.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : blueprint_ellipses.py
-#  Author   : Emmanuel Turquin
-#  Date     : 04/08/2005
-#  Purpose  : Produces a blueprint using elliptic contour strokes
-
-from freestyle import ChainPredicateIterator, ConstantThicknessShader, ContourUP1D, IncreasingColorShader, \
-    Operators, QuantitativeInvisibilityUP1D, SameShapeIdBP1D, TextureAssignerShader, TrueUP1D
-from PredicatesU1D import pyHigherLengthUP1D
-from logical_operators import AndUP1D, NotUP1D
-from shaders import pyBluePrintEllipsesShader, pyPerlinNoise1DShader
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
-bpred = SameShapeIdBP1D()
-Operators.select(upred)
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
-Operators.select(pyHigherLengthUP1D(200))
-shaders_list = [
-    ConstantThicknessShader(5),
-    pyBluePrintEllipsesShader(3),
-    pyPerlinNoise1DShader(0.1, 10, 8),
-    TextureAssignerShader(4),
-    IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.3, 0.3, 0.3, 0.1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/blueprint_squares.py b/release/scripts/freestyle/style_modules/blueprint_squares.py
deleted file mode 100644
index 35cfc33fd69..00000000000
--- a/release/scripts/freestyle/style_modules/blueprint_squares.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : blueprint_squares.py
-#  Author   : Emmanuel Turquin
-#  Date     : 04/08/2005
-#  Purpose  : Produces a blueprint using square contour strokes
-
-from freestyle import ChainPredicateIterator, ConstantThicknessShader, ContourUP1D, IncreasingColorShader, \
-    Operators, QuantitativeInvisibilityUP1D, SameShapeIdBP1D, TextureAssignerShader, TrueUP1D
-from PredicatesU1D import pyHigherLengthUP1D
-from logical_operators import AndUP1D, NotUP1D
-from shaders import pyBluePrintSquaresShader, pyPerlinNoise1DShader
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
-bpred = SameShapeIdBP1D()
-Operators.select(upred)
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
-Operators.select(pyHigherLengthUP1D(200))
-shaders_list = [
-    ConstantThicknessShader(8),
-    pyBluePrintSquaresShader(2, 20),
-    pyPerlinNoise1DShader(0.07, 10, 8),
-    TextureAssignerShader(4),
-    IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.6, 0.3, 0.3, 0.3),
-    ConstantThicknessShader(4),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/cartoon.py b/release/scripts/freestyle/style_modules/cartoon.py
deleted file mode 100644
index de4a5dd6c5d..00000000000
--- a/release/scripts/freestyle/style_modules/cartoon.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : cartoon.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws colored lines. The color is automatically 
-#             infered from each object's material in a cartoon-like
-#             fashion.
-
-from freestyle import BezierCurveShader, ChainSilhouetteIterator, ConstantThicknessShader, Operators, \
-    QuantitativeInvisibilityUP1D, TrueUP1D
-from logical_operators import NotUP1D
-from shaders import pyMaterialColorShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    BezierCurveShader(3),
-    ConstantThicknessShader(4),
-    pyMaterialColorShader(0.8),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/contour.py b/release/scripts/freestyle/style_modules/contour.py
deleted file mode 100644
index f7a42d9c906..00000000000
--- a/release/scripts/freestyle/style_modules/contour.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : contour.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws each object's visible contour
-
-from freestyle import ChainPredicateIterator, ConstantThicknessShader, ContourUP1D, IncreasingColorShader, \
-    Operators, QuantitativeInvisibilityUP1D, SameShapeIdBP1D, TrueUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D()))
-bpred = SameShapeIdBP1D()
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    ConstantThicknessShader(5.0),
-    IncreasingColorShader(0.8,0,0,1,0.1,0,0,1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/curvature2d.py b/release/scripts/freestyle/style_modules/curvature2d.py
deleted file mode 100644
index 4204951fbd5..00000000000
--- a/release/scripts/freestyle/style_modules/curvature2d.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : curvature2d.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : The stroke points are colored in gray levels and depending
-#             on the 2d curvature value
-
-from freestyle import ChainSilhouetteIterator, ConstantThicknessShader, Operators, \
-    QuantitativeInvisibilityUP1D, Stroke, StrokeTextureShader, TrueUP1D
-from logical_operators import NotUP1D
-from shaders import py2DCurvatureColorShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, False),
-    ConstantThicknessShader(5),
-    py2DCurvatureColorShader()
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/external_contour.py b/release/scripts/freestyle/style_modules/external_contour.py
deleted file mode 100644
index c7e51f1a16d..00000000000
--- a/release/scripts/freestyle/style_modules/external_contour.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : external_contour.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws the external contour of the scene
-
-from freestyle import ChainPredicateIterator, ConstantColorShader, ConstantThicknessShader, \
-    ExternalContourUP1D, Operators, QuantitativeInvisibilityUP1D, TrueBP1D, TrueUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
-Operators.select(upred)
-bpred = TrueBP1D()
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
-shaders_list = [
-    ConstantThicknessShader(3),
-    ConstantColorShader(0.0, 0.0, 0.0, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/external_contour_sketchy.py b/release/scripts/freestyle/style_modules/external_contour_sketchy.py
deleted file mode 100644
index b8d381ea24e..00000000000
--- a/release/scripts/freestyle/style_modules/external_contour_sketchy.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : external_contour_sketchy.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws the external contour of the scene using a sketchy 
-#             chaining iterator (in particular each ViewEdge can be drawn 
-#             several times
-
-from ChainingIterators import pySketchyChainingIterator
-from freestyle import ExternalContourUP1D, IncreasingColorShader, IncreasingThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, SmoothingShader, SpatialNoiseShader, \
-    TextureAssignerShader, TrueUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D()) 
-Operators.select(upred)
-Operators.bidirectional_chain(pySketchyChainingIterator(), NotUP1D(upred))
-shaders_list = [
-    SamplingShader(4),
-    SpatialNoiseShader(10, 150, 2, 1, 1),
-    IncreasingThicknessShader(4, 10),
-    SmoothingShader(400, 0.1, 0, 0.2, 0, 0, 0, 1),
-    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
-    TextureAssignerShader(4),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/external_contour_smooth.py b/release/scripts/freestyle/style_modules/external_contour_smooth.py
deleted file mode 100644
index 045984ea4a5..00000000000
--- a/release/scripts/freestyle/style_modules/external_contour_smooth.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : external_contour_smooth.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws a smooth external contour
-
-from freestyle import ChainPredicateIterator, ExternalContourUP1D, IncreasingColorShader, \
-    IncreasingThicknessShader, Operators, QuantitativeInvisibilityUP1D, SamplingShader, \
-    SmoothingShader, TrueBP1D, TrueUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
-Operators.select(upred)
-bpred = TrueBP1D()
-Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
-shaders_list = [
-    SamplingShader(2),
-    IncreasingThicknessShader(4,20),
-    IncreasingColorShader(1.0, 0.0, 0.5,1, 0.5,1, 0.3, 1),
-    SmoothingShader(100, 0.05, 0, 0.2, 0, 0, 0, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/haloing.py b/release/scripts/freestyle/style_modules/haloing.py
deleted file mode 100644
index feadb5dd1ee..00000000000
--- a/release/scripts/freestyle/style_modules/haloing.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : haloing.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : This style module selects the lines that 
-#             are connected (in the image) to a specific 
-#             object and trims them in order to produce
-#             a haloing effect around the target shape
-
-from freestyle import ChainSilhouetteIterator, Id, IncreasingColorShader, IncreasingThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TipRemoverShader, TrueUP1D
-from PredicatesU1D import pyIsOccludedByUP1D
-from logical_operators import AndUP1D, NotUP1D
-from shaders import pyTVertexRemoverShader
-
-# id corresponds to the id of the target object 
-# (accessed by SHIFT+click)
-id = Id(3,0)
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyIsOccludedByUP1D(id))
-Operators.select(upred)
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-shaders_list = [
-    IncreasingThicknessShader(3, 5), 
-    IncreasingColorShader(1,0,0, 1,0,1,0,1),
-    SamplingShader(1.0),
-    pyTVertexRemoverShader(),
-    TipRemoverShader(3.0),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/ignore_small_occlusions.py b/release/scripts/freestyle/style_modules/ignore_small_occlusions.py
deleted file mode 100644
index a9dc102a0bd..00000000000
--- a/release/scripts/freestyle/style_modules/ignore_small_occlusions.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : ignore_small_oclusions.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : The strokes are drawn through small occlusions
-
-from ChainingIterators import pyFillOcclusionsAbsoluteChainingIterator
-from freestyle import ConstantColorShader, ConstantThicknessShader, Operators, \
-    QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-#Operators.bidirectional_chain(pyFillOcclusionsChainingIterator(0.1))
-Operators.bidirectional_chain(pyFillOcclusionsAbsoluteChainingIterator(12))
-shaders_list = [
-    SamplingShader(5.0),
-    ConstantThicknessShader(3),
-    ConstantColorShader(0.0, 0.0, 0.0),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/invisible_lines.py b/release/scripts/freestyle/style_modules/invisible_lines.py
deleted file mode 100644
index b94d7b0a5fd..00000000000
--- a/release/scripts/freestyle/style_modules/invisible_lines.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : invisible_lines.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws all lines whose Quantitative Invisibility 
-#             is different from 0
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from logical_operators import NotUP1D
-
-upred = NotUP1D(QuantitativeInvisibilityUP1D(0))
-Operators.select(upred)
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-shaders_list = [
-    SamplingShader(5.0),
-    ConstantThicknessShader(3.0),
-    ConstantColorShader(0.7, 0.7, 0.7),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/japanese_bigbrush.py b/release/scripts/freestyle/style_modules/japanese_bigbrush.py
deleted file mode 100644
index 4a5203fb31f..00000000000
--- a/release/scripts/freestyle/style_modules/japanese_bigbrush.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : japanese_bigbrush.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Simulates a big brush fr oriental painting
-
-from freestyle import BezierCurveShader, ChainSilhouetteIterator, ConstantColorShader, \
-    ConstantThicknessShader, IntegrationType, Operators, QuantitativeInvisibilityUP1D, \
-    SamplingShader, TextureAssignerShader, TipRemoverShader
-from Functions0D import pyInverseCurvature2DAngleF0D
-from PredicatesB1D import pyLengthBP1D
-from PredicatesU0D import pyParameterUP0D
-from PredicatesU1D import pyDensityUP1D, pyHigherLengthUP1D, pyHigherNumberOfTurnsUP1D
-from logical_operators import NotUP1D
-from shaders import pyNonLinearVaryingThicknessShader, pySamplingShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-## Splits strokes at points of highest 2D curavture 
-## when there are too many abrupt turns in it
-func = pyInverseCurvature2DAngleF0D()
-Operators.recursive_split(func, pyParameterUP0D(0.2, 0.8), NotUP1D(pyHigherNumberOfTurnsUP1D(3, 0.5)), 2)
-## Keeps only long enough strokes
-Operators.select(pyHigherLengthUP1D(100))
-## Sorts so as to draw the longest strokes first
-## (this will be done using the causal density)
-Operators.sort(pyLengthBP1D())
-shaders_list = [
-    pySamplingShader(10),
-    BezierCurveShader(30),
-    SamplingShader(50),
-    ConstantThicknessShader(10),
-    pyNonLinearVaryingThicknessShader(4, 25, 0.6),
-    TextureAssignerShader(6),
-    ConstantColorShader(0.2, 0.2, 0.2,1.0),
-    TipRemoverShader(10),
-    ]
-## Use the causal density to avoid cluttering
-Operators.create(pyDensityUP1D(8, 0.4, IntegrationType.MEAN), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/logical_operators.py b/release/scripts/freestyle/style_modules/logical_operators.py
deleted file mode 100644
index 0169ab7f2a7..00000000000
--- a/release/scripts/freestyle/style_modules/logical_operators.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : logical_operators.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 08/04/2005
-#  Purpose  : Logical unary predicates (functors) for 1D elements
-
-from freestyle import UnaryPredicate1D
-
-class AndUP1D(UnaryPredicate1D):
-    def __init__(self, pred1, pred2):
-        UnaryPredicate1D.__init__(self)
-        self.__pred1 = pred1
-        self.__pred2 = pred2
-    def __call__(self, inter):
-        return self.__pred1(inter) and self.__pred2(inter)
-    
-class OrUP1D(UnaryPredicate1D):
-    def __init__(self, pred1, pred2):
-        UnaryPredicate1D.__init__(self)
-        self.__pred1 = pred1
-        self.__pred2 = pred2
-    def __call__(self, inter):
-        return self.__pred1(inter) or self.__pred2(inter)
-
-class NotUP1D(UnaryPredicate1D):
-    def __init__(self, pred):
-        UnaryPredicate1D.__init__(self)
-        self.__pred = pred
-    def __call__(self, inter):
-        return not self.__pred(inter)
diff --git a/release/scripts/freestyle/style_modules/long_anisotropically_dense.py b/release/scripts/freestyle/style_modules/long_anisotropically_dense.py
deleted file mode 100644
index f181bcc2348..00000000000
--- a/release/scripts/freestyle/style_modules/long_anisotropically_dense.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : long_anisotropically_dense.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Selects the lines that are long and have a high anisotropic 
-#             a priori density and uses causal density 
-#             to draw without cluttering. Ideally, half of the
-#             selected lines are culled using the causal density.
-#
-#             ********************* WARNING *************************************
-#             ******** The Directional a priori density maps must          ****** 
-#             ******** have been computed prior to using this style module ******
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, DensityF1D, \
-    IntegrationType, Operators, QuantitativeInvisibilityUP1D, SamplingShader, UnaryPredicate1D
-from PredicatesB1D import pyLengthBP1D
-from PredicatesU1D import pyHighDensityAnisotropyUP1D, pyHigherLengthUP1D
-from logical_operators import NotUP1D
-
-## custom density predicate
-class pyDensityUP1D(UnaryPredicate1D):
-    def __init__(self, wsize, threshold, integration=IntegrationType.MEAN, sampling=2.0):
-        UnaryPredicate1D.__init__(self)
-        self._wsize = wsize
-        self._threshold = threshold
-        self._integration = integration
-        self._func = DensityF1D(self._wsize, self._integration, sampling)
-        self._func2 = DensityF1D(self._wsize, IntegrationType.MAX, sampling)
-    def __call__(self, inter):
-        c = self._func(inter)
-        m = self._func2(inter)
-        if c < self._threshold:
-            return 1
-        if m > 4*c:
-            if c < 1.5*self._threshold:
-                return 1
-        return 0
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(),NotUP1D(QuantitativeInvisibilityUP1D(0)))
-Operators.select(pyHigherLengthUP1D(40))
-## selects lines having a high anisotropic a priori density
-Operators.select(pyHighDensityAnisotropyUP1D(0.3,4))
-Operators.sort(pyLengthBP1D())
-shaders_list = [
-    SamplingShader(2.0),
-    ConstantThicknessShader(2),
-    ConstantColorShader(0.2,0.2,0.25,1), 
-    ]
-## uniform culling
-Operators.create(pyDensityUP1D(3.0,2.0e-2, IntegrationType.MEAN, 0.1), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/multiple_parameterization.py b/release/scripts/freestyle/style_modules/multiple_parameterization.py
deleted file mode 100644
index 922a5ffa972..00000000000
--- a/release/scripts/freestyle/style_modules/multiple_parameterization.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : multiple_parameterization.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : The thickness and the color of the strokes vary continuously 
-#             independently from occlusions although only
-#             visible lines are actually drawn. This is equivalent
-#             to assigning the thickness using a parameterization covering
-#             the complete silhouette (visible+invisible) and drawing
-#             the strokes using a second parameterization that only
-#             covers the visible portions.
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, IncreasingColorShader, \
-    IncreasingThicknessShader, Operators, QuantitativeInvisibilityUP1D, SamplingShader, \
-    TextureAssignerShader, TrueUP1D
-from shaders import pyHLRShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-## Chain following the same nature, but without the restriction
-## of staying inside the selection (0).
-Operators.bidirectional_chain(ChainSilhouetteIterator(0))
-shaders_list = [
-    SamplingShader(20),
-    IncreasingThicknessShader(1.5, 30),
-    ConstantColorShader(0.0, 0.0, 0.0),
-    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
-    TextureAssignerShader(-1),
-    pyHLRShader(), ## this shader draws only visible portions
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/nature.py b/release/scripts/freestyle/style_modules/nature.py
deleted file mode 100644
index fdc627ecade..00000000000
--- a/release/scripts/freestyle/style_modules/nature.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : nature.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Uses the NatureUP1D predicate to select the lines
-#             of a given type (among Nature.SILHOUETTE, Nature.CREASE, Nature.SUGGESTIVE_CONTOURS,
-#             Nature.BORDERS).
-#             The suggestive contours must have been enabled in the 
-#             options dialog to appear in the View Map.
-
-from freestyle import ChainSilhouetteIterator, IncreasingColorShader, \
-    IncreasingThicknessShader, Nature, Operators, TrueUP1D
-from PredicatesU1D import pyNatureUP1D
-from logical_operators import NotUP1D
-
-Operators.select(pyNatureUP1D(Nature.SILHOUETTE))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(pyNatureUP1D(Nature.SILHOUETTE)))
-shaders_list = [
-    IncreasingThicknessShader(3, 10),
-    IncreasingColorShader(0.0, 0.0, 0.0, 1, 0.8, 0, 0, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/near_lines.py b/release/scripts/freestyle/style_modules/near_lines.py
deleted file mode 100644
index 977b99546bc..00000000000
--- a/release/scripts/freestyle/style_modules/near_lines.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : near_lines.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws the lines that are "closer" than a threshold 
-#             (between 0 and 1)
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    IntegrationType, Operators, QuantitativeInvisibilityUP1D, TextureAssignerShader, TrueUP1D
-from PredicatesU1D import pyZSmallerUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyZSmallerUP1D(0.5, IntegrationType.MEAN))
-Operators.select(upred)
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-shaders_list = [
-    TextureAssignerShader(-1),
-    ConstantThicknessShader(5),
-    ConstantColorShader(0.0, 0.0, 0.0),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/occluded_by_specific_object.py b/release/scripts/freestyle/style_modules/occluded_by_specific_object.py
deleted file mode 100644
index 0ae0804f2a8..00000000000
--- a/release/scripts/freestyle/style_modules/occluded_by_specific_object.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : occluded_by_specific_object.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws only the lines that are occluded by a given object
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Id, Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from PredicatesU1D import pyIsInOccludersListUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-## the id of the occluder (use SHIFT+click on the ViewMap to
-## retrieve ids)
-id = Id(3,0)
-upred = AndUP1D(NotUP1D(QuantitativeInvisibilityUP1D(0)), pyIsInOccludersListUP1D(id))
-Operators.select(upred)
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-shaders_list = [
-    SamplingShader(5),
-    ConstantThicknessShader(3),
-    ConstantColorShader(0.3, 0.3, 0.3, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/parameter_editor.py b/release/scripts/freestyle/style_modules/parameter_editor.py
deleted file mode 100644
index 83bd8dbda5e..00000000000
--- a/release/scripts/freestyle/style_modules/parameter_editor.py
+++ /dev/null
@@ -1,1388 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : parameter_editor.py
-#  Authors  : Tamito Kajiyama
-#  Date     : 26/07/2010
-#  Purpose  : Interactive manipulation of stylization parameters
-
-import freestyle
-import math
-import mathutils
-import time
-
-from ChainingIterators import pySketchyChainSilhouetteIterator, pySketchyChainingIterator
-from freestyle import BackboneStretcherShader, BezierCurveShader, BinaryPredicate1D, ChainPredicateIterator, \
-    ChainSilhouetteIterator, ConstantColorShader, ContourUP1D, Curvature2DAngleF0D, ExternalContourUP1D, \
-    FalseBP1D, FalseUP1D, GuidingLinesShader, Interface0DIterator, Nature, Noise, Normal2DF0D, Operators, \
-    PolygonalizationShader, QuantitativeInvisibilityF1D, QuantitativeInvisibilityUP1D, SamplingShader, \
-    SpatialNoiseShader, StrokeAttribute, StrokeShader, TipRemoverShader, TrueBP1D, TrueUP1D, UnaryPredicate0D, \
-    UnaryPredicate1D, VertexOrientation2DF0D, WithinImageBoundaryUP1D, ContextFunctions, TVertex
-from Functions0D import CurveMaterialF0D
-from PredicatesU1D import pyNatureUP1D
-from logical_operators import AndUP1D, NotUP1D, OrUP1D
-from shaders import pyBluePrintCirclesShader, pyBluePrintEllipsesShader, pyBluePrintSquaresShader
-
-
-class ColorRampModifier(StrokeShader):
-    def __init__(self, blend, influence, ramp):
-        StrokeShader.__init__(self)
-        self.__blend = blend
-        self.__influence = influence
-        self.__ramp = ramp
-
-    def evaluate(self, t):
-        col = freestyle.evaluateColorRamp(self.__ramp, t)
-        col = col.xyz  # omit alpha
-        return col
-
-    def blend_ramp(self, a, b):
-        return freestyle.blendRamp(self.__blend, a, self.__influence, b)
-
-
-class ScalarBlendModifier(StrokeShader):
-    def __init__(self, blend, influence):
-        StrokeShader.__init__(self)
-        self.__blend = blend
-        self.__influence = influence
-
-    def blend(self, v1, v2):
-        fac = self.__influence
-        facm = 1.0 - fac
-        if self.__blend == 'MIX':
-            v1 = facm * v1 + fac * v2
-        elif self.__blend == 'ADD':
-            v1 += fac * v2
-        elif self.__blend == 'MULTIPLY':
-            v1 *= facm + fac * v2
-        elif self.__blend == 'SUBTRACT':
-            v1 -= fac * v2
-        elif self.__blend == 'DIVIDE':
-            if v2 != 0.0:
-                v1 = facm * v1 + fac * v1 / v2
-        elif self.__blend == 'DIFFERENCE':
-            v1 = facm * v1 + fac * abs(v1 - v2)
-        elif self.__blend == 'MININUM':
-            tmp = fac * v2
-            if v1 > tmp:
-                v1 = tmp
-        elif self.__blend == 'MAXIMUM':
-            tmp = fac * v2
-            if v1 < tmp:
-                v1 = tmp
-        else:
-            raise ValueError("unknown curve blend type: " + self.__blend)
-        return v1
-
-
-class CurveMappingModifier(ScalarBlendModifier):
-    def __init__(self, blend, influence, mapping, invert, curve):
-        ScalarBlendModifier.__init__(self, blend, influence)
-        assert mapping in {'LINEAR', 'CURVE'}
-        self.__mapping = getattr(self, mapping)
-        self.__invert = invert
-        self.__curve = curve
-
-    def LINEAR(self, t):
-        if self.__invert:
-            return 1.0 - t
-        return t
-
-    def CURVE(self, t):
-        return freestyle.evaluateCurveMappingF(self.__curve, 0, t)
-
-    def evaluate(self, t):
-        return self.__mapping(t)
-
-
-class ThicknessModifierMixIn:
-    def __init__(self):
-        scene = freestyle.getCurrentScene()
-        self.__persp_camera = (scene.camera.data.type == 'PERSP')
-
-    def set_thickness(self, sv, outer, inner):
-        fe = sv.first_svertex.get_fedge(sv.second_svertex)
-        nature = fe.nature
-        if (nature & Nature.BORDER):
-            if self.__persp_camera:
-                point = -sv.point_3d.copy()
-                point.normalize()
-                dir = point.dot(fe.normal_left)
-            else:
-                dir = fe.normal_left.z
-            if dir < 0.0:  # the back side is visible
-                outer, inner = inner, outer
-        elif (nature & Nature.SILHOUETTE):
-            if fe.is_smooth:  # TODO more tests needed
-                outer, inner = inner, outer
-        else:
-            outer = inner = (outer + inner) / 2
-        sv.attribute.thickness = (outer, inner)
-
-
-class ThicknessBlenderMixIn(ThicknessModifierMixIn):
-    def __init__(self, position, ratio):
-        ThicknessModifierMixIn.__init__(self)
-        self.__position = position
-        self.__ratio = ratio
-
-    def blend_thickness(self, outer, inner, v):
-        v = self.blend(outer + inner, v)
-        if self.__position == 'CENTER':
-            outer = v * 0.5
-            inner = v - outer
-        elif self.__position == 'INSIDE':
-            outer = 0
-            inner = v
-        elif self.__position == 'OUTSIDE':
-            outer = v
-            inner = 0
-        elif self.__position == 'RELATIVE':
-            outer = v * self.__ratio
-            inner = v - outer
-        else:
-            raise ValueError("unknown thickness position: " + self.__position)
-        return outer, inner
-
-
-class BaseColorShader(ConstantColorShader):
-    pass
-
-
-class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
-    def __init__(self, thickness, position, ratio):
-        StrokeShader.__init__(self)
-        ThicknessModifierMixIn.__init__(self)
-        if position == 'CENTER':
-            self.__outer = thickness * 0.5
-            self.__inner = thickness - self.__outer
-        elif position == 'INSIDE':
-            self.__outer = 0
-            self.__inner = thickness
-        elif position == 'OUTSIDE':
-            self.__outer = thickness
-            self.__inner = 0
-        elif position == 'RELATIVE':
-            self.__outer = thickness * ratio
-            self.__inner = thickness - self.__outer
-        else:
-            raise ValueError("unknown thickness position: " + self.position)
-
-    def shade(self, stroke):
-        it = stroke.stroke_vertices_begin()
-        while not it.is_end:
-            sv = it.object
-            self.set_thickness(sv, self.__outer, self.__inner)
-            it.increment()
-
-
-# Along Stroke modifiers
-
-def iter_t2d_along_stroke(stroke):
-    total = stroke.length_2d
-    distance = 0.0
-    it = stroke.stroke_vertices_begin()
-    prev = it.object.point
-    while not it.is_end:
-        p = it.object.point
-        distance += (prev - p).length
-        prev = p.copy()  # need a copy because the point can be altered
-        t = min(distance / total, 1.0) if total > 0.0 else 0.0
-        yield it, t
-        it.increment()
-
-
-class ColorAlongStrokeShader(ColorRampModifier):
-    def shade(self, stroke):
-        for it, t in iter_t2d_along_stroke(stroke):
-            sv = it.object
-            a = sv.attribute.color
-            b = self.evaluate(t)
-            sv.attribute.color = self.blend_ramp(a, b)
-
-
-class AlphaAlongStrokeShader(CurveMappingModifier):
-    def shade(self, stroke):
-        for it, t in iter_t2d_along_stroke(stroke):
-            sv = it.object
-            a = sv.attribute.alpha
-            b = self.evaluate(t)
-            sv.attribute.alpha = self.blend(a, b)
-
-
-class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
-    def __init__(self, thickness_position, thickness_ratio,
-                 blend, influence, mapping, invert, curve, value_min, value_max):
-        ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
-        CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__value_min = value_min
-        self.__value_max = value_max
-
-    def shade(self, stroke):
-        for it, t in iter_t2d_along_stroke(stroke):
-            sv = it.object
-            a = sv.attribute.thickness
-            b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
-            c = self.blend_thickness(a[0], a[1], b)
-            self.set_thickness(sv, c[0], c[1])
-
-
-# Distance from Camera modifiers
-
-def iter_distance_from_camera(stroke, range_min, range_max):
-    normfac = range_max - range_min  # normalization factor
-    it = stroke.stroke_vertices_begin()
-    while not it.is_end:
-        p = it.object.point_3d  # in the camera coordinate
-        distance = p.length
-        if distance < range_min:
-            t = 0.0
-        elif distance > range_max:
-            t = 1.0
-        else:
-            t = (distance - range_min) / normfac
-        yield it, t
-        it.increment()
-
-
-class ColorDistanceFromCameraShader(ColorRampModifier):
-    def __init__(self, blend, influence, ramp, range_min, range_max):
-        ColorRampModifier.__init__(self, blend, influence, ramp)
-        self.__range_min = range_min
-        self.__range_max = range_max
-
-    def shade(self, stroke):
-        for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
-            sv = it.object
-            a = sv.attribute.color
-            b = self.evaluate(t)
-            sv.attribute.color = self.blend_ramp(a, b)
-
-
-class AlphaDistanceFromCameraShader(CurveMappingModifier):
-    def __init__(self, blend, influence, mapping, invert, curve, range_min, range_max):
-        CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__range_min = range_min
-        self.__range_max = range_max
-
-    def shade(self, stroke):
-        for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
-            sv = it.object
-            a = sv.attribute.alpha
-            b = self.evaluate(t)
-            sv.attribute.alpha = self.blend(a, b)
-
-
-class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModifier):
-    def __init__(self, thickness_position, thickness_ratio,
-                 blend, influence, mapping, invert, curve, range_min, range_max, value_min, value_max):
-        ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
-        CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__range_min = range_min
-        self.__range_max = range_max
-        self.__value_min = value_min
-        self.__value_max = value_max
-
-    def shade(self, stroke):
-        for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
-            sv = it.object
-            a = sv.attribute.thickness
-            b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
-            c = self.blend_thickness(a[0], a[1], b)
-            self.set_thickness(sv, c[0], c[1])
-
-
-# Distance from Object modifiers
-
-def iter_distance_from_object(stroke, object, range_min, range_max):
-    scene = freestyle.getCurrentScene()
-    mv = scene.camera.matrix_world.copy()  # model-view matrix
-    mv.invert()
-    loc = mv * object.location  # loc in the camera coordinate
-    normfac = range_max - range_min  # normalization factor
-    it = stroke.stroke_vertices_begin()
-    while not it.is_end:
-        p = it.object.point_3d  # in the camera coordinate
-        distance = (p - loc).length
-        if distance < range_min:
-            t = 0.0
-        elif distance > range_max:
-            t = 1.0
-        else:
-            t = (distance - range_min) / normfac
-        yield it, t
-        it.increment()
-
-
-class ColorDistanceFromObjectShader(ColorRampModifier):
-    def __init__(self, blend, influence, ramp, target, range_min, range_max):
-        ColorRampModifier.__init__(self, blend, influence, ramp)
-        self.__target = target
-        self.__range_min = range_min
-        self.__range_max = range_max
-
-    def shade(self, stroke):
-        if self.__target is None:
-            return
-        for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max):
-            sv = it.object
-            a = sv.attribute.color
-            b = self.evaluate(t)
-            sv.attribute.color = self.blend_ramp(a, b)
-
-
-class AlphaDistanceFromObjectShader(CurveMappingModifier):
-    def __init__(self, blend, influence, mapping, invert, curve, target, range_min, range_max):
-        CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__target = target
-        self.__range_min = range_min
-        self.__range_max = range_max
-
-    def shade(self, stroke):
-        if self.__target is None:
-            return
-        for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max):
-            sv = it.object
-            a = sv.attribute.alpha
-            b = self.evaluate(t)
-            sv.attribute.alpha = self.blend(a, b)
-
-
-class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModifier):
-    def __init__(self, thickness_position, thickness_ratio,
-                 blend, influence, mapping, invert, curve, target, range_min, range_max, value_min, value_max):
-        ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
-        CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__target = target
-        self.__range_min = range_min
-        self.__range_max = range_max
-        self.__value_min = value_min
-        self.__value_max = value_max
-
-    def shade(self, stroke):
-        if self.__target is None:
-            return
-        for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max):
-            sv = it.object
-            a = sv.attribute.thickness
-            b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
-            c = self.blend_thickness(a[0], a[1], b)
-            self.set_thickness(sv, c[0], c[1])
-
-
-# Material modifiers
-
-def iter_material_color(stroke, material_attribute):
-    func = CurveMaterialF0D()
-    it = stroke.stroke_vertices_begin()
-    while not it.is_end:
-        material = func(Interface0DIterator(it))
-        if material_attribute == 'DIFF':
-            color = material.diffuse[0:3]
-        elif material_attribute == 'SPEC':
-            color = material.specular[0:3]
-        else:
-            raise ValueError("unexpected material attribute: " + material_attribute)
-        yield it, color
-        it.increment()
-
-
-def iter_material_value(stroke, material_attribute):
-    func = CurveMaterialF0D()
-    it = stroke.stroke_vertices_begin()
-    while not it.is_end:
-        material = func(Interface0DIterator(it))
-        if material_attribute == 'DIFF':
-            r, g, b = material.diffuse[0:3]
-            t = 0.35 * r + 0.45 * r + 0.2 * b
-        elif material_attribute == 'DIFF_R':
-            t = material.diffuse[0]
-        elif material_attribute == 'DIFF_G':
-            t = material.diffuse[1]
-        elif material_attribute == 'DIFF_B':
-            t = material.diffuse[2]
-        elif material_attribute == 'SPEC':
-            r, g, b = material.specular[0:3]
-            t = 0.35 * r + 0.45 * r + 0.2 * b
-        elif material_attribute == 'SPEC_R':
-            t = material.specular[0]
-        elif material_attribute == 'SPEC_G':
-            t = material.specular[1]
-        elif material_attribute == 'SPEC_B':
-            t = material.specular[2]
-        elif material_attribute == 'SPEC_HARDNESS':
-            t = material.shininess
-        elif material_attribute == 'ALPHA':
-            t = material.diffuse[3]
-        else:
-            raise ValueError("unexpected material attribute: " + material_attribute)
-        yield it, t
-        it.increment()
-
-
-class ColorMaterialShader(ColorRampModifier):
-    def __init__(self, blend, influence, ramp, material_attribute, use_ramp):
-        ColorRampModifier.__init__(self, blend, influence, ramp)
-        self.__material_attribute = material_attribute
-        self.__use_ramp = use_ramp
-
-    def shade(self, stroke):
-        if self.__material_attribute in {'DIFF', 'SPEC'} and not self.__use_ramp:
-            for it, b in iter_material_color(stroke, self.__material_attribute):
-                sv = it.object
-                a = sv.attribute.color
-                sv.attribute.color = self.blend_ramp(a, b)
-        else:
-            for it, t in iter_material_value(stroke, self.__material_attribute):
-                sv = it.object
-                a = sv.attribute.color
-                b = self.evaluate(t)
-                sv.attribute.color = self.blend_ramp(a, b)
-
-
-class AlphaMaterialShader(CurveMappingModifier):
-    def __init__(self, blend, influence, mapping, invert, curve, material_attribute):
-        CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__material_attribute = material_attribute
-
-    def shade(self, stroke):
-        for it, t in iter_material_value(stroke, self.__material_attribute):
-            sv = it.object
-            a = sv.attribute.alpha
-            b = self.evaluate(t)
-            sv.attribute.alpha = self.blend(a, b)
-
-
-class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
-    def __init__(self, thickness_position, thickness_ratio,
-                 blend, influence, mapping, invert, curve, material_attribute, value_min, value_max):
-        ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
-        CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__material_attribute = material_attribute
-        self.__value_min = value_min
-        self.__value_max = value_max
-
-    def shade(self, stroke):
-        for it, t in iter_material_value(stroke, self.__material_attribute):
-            sv = it.object
-            a = sv.attribute.thickness
-            b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
-            c = self.blend_thickness(a[0], a[1], b)
-            self.set_thickness(sv, c[0], c[1])
-
-
-# Calligraphic thickness modifier
-
-class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
-    def __init__(self, thickness_position, thickness_ratio,
-                 blend, influence, orientation, thickness_min, thickness_max):
-        ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
-        ScalarBlendModifier.__init__(self, blend, influence)
-        self.__orientation = mathutils.Vector((math.cos(orientation), math.sin(orientation)))
-        self.__thickness_min = thickness_min
-        self.__thickness_max = thickness_max
-
-    def shade(self, stroke):
-        func = VertexOrientation2DF0D()
-        it = stroke.stroke_vertices_begin()
-        while not it.is_end:
-            dir = func(Interface0DIterator(it))
-            orthDir = mathutils.Vector((-dir.y, dir.x))
-            orthDir.normalize()
-            fac = abs(orthDir * self.__orientation)
-            sv = it.object
-            a = sv.attribute.thickness
-            b = self.__thickness_min + fac * (self.__thickness_max - self.__thickness_min)
-            b = max(b, 0.0)
-            c = self.blend_thickness(a[0], a[1], b)
-            self.set_thickness(sv, c[0], c[1])
-            it.increment()
-
-
-# Geometry modifiers
-
-def iter_distance_along_stroke(stroke):
-    distance = 0.0
-    it = stroke.stroke_vertices_begin()
-    prev = it.object.point
-    while not it.is_end:
-        p = it.object.point
-        distance += (prev - p).length
-        prev = p.copy()  # need a copy because the point can be altered
-        yield it, distance
-        it.increment()
-
-
-class SinusDisplacementShader(StrokeShader):
-    def __init__(self, wavelength, amplitude, phase):
-        StrokeShader.__init__(self)
-        self._wavelength = wavelength
-        self._amplitude = amplitude
-        self._phase = phase / wavelength * 2 * math.pi
-        self._getNormal = Normal2DF0D()
-
-    def shade(self, stroke):
-        for it, distance in iter_distance_along_stroke(stroke):
-            v = it.object
-            n = self._getNormal(Interface0DIterator(it))
-            n = n * self._amplitude * math.cos(distance / self._wavelength * 2 * math.pi + self._phase)
-            v.point = v.point + n
-        stroke.update_length()
-
-
-class PerlinNoise1DShader(StrokeShader):
-    def __init__(self, freq=10, amp=10, oct=4, angle=math.radians(45), seed=-1):
-        StrokeShader.__init__(self)
-        self.__noise = Noise(seed)
-        self.__freq = freq
-        self.__amp = amp
-        self.__oct = oct
-        self.__dir = mathutils.Vector((math.cos(angle), math.sin(angle)))
-
-    def shade(self, stroke):
-        length = stroke.length_2d
-        it = stroke.stroke_vertices_begin()
-        while not it.is_end:
-            v = it.object
-            nres = self.__noise.turbulence1(length * v.u, self.__freq, self.__amp, self.__oct)
-            v.point = v.point + nres * self.__dir
-            it.increment()
-        stroke.update_length()
-
-
-class PerlinNoise2DShader(StrokeShader):
-    def __init__(self, freq=10, amp=10, oct=4, angle=math.radians(45), seed=-1):
-        StrokeShader.__init__(self)
-        self.__noise = Noise(seed)
-        self.__freq = freq
-        self.__amp = amp
-        self.__oct = oct
-        self.__dir = mathutils.Vector((math.cos(angle), math.sin(angle)))
-
-    def shade(self, stroke):
-        it = stroke.stroke_vertices_begin()
-        while not it.is_end:
-            v = it.object
-            vec = mathutils.Vector((v.projected_x, v.projected_y))
-            nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
-            v.point = v.point + nres * self.__dir
-            it.increment()
-        stroke.update_length()
-
-
-class Offset2DShader(StrokeShader):
-    def __init__(self, start, end, x, y):
-        StrokeShader.__init__(self)
-        self.__start = start
-        self.__end = end
-        self.__xy = mathutils.Vector((x, y))
-        self.__getNormal = Normal2DF0D()
-
-    def shade(self, stroke):
-        it = stroke.stroke_vertices_begin()
-        while not it.is_end:
-            v = it.object
-            u = v.u
-            a = self.__start + u * (self.__end - self.__start)
-            n = self.__getNormal(Interface0DIterator(it))
-            n = n * a
-            v.point = v.point + n + self.__xy
-            it.increment()
-        stroke.update_length()
-
-
-class Transform2DShader(StrokeShader):
-    def __init__(self, pivot, scale_x, scale_y, angle, pivot_u, pivot_x, pivot_y):
-        StrokeShader.__init__(self)
-        self.__pivot = pivot
-        self.__scale_x = scale_x
-        self.__scale_y = scale_y
-        self.__angle = angle
-        self.__pivot_u = pivot_u
-        self.__pivot_x = pivot_x
-        self.__pivot_y = pivot_y
-
-    def shade(self, stroke):
-        # determine the pivot of scaling and rotation operations
-        if self.__pivot == 'START':
-            it = stroke.stroke_vertices_begin()
-            pivot = it.object.point
-        elif self.__pivot == 'END':
-            it = stroke.stroke_vertices_end()
-            it.decrement()
-            pivot = it.object.point
-        elif self.__pivot == 'PARAM':
-            p = None
-            it = stroke.stroke_vertices_begin()
-            while not it.is_end:
-                prev = p
-                v = it.object
-                p = v.point
-                u = v.u
-                if self.__pivot_u < u:
-                    break
-                it.increment()
-            if prev is None:
-                pivot = p
-            else:
-                delta = u - self.__pivot_u
-                pivot = p + delta * (prev - p)
-        elif self.__pivot == 'CENTER':
-            pivot = mathutils.Vector((0.0, 0.0))
-            n = 0
-            it = stroke.stroke_vertices_begin()
-            while not it.is_end:
-                p = it.object.point
-                pivot = pivot + p
-                n += 1
-                it.increment()
-            pivot.x = pivot.x / n
-            pivot.y = pivot.y / n
-        elif self.__pivot == 'ABSOLUTE':
-            pivot = mathutils.Vector((self.__pivot_x, self.__pivot_y))
-        # apply scaling and rotation operations
-        cos_theta = math.cos(self.__angle)
-        sin_theta = math.sin(self.__angle)
-        it = stroke.stroke_vertices_begin()
-        while not it.is_end:
-            v = it.object
-            p = v.point
-            p = p - pivot
-            x = p.x * self.__scale_x
-            y = p.y * self.__scale_y
-            p.x = x * cos_theta - y * sin_theta
-            p.y = x * sin_theta + y * cos_theta
-            v.point = p + pivot
-            it.increment()
-        stroke.update_length()
-
-
-# Predicates and helper functions
-
-class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D):
-    def __init__(self, qi_start, qi_end):
-        UnaryPredicate1D.__init__(self)
-        self.__getQI = QuantitativeInvisibilityF1D()
-        self.__qi_start = qi_start
-        self.__qi_end = qi_end
-
-    def __call__(self, inter):
-        qi = self.__getQI(inter)
-        return self.__qi_start <= qi <= self.__qi_end
-
-
-def join_unary_predicates(upred_list, bpred):
-    if not upred_list:
-        return None
-    upred = upred_list[0]
-    for p in upred_list[1:]:
-        upred = bpred(upred, p)
-    return upred
-
-
-class ObjectNamesUP1D(UnaryPredicate1D):
-    def __init__(self, names, negative):
-        UnaryPredicate1D.__init__(self)
-        self._names = names
-        self._negative = negative
-
-    def __call__(self, viewEdge):
-        found = viewEdge.viewshape.name in self._names
-        if self._negative:
-            return not found
-        return found
-
-
-# Stroke caps
-
-def iter_stroke_vertices(stroke):
-    it = stroke.stroke_vertices_begin()
-    prev_p = None
-    while not it.is_end:
-        sv = it.object
-        p = sv.point
-        if prev_p is None or (prev_p - p).length > 1e-6:
-            yield sv
-            prev_p = p.copy()
-        it.increment()
-
-
-class RoundCapShader(StrokeShader):
-    def round_cap_thickness(self, x):
-        x = max(0.0, min(x, 1.0))
-        return math.sqrt(1.0 - (x ** 2.0))
-
-    def shade(self, stroke):
-        # save the location and attribute of stroke vertices
-        buffer = []
-        for sv in iter_stroke_vertices(stroke):
-            buffer.append((mathutils.Vector(sv.point), StrokeAttribute(sv.attribute)))
-        nverts = len(buffer)
-        if nverts < 2:
-            return
-        # calculate the number of additional vertices to form caps
-        R, L = stroke[0].attribute.thickness
-        caplen_beg = (R + L) / 2.0
-        nverts_beg = max(5, int(R + L))
-        R, L = stroke[-1].attribute.thickness
-        caplen_end = (R + L) / 2.0
-        nverts_end = max(5, int(R + L))
-        # adjust the total number of stroke vertices
-        stroke.resample(nverts + nverts_beg + nverts_end)
-        # restore the location and attribute of the original vertices
-        for i in range(nverts):
-            p, attr = buffer[i]
-            stroke[nverts_beg + i].point = p
-            stroke[nverts_beg + i].attribute = attr
-        # reshape the cap at the beginning of the stroke
-        q, attr = buffer[1]
-        p, attr = buffer[0]
-        d = p - q
-        d = d / d.length * caplen_beg
-        n = 1.0 / nverts_beg
-        R, L = attr.thickness
-        for i in range(nverts_beg):
-            t = (nverts_beg - i) * n
-            stroke[i].point = p + d * t
-            r = self.round_cap_thickness((nverts_beg - i + 1) * n)
-            stroke[i].attribute = attr
-            stroke[i].attribute.thickness = (R * r, L * r)
-        # reshape the cap at the end of the stroke
-        q, attr = buffer[-2]
-        p, attr = buffer[-1]
-        d = p - q
-        d = d / d.length * caplen_end
-        n = 1.0 / nverts_end
-        R, L = attr.thickness
-        for i in range(nverts_end):
-            t = (nverts_end - i) * n
-            stroke[-i - 1].point = p + d * t
-            r = self.round_cap_thickness((nverts_end - i + 1) * n)
-            stroke[-i - 1].attribute = attr
-            stroke[-i - 1].attribute.thickness = (R * r, L * r)
-        # update the curvilinear 2D length of each vertex
-        stroke.update_length()
-
-
-class SquareCapShader(StrokeShader):
-    def shade(self, stroke):
-        # save the location and attribute of stroke vertices
-        buffer = []
-        for sv in iter_stroke_vertices(stroke):
-            buffer.append((mathutils.Vector(sv.point), StrokeAttribute(sv.attribute)))
-        nverts = len(buffer)
-        if nverts < 2:
-            return
-        # calculate the number of additional vertices to form caps
-        R, L = stroke[0].attribute.thickness
-        caplen_beg = (R + L) / 2.0
-        nverts_beg = 1
-        R, L = stroke[-1].attribute.thickness
-        caplen_end = (R + L) / 2.0
-        nverts_end = 1
-        # adjust the total number of stroke vertices
-        stroke.resample(nverts + nverts_beg + nverts_end)
-        # restore the location and attribute of the original vertices
-        for i in range(nverts):
-            p, attr = buffer[i]
-            stroke[nverts_beg + i].point = p
-            stroke[nverts_beg + i].attribute = attr
-        # reshape the cap at the beginning of the stroke
-        q, attr = buffer[1]
-        p, attr = buffer[0]
-        d = p - q
-        stroke[0].point = p + d / d.length * caplen_beg
-        stroke[0].attribute = attr
-        # reshape the cap at the end of the stroke
-        q, attr = buffer[-2]
-        p, attr = buffer[-1]
-        d = p - q
-        stroke[-1].point = p + d / d.length * caplen_beg
-        stroke[-1].attribute = attr
-        # update the curvilinear 2D length of each vertex
-        stroke.update_length()
-
-
-# Split by dashed line pattern
-
-class SplitPatternStartingUP0D(UnaryPredicate0D):
-    def __init__(self, controller):
-        UnaryPredicate0D.__init__(self)
-        self._controller = controller
-
-    def __call__(self, inter):
-        return self._controller.start()
-
-
-class SplitPatternStoppingUP0D(UnaryPredicate0D):
-    def __init__(self, controller):
-        UnaryPredicate0D.__init__(self)
-        self._controller = controller
-
-    def __call__(self, inter):
-        return self._controller.stop()
-
-
-class SplitPatternController:
-    def __init__(self, pattern, sampling):
-        self.sampling = float(sampling)
-        k = len(pattern) // 2
-        n = k * 2
-        self.start_pos = [pattern[i] + pattern[i + 1] for i in range(0, n, 2)]
-        self.stop_pos = [pattern[i] for i in range(0, n, 2)]
-        self.init()
-
-    def init(self):
-        self.start_len = 0.0
-        self.start_idx = 0
-        self.stop_len = self.sampling
-        self.stop_idx = 0
-
-    def start(self):
-        self.start_len += self.sampling
-        if abs(self.start_len - self.start_pos[self.start_idx]) < self.sampling / 2.0:
-            self.start_len = 0.0
-            self.start_idx = (self.start_idx + 1) % len(self.start_pos)
-            return True
-        return False
-
-    def stop(self):
-        if self.start_len > 0.0:
-            self.init()
-        self.stop_len += self.sampling
-        if abs(self.stop_len - self.stop_pos[self.stop_idx]) < self.sampling / 2.0:
-            self.stop_len = self.sampling
-            self.stop_idx = (self.stop_idx + 1) % len(self.stop_pos)
-            return True
-        return False
-
-
-# Dashed line
-
-class DashedLineShader(StrokeShader):
-    def __init__(self, pattern):
-        StrokeShader.__init__(self)
-        self._pattern = pattern
-
-    def shade(self, stroke):
-        index = 0  # pattern index
-        start = 0.0  # 2D curvilinear length
-        visible = True
-        sampling = 1.0
-        it = stroke.stroke_vertices_begin(sampling)
-        while not it.is_end:
-            pos = it.t  # curvilinear abscissa
-            # The extra 'sampling' term is added below, because the
-            # visibility attribute of the i-th vertex refers to the
-            # visibility of the stroke segment between the i-th and
-            # (i+1)-th vertices.
-            if pos - start + sampling > self._pattern[index]:
-                start = pos
-                index += 1
-                if index == len(self._pattern):
-                    index = 0
-                visible = not visible
-            it.object.attribute.visible = visible
-            it.increment()
-
-
-# predicates for chaining
-
-class AngleLargerThanBP1D(BinaryPredicate1D):
-    def __init__(self, angle):
-        BinaryPredicate1D.__init__(self)
-        self._angle = angle
-
-    def __call__(self, i1, i2):
-        sv1a = i1.first_fedge.first_svertex.point_2d
-        sv1b = i1.last_fedge.second_svertex.point_2d
-        sv2a = i2.first_fedge.first_svertex.point_2d
-        sv2b = i2.last_fedge.second_svertex.point_2d
-        if (sv1a - sv2a).length < 1e-6:
-            dir1 = sv1a - sv1b
-            dir2 = sv2b - sv2a
-        elif (sv1b - sv2b).length < 1e-6:
-            dir1 = sv1b - sv1a
-            dir2 = sv2a - sv2b
-        elif (sv1a - sv2b).length < 1e-6:
-            dir1 = sv1a - sv1b
-            dir2 = sv2a - sv2b
-        elif (sv1b - sv2a).length < 1e-6:
-            dir1 = sv1b - sv1a
-            dir2 = sv2b - sv2a
-        else:
-            return False
-        denom = dir1.length * dir2.length
-        if denom < 1e-6:
-            return False
-        x = (dir1 * dir2) / denom
-        return math.acos(min(max(x, -1.0), 1.0)) > self._angle
-
-
-class AndBP1D(BinaryPredicate1D):
-    def __init__(self, pred1, pred2):
-        BinaryPredicate1D.__init__(self)
-        self.__pred1 = pred1
-        self.__pred2 = pred2
-
-    def __call__(self, i1, i2):
-        return self.__pred1(i1, i2) and self.__pred2(i1, i2)
-
-
-# predicates for selection
-
-class LengthThresholdUP1D(UnaryPredicate1D):
-    def __init__(self, length_min=None, length_max=None):
-        UnaryPredicate1D.__init__(self)
-        self._length_min = length_min
-        self._length_max = length_max
-
-    def __call__(self, inter):
-        length = inter.length_2d
-        if self._length_min is not None and length < self._length_min:
-            return False
-        if self._length_max is not None and length > self._length_max:
-            return False
-        return True
-
-
-class FaceMarkBothUP1D(UnaryPredicate1D):
-    def __call__(self, inter):  # ViewEdge
-        fe = inter.first_fedge
-        while fe is not None:
-            if fe.is_smooth:
-                if fe.face_mark:
-                    return True
-            elif (fe.nature & Nature.BORDER):
-                if fe.face_mark_left:
-                    return True
-            else:
-                if fe.face_mark_right and fe.face_mark_left:
-                    return True
-            fe = fe.next_fedge
-        return False
-
-
-class FaceMarkOneUP1D(UnaryPredicate1D):
-    def __call__(self, inter):  # ViewEdge
-        fe = inter.first_fedge
-        while fe is not None:
-            if fe.is_smooth:
-                if fe.face_mark:
-                    return True
-            elif (fe.nature & Nature.BORDER):
-                if fe.face_mark_left:
-                    return True
-            else:
-                if fe.face_mark_right or fe.face_mark_left:
-                    return True
-            fe = fe.next_fedge
-        return False
-
-
-# predicates for splitting
-
-class MaterialBoundaryUP0D(UnaryPredicate0D):
-    def __call__(self, it):
-        if it.is_begin:
-            return False
-        it_prev = Interface0DIterator(it)
-        it_prev.decrement()
-        v = it.object
-        it.increment()
-        if it.is_end:
-            return False
-        fe = v.get_fedge(it_prev.object)
-        idx1 = fe.material_index if fe.is_smooth else fe.material_index_left
-        fe = v.get_fedge(it.object)
-        idx2 = fe.material_index if fe.is_smooth else fe.material_index_left
-        return idx1 != idx2
-
-
-class Curvature2DAngleThresholdUP0D(UnaryPredicate0D):
-    def __init__(self, angle_min=None, angle_max=None):
-        UnaryPredicate0D.__init__(self)
-        self._angle_min = angle_min
-        self._angle_max = angle_max
-        self._func = Curvature2DAngleF0D()
-
-    def __call__(self, inter):
-        angle = math.pi - self._func(inter)
-        if self._angle_min is not None and angle < self._angle_min:
-            return True
-        if self._angle_max is not None and angle > self._angle_max:
-            return True
-        return False
-
-
-class Length2DThresholdUP0D(UnaryPredicate0D):
-    def __init__(self, length_limit):
-        UnaryPredicate0D.__init__(self)
-        self._length_limit = length_limit
-        self._t = 0.0
-
-    def __call__(self, inter):
-        t = inter.t  # curvilinear abscissa
-        if t < self._t:
-            self._t = 0.0
-            return False
-        if t - self._t < self._length_limit:
-            return False
-        self._t = t
-        return True
-
-
-# Seed for random number generation
-
-class Seed:
-    def __init__(self):
-        self.t_max = 2 ** 15
-        self.t = int(time.time()) % self.t_max
-
-    def get(self, seed):
-        if seed < 0:
-            self.t = (self.t + 1) % self.t_max
-            return self.t
-        return seed
-
-_seed = Seed()
-
-
-### T.K. 07-Aug-2013 Temporary fix for unexpected line gaps
-
-def iter_three_segments(stroke):
-    n = stroke.stroke_vertices_size()
-    if n >= 4:
-        it1 = stroke.stroke_vertices_begin()
-        it2 = stroke.stroke_vertices_begin()
-        it2.increment()
-        it3 = stroke.stroke_vertices_begin()
-        it3.increment()
-        it3.increment()
-        it4 = stroke.stroke_vertices_begin()
-        it4.increment()
-        it4.increment()
-        it4.increment()
-        while not it4.is_end:
-            yield (it1.object, it2.object, it3.object, it4.object)
-            it1.increment()
-            it2.increment()
-            it3.increment()
-            it4.increment()
-
-def is_tvertex(svertex):
-    return type(svertex.viewvertex) is TVertex
-
-class StrokeCleaner(StrokeShader):
-    def shade(self, stroke):
-        for sv1, sv2, sv3, sv4 in iter_three_segments(stroke):
-            seg1 = sv2.point - sv1.point
-            seg2 = sv3.point - sv2.point
-            seg3 = sv4.point - sv3.point
-            if not ((is_tvertex(sv2.first_svertex) and is_tvertex(sv2.second_svertex)) or
-                    (is_tvertex(sv3.first_svertex) and is_tvertex(sv3.second_svertex))):
-                continue
-            if seg1.dot(seg2) < 0.0 and seg2.dot(seg3) < 0.0 and seg2.length < 0.01:
-                #print(sv2.first_svertex.viewvertex)
-                #print(sv2.second_svertex.viewvertex)
-                #print(sv3.first_svertex.viewvertex)
-                #print(sv3.second_svertex.viewvertex)
-                p2 = mathutils.Vector(sv2.point)
-                p3 = mathutils.Vector(sv3.point)
-                sv2.point = p3
-                sv3.point = p2
-        stroke.update_length()
-
-
-# main function for parameter processing
-
-def process(layer_name, lineset_name):
-    scene = freestyle.getCurrentScene()
-    layer = scene.render.layers[layer_name]
-    lineset = layer.freestyle_settings.linesets[lineset_name]
-    linestyle = lineset.linestyle
-
-    selection_criteria = []
-    # prepare selection criteria by visibility
-    if lineset.select_by_visibility:
-        if lineset.visibility == 'VISIBLE':
-            selection_criteria.append(
-                QuantitativeInvisibilityUP1D(0))
-        elif lineset.visibility == 'HIDDEN':
-            selection_criteria.append(
-                NotUP1D(QuantitativeInvisibilityUP1D(0)))
-        elif lineset.visibility == 'RANGE':
-            selection_criteria.append(
-                QuantitativeInvisibilityRangeUP1D(lineset.qi_start, lineset.qi_end))
-    # prepare selection criteria by edge types
-    if lineset.select_by_edge_types:
-        edge_type_criteria = []
-        if lineset.select_silhouette:
-            upred = pyNatureUP1D(Nature.SILHOUETTE)
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_silhouette else upred)
-        if lineset.select_border:
-            upred = pyNatureUP1D(Nature.BORDER)
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_border else upred)
-        if lineset.select_crease:
-            upred = pyNatureUP1D(Nature.CREASE)
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_crease else upred)
-        if lineset.select_ridge_valley:
-            upred = pyNatureUP1D(Nature.RIDGE)
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_ridge_valley else upred)
-        if lineset.select_suggestive_contour:
-            upred = pyNatureUP1D(Nature.SUGGESTIVE_CONTOUR)
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_suggestive_contour else upred)
-        if lineset.select_material_boundary:
-            upred = pyNatureUP1D(Nature.MATERIAL_BOUNDARY)
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_material_boundary else upred)
-        if lineset.select_edge_mark:
-            upred = pyNatureUP1D(Nature.EDGE_MARK)
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_edge_mark else upred)
-        if lineset.select_contour:
-            upred = ContourUP1D()
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_contour else upred)
-        if lineset.select_external_contour:
-            upred = ExternalContourUP1D()
-            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_external_contour else upred)
-        if lineset.edge_type_combination == 'OR':
-            upred = join_unary_predicates(edge_type_criteria, OrUP1D)
-        else:
-            upred = join_unary_predicates(edge_type_criteria, AndUP1D)
-        if upred is not None:
-            if lineset.edge_type_negation == 'EXCLUSIVE':
-                upred = NotUP1D(upred)
-            selection_criteria.append(upred)
-    # prepare selection criteria by face marks
-    if lineset.select_by_face_marks:
-        if lineset.face_mark_condition == 'BOTH':
-            upred = FaceMarkBothUP1D()
-        else:
-            upred = FaceMarkOneUP1D()
-        if lineset.face_mark_negation == 'EXCLUSIVE':
-            upred = NotUP1D(upred)
-        selection_criteria.append(upred)
-    # prepare selection criteria by group of objects
-    if lineset.select_by_group:
-        if lineset.group is not None:
-            names = dict((ob.name, True) for ob in lineset.group.objects)
-            upred = ObjectNamesUP1D(names, lineset.group_negation == 'EXCLUSIVE')
-            selection_criteria.append(upred)
-    # prepare selection criteria by image border
-    if lineset.select_by_image_border:
-        xmin, ymin, xmax, ymax = ContextFunctions.get_border()
-        upred = WithinImageBoundaryUP1D(xmin, ymin, xmax, ymax)
-        selection_criteria.append(upred)
-    # select feature edges
-    upred = join_unary_predicates(selection_criteria, AndUP1D)
-    if upred is None:
-        upred = TrueUP1D()
-    Operators.select(upred)
-    # join feature edges to form chains
-    if linestyle.use_chaining:
-        if linestyle.chaining == 'PLAIN':
-            if linestyle.use_same_object:
-                Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-            else:
-                Operators.bidirectional_chain(ChainPredicateIterator(upred, TrueBP1D()), NotUP1D(upred))
-        elif linestyle.chaining == 'SKETCHY':
-            if linestyle.use_same_object:
-                Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(linestyle.rounds))
-            else:
-                Operators.bidirectional_chain(pySketchyChainingIterator(linestyle.rounds))
-    else:
-        Operators.chain(ChainPredicateIterator(FalseUP1D(), FalseBP1D()), NotUP1D(upred))
-    # split chains
-    if linestyle.material_boundary:
-        Operators.sequential_split(MaterialBoundaryUP0D())
-    if linestyle.use_angle_min or linestyle.use_angle_max:
-        angle_min = linestyle.angle_min if linestyle.use_angle_min else None
-        angle_max = linestyle.angle_max if linestyle.use_angle_max else None
-        Operators.sequential_split(Curvature2DAngleThresholdUP0D(angle_min, angle_max))
-    if linestyle.use_split_length:
-        Operators.sequential_split(Length2DThresholdUP0D(linestyle.split_length), 1.0)
-    if linestyle.use_split_pattern:
-        pattern = []
-        if linestyle.split_dash1 > 0 and linestyle.split_gap1 > 0:
-            pattern.append(linestyle.split_dash1)
-            pattern.append(linestyle.split_gap1)
-        if linestyle.split_dash2 > 0 and linestyle.split_gap2 > 0:
-            pattern.append(linestyle.split_dash2)
-            pattern.append(linestyle.split_gap2)
-        if linestyle.split_dash3 > 0 and linestyle.split_gap3 > 0:
-            pattern.append(linestyle.split_dash3)
-            pattern.append(linestyle.split_gap3)
-        if len(pattern) > 0:
-            sampling = 1.0
-            controller = SplitPatternController(pattern, sampling)
-            Operators.sequential_split(SplitPatternStartingUP0D(controller),
-                                       SplitPatternStoppingUP0D(controller),
-                                       sampling)
-    # select chains
-    if linestyle.use_length_min or linestyle.use_length_max:
-        length_min = linestyle.length_min if linestyle.use_length_min else None
-        length_max = linestyle.length_max if linestyle.use_length_max else None
-        Operators.select(LengthThresholdUP1D(length_min, length_max))
-    # prepare a list of stroke shaders
-    shaders_list = []
-    ###
-    shaders_list.append(StrokeCleaner())
-    ###
-    for m in linestyle.geometry_modifiers:
-        if not m.use:
-            continue
-        if m.type == 'SAMPLING':
-            shaders_list.append(SamplingShader(
-                m.sampling))
-        elif m.type == 'BEZIER_CURVE':
-            shaders_list.append(BezierCurveShader(
-                m.error))
-        elif m.type == 'SINUS_DISPLACEMENT':
-            shaders_list.append(SinusDisplacementShader(
-                m.wavelength, m.amplitude, m.phase))
-        elif m.type == 'SPATIAL_NOISE':
-            shaders_list.append(SpatialNoiseShader(
-                m.amplitude, m.scale, m.octaves, m.smooth, m.use_pure_random))
-        elif m.type == 'PERLIN_NOISE_1D':
-            shaders_list.append(PerlinNoise1DShader(
-                m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed)))
-        elif m.type == 'PERLIN_NOISE_2D':
-            shaders_list.append(PerlinNoise2DShader(
-                m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed)))
-        elif m.type == 'BACKBONE_STRETCHER':
-            shaders_list.append(BackboneStretcherShader(
-                m.backbone_length))
-        elif m.type == 'TIP_REMOVER':
-            shaders_list.append(TipRemoverShader(
-                m.tip_length))
-        elif m.type == 'POLYGONIZATION':
-            shaders_list.append(PolygonalizationShader(
-                m.error))
-        elif m.type == 'GUIDING_LINES':
-            shaders_list.append(GuidingLinesShader(
-                m.offset))
-        elif m.type == 'BLUEPRINT':
-            if m.shape == 'CIRCLES':
-                shaders_list.append(pyBluePrintCirclesShader(
-                    m.rounds, m.random_radius, m.random_center))
-            elif m.shape == 'ELLIPSES':
-                shaders_list.append(pyBluePrintEllipsesShader(
-                    m.rounds, m.random_radius, m.random_center))
-            elif m.shape == 'SQUARES':
-                shaders_list.append(pyBluePrintSquaresShader(
-                    m.rounds, m.backbone_length, m.random_backbone))
-        elif m.type == '2D_OFFSET':
-            shaders_list.append(Offset2DShader(
-                m.start, m.end, m.x, m.y))
-        elif m.type == '2D_TRANSFORM':
-            shaders_list.append(Transform2DShader(
-                m.pivot, m.scale_x, m.scale_y, m.angle, m.pivot_u, m.pivot_x, m.pivot_y))
-    color = linestyle.color
-    if (not linestyle.use_chaining) or (linestyle.chaining == 'PLAIN' and linestyle.use_same_object):
-        thickness_position = linestyle.thickness_position
-    else:
-        thickness_position = 'CENTER'
-        import bpy
-        if bpy.app.debug_freestyle:
-            print("Warning: Thickness position options are applied when chaining is disabled\n"
-                  "         or the Plain chaining is used with the Same Object option enabled.")
-    shaders_list.append(BaseColorShader(color.r, color.g, color.b, linestyle.alpha))
-    shaders_list.append(BaseThicknessShader(linestyle.thickness, thickness_position,
-                                            linestyle.thickness_ratio))
-    for m in linestyle.color_modifiers:
-        if not m.use:
-            continue
-        if m.type == 'ALONG_STROKE':
-            shaders_list.append(ColorAlongStrokeShader(
-                m.blend, m.influence, m.color_ramp))
-        elif m.type == 'DISTANCE_FROM_CAMERA':
-            shaders_list.append(ColorDistanceFromCameraShader(
-                m.blend, m.influence, m.color_ramp,
-                m.range_min, m.range_max))
-        elif m.type == 'DISTANCE_FROM_OBJECT':
-            shaders_list.append(ColorDistanceFromObjectShader(
-                m.blend, m.influence, m.color_ramp, m.target,
-                m.range_min, m.range_max))
-        elif m.type == 'MATERIAL':
-            shaders_list.append(ColorMaterialShader(
-                m.blend, m.influence, m.color_ramp, m.material_attribute,
-                m.use_ramp))
-    for m in linestyle.alpha_modifiers:
-        if not m.use:
-            continue
-        if m.type == 'ALONG_STROKE':
-            shaders_list.append(AlphaAlongStrokeShader(
-                m.blend, m.influence, m.mapping, m.invert, m.curve))
-        elif m.type == 'DISTANCE_FROM_CAMERA':
-            shaders_list.append(AlphaDistanceFromCameraShader(
-                m.blend, m.influence, m.mapping, m.invert, m.curve,
-                m.range_min, m.range_max))
-        elif m.type == 'DISTANCE_FROM_OBJECT':
-            shaders_list.append(AlphaDistanceFromObjectShader(
-                m.blend, m.influence, m.mapping, m.invert, m.curve, m.target,
-                m.range_min, m.range_max))
-        elif m.type == 'MATERIAL':
-            shaders_list.append(AlphaMaterialShader(
-                m.blend, m.influence, m.mapping, m.invert, m.curve,
-                m.material_attribute))
-    for m in linestyle.thickness_modifiers:
-        if not m.use:
-            continue
-        if m.type == 'ALONG_STROKE':
-            shaders_list.append(ThicknessAlongStrokeShader(
-                thickness_position, linestyle.thickness_ratio,
-                m.blend, m.influence, m.mapping, m.invert, m.curve,
-                m.value_min, m.value_max))
-        elif m.type == 'DISTANCE_FROM_CAMERA':
-            shaders_list.append(ThicknessDistanceFromCameraShader(
-                thickness_position, linestyle.thickness_ratio,
-                m.blend, m.influence, m.mapping, m.invert, m.curve,
-                m.range_min, m.range_max, m.value_min, m.value_max))
-        elif m.type == 'DISTANCE_FROM_OBJECT':
-            shaders_list.append(ThicknessDistanceFromObjectShader(
-                thickness_position, linestyle.thickness_ratio,
-                m.blend, m.influence, m.mapping, m.invert, m.curve, m.target,
-                m.range_min, m.range_max, m.value_min, m.value_max))
-        elif m.type == 'MATERIAL':
-            shaders_list.append(ThicknessMaterialShader(
-                thickness_position, linestyle.thickness_ratio,
-                m.blend, m.influence, m.mapping, m.invert, m.curve,
-                m.material_attribute, m.value_min, m.value_max))
-        elif m.type == 'CALLIGRAPHY':
-            shaders_list.append(CalligraphicThicknessShader(
-                thickness_position, linestyle.thickness_ratio,
-                m.blend, m.influence,
-                m.orientation, m.thickness_min, m.thickness_max))
-    if linestyle.caps == 'ROUND':
-        shaders_list.append(RoundCapShader())
-    elif linestyle.caps == 'SQUARE':
-        shaders_list.append(SquareCapShader())
-    if linestyle.use_dashed_line:
-        pattern = []
-        if linestyle.dash1 > 0 and linestyle.gap1 > 0:
-            pattern.append(linestyle.dash1)
-            pattern.append(linestyle.gap1)
-        if linestyle.dash2 > 0 and linestyle.gap2 > 0:
-            pattern.append(linestyle.dash2)
-            pattern.append(linestyle.gap2)
-        if linestyle.dash3 > 0 and linestyle.gap3 > 0:
-            pattern.append(linestyle.dash3)
-            pattern.append(linestyle.gap3)
-        if len(pattern) > 0:
-            shaders_list.append(DashedLineShader(pattern))
-    # create strokes using the shaders list
-    Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/polygonalize.py b/release/scripts/freestyle/style_modules/polygonalize.py
deleted file mode 100644
index e570e15ca6c..00000000000
--- a/release/scripts/freestyle/style_modules/polygonalize.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : polygonalize.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Make the strokes more "polygonal"
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Operators, PolygonalizationShader, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    SamplingShader(2.0),
-    ConstantThicknessShader(3),
-    ConstantColorShader(0.0, 0.0, 0.0),
-    PolygonalizationShader(8),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/qi0.py b/release/scripts/freestyle/style_modules/qi0.py
deleted file mode 100644
index 8386817754a..00000000000
--- a/release/scripts/freestyle/style_modules/qi0.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : qi0.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws the visible lines (chaining follows same nature lines)
-#             (most basic style module)
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    SamplingShader(5.0),
-    ConstantThicknessShader(4.0),
-    ConstantColorShader(0.0, 0.0, 0.0)
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/qi0_not_external_contour.py b/release/scripts/freestyle/style_modules/qi0_not_external_contour.py
deleted file mode 100644
index 6315f1291d4..00000000000
--- a/release/scripts/freestyle/style_modules/qi0_not_external_contour.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : qi0_not_external_contour.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws the visible lines (chaining follows same nature lines)
-#             that do not belong to the external contour of the scene
-
-from freestyle import BackboneStretcherShader, ChainSilhouetteIterator, ExternalContourUP1D, \
-    IncreasingColorShader, IncreasingThicknessShader, Operators, QuantitativeInvisibilityUP1D, \
-    SamplingShader, SpatialNoiseShader, TextureAssignerShader, TrueUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
-Operators.select(upred)
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-shaders_list = [
-    SamplingShader(4),
-    SpatialNoiseShader(4, 150, 2, True, True),
-    IncreasingThicknessShader(2, 5),
-    BackboneStretcherShader(20),
-    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
-    TextureAssignerShader(4),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/qi1.py b/release/scripts/freestyle/style_modules/qi1.py
deleted file mode 100644
index d5424b37748..00000000000
--- a/release/scripts/freestyle/style_modules/qi1.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : qi1.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws lines hidden by one surface.
-#             *** Quantitative Invisibility must have been 
-#             enabled in the options dialog to use this style module ****
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(1))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(1)))
-shaders_list = [
-    SamplingShader(5.0),
-    ConstantThicknessShader(3),
-    ConstantColorShader(0.5, 0.5, 0.5, 1)
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/qi2.py b/release/scripts/freestyle/style_modules/qi2.py
deleted file mode 100644
index 367139de2e2..00000000000
--- a/release/scripts/freestyle/style_modules/qi2.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : qi2.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws lines hidden by two surfaces.
-#             *** Quantitative Invisibility must have been 
-#             enabled in the options dialog to use this style module ****
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(2))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(2)))
-shaders_list = [
-    SamplingShader(10),
-    ConstantThicknessShader(1.5),
-    ConstantColorShader(0.7, 0.7, 0.7, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py b/release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py
deleted file mode 100644
index 755098d96b6..00000000000
--- a/release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : sequentialsplit_sketchy.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Use the sequential split with two different
-#             predicates to specify respectively the starting and
-#             the stopping extremities for strokes 
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, IncreasingThicknessShader, Nature, \
-    Operators, QuantitativeInvisibilityUP1D, SpatialNoiseShader, TextureAssignerShader, TrueUP1D
-from PredicatesU0D import pyBackTVertexUP0D, pyVertexNatureUP0D
-from logical_operators import NotUP1D
-
-upred = QuantitativeInvisibilityUP1D(0)
-Operators.select(upred)
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-## starting and stopping predicates:
-start = pyVertexNatureUP0D(Nature.NON_T_VERTEX)
-stop = pyBackTVertexUP0D()
-Operators.sequential_split(start, stop, 10)
-shaders_list = [
-    SpatialNoiseShader(7, 120, 2, True, True),
-    IncreasingThicknessShader(5, 8),
-    ConstantColorShader(0.2, 0.2, 0.2, 1),
-    TextureAssignerShader(4),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/shaders.py b/release/scripts/freestyle/style_modules/shaders.py
deleted file mode 100644
index 01bfac4d074..00000000000
--- a/release/scripts/freestyle/style_modules/shaders.py
+++ /dev/null
@@ -1,1227 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : shaders.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 11/08/2005
-#  Purpose  : Stroke shaders to be used for creation of stylized strokes
-
-from freestyle import AdjacencyIterator, Curvature2DAngleF0D, DensityF0D, GetProjectedZF0D, \
-    Interface0DIterator, MaterialF0D, Nature, Noise, Normal2DF0D, Orientation2DF1D, \
-    StrokeAttribute, StrokeShader, StrokeVertexIterator, ZDiscontinuityF0D
-from freestyle import ContextFunctions as CF
-from PredicatesU0D import pyVertexNatureUP0D
-
-import math
-import mathutils
-import random
-
-## thickness modifiers
-######################
-
-class pyDepthDiscontinuityThicknessShader(StrokeShader):
-	def __init__(self, min, max):
-		StrokeShader.__init__(self)
-		self.__min = float(min)
-		self.__max = float(max)
-		self.__func = ZDiscontinuityF0D()
-	def shade(self, stroke):
-		z_min=0.0
-		z_max=1.0
-		a = (self.__max - self.__min)/(z_max-z_min)
-		b = (self.__min*z_max-self.__max*z_min)/(z_max-z_min)
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			z = self.__func(Interface0DIterator(it))
-			thickness = a*z+b
-			it.object.attribute.thickness = (thickness, thickness)
-			it.increment()
-
-class pyConstantThicknessShader(StrokeShader):
-	def __init__(self, thickness):
-		StrokeShader.__init__(self)
-		self._thickness = thickness
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			t = self._thickness/2.0
-			it.object.attribute.thickness = (t, t)
-			it.increment()
-
-class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
-	def __init__(self, wsize, threshold_min, threshold_max, thicknessMin, thicknessMax):
-		StrokeShader.__init__(self)
-		self.wsize= wsize
-		self.threshold_min= threshold_min
-		self.threshold_max= threshold_max
-		self._thicknessMin = thicknessMin
-		self._thicknessMax = thicknessMax
-	def shade(self, stroke):
-		n = stroke.stroke_vertices_size()
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		func = DensityF0D(self.wsize)
-		while not it.is_end:
-			c = func(Interface0DIterator(it))
-			if c < self.threshold_min:
-				c = self.threshold_min
-			if c > self.threshold_max:
-				c = self.threshold_max
-##			t = (c - self.threshold_min)/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin
-			t = (self.threshold_max - c  )/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin
-			it.object.attribute.thickness = (t/2.0, t/2.0)
-			i = i+1
-			it.increment()
-
-class pyIncreasingThicknessShader(StrokeShader):
-	def __init__(self, thicknessMin, thicknessMax):
-		StrokeShader.__init__(self)
-		self._thicknessMin = thicknessMin
-		self._thicknessMax = thicknessMax
-	def shade(self, stroke):
-		n = stroke.stroke_vertices_size()
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			c = float(i)/float(n)
-			if i < float(n)/2.0:
-				t = (1.0 - c)*self._thicknessMin + c * self._thicknessMax
-			else:
-				t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin
-			it.object.attribute.thickness = (t/2.0, t/2.0)
-			i = i+1
-			it.increment()
-
-class pyConstrainedIncreasingThicknessShader(StrokeShader):
-	def __init__(self, thicknessMin, thicknessMax, ratio):
-		StrokeShader.__init__(self)
-		self._thicknessMin = thicknessMin
-		self._thicknessMax = thicknessMax
-		self._ratio = ratio
-	def shade(self, stroke):
-		slength = stroke.length_2d
-		tmp = self._ratio*slength
-		maxT = 0.0
-		if tmp < self._thicknessMax:
-			maxT = tmp
-		else:
-			maxT = self._thicknessMax
-		n = stroke.stroke_vertices_size()
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			att = it.object.attribute
-			c = float(i)/float(n)
-			if i < float(n)/2.0:
-				t = (1.0 - c)*self._thicknessMin + c * maxT
-			else:
-				t = (1.0 - c)*maxT + c * self._thicknessMin
-			att.thickness = (t/2.0, t/2.0)
-			if i == n-1:
-				att.thickness = (self._thicknessMin/2.0, self._thicknessMin/2.0)
-			i = i+1
-			it.increment()
-
-class pyDecreasingThicknessShader(StrokeShader):
-	def __init__(self, thicknessMin, thicknessMax):
-		StrokeShader.__init__(self)
-		self._thicknessMin = thicknessMin
-		self._thicknessMax = thicknessMax
-	def shade(self, stroke):
-		l = stroke.length_2d
-		tMax = self._thicknessMax
-		if self._thicknessMax > 0.33*l:
-			tMax = 0.33*l
-		tMin = self._thicknessMin
-		if self._thicknessMin > 0.1*l:
-			tMin = 0.1*l
-		n = stroke.stroke_vertices_size()
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			c = float(i)/float(n)
-			t = (1.0 - c)*tMax +c*tMin
-			it.object.attribute.thickness = (t/2.0, t/2.0)
-			i = i+1
-			it.increment()
-
-class pyNonLinearVaryingThicknessShader(StrokeShader):
-	def __init__(self, thicknessExtremity, thicknessMiddle, exponent):
-		StrokeShader.__init__(self)
-		self._thicknessMin = thicknessMiddle
-		self._thicknessMax = thicknessExtremity
-		self._exponent = exponent
-	def shade(self, stroke):
-		n = stroke.stroke_vertices_size()
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			if i < float(n)/2.0:
-				c = float(i)/float(n)
-			else:
-				c = float(n-i)/float(n)
-			c = self.smoothC(c, self._exponent)
-			t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin
-			it.object.attribute.thickness = (t/2.0, t/2.0)
-			i = i+1
-			it.increment()
-	def smoothC(self, a, exp):
-		return math.pow(float(a), exp) * math.pow(2.0, exp)
-
-## Spherical linear interpolation (cos)
-class pySLERPThicknessShader(StrokeShader):
-	def __init__(self, thicknessMin, thicknessMax, omega=1.2):
-		StrokeShader.__init__(self)
-		self._thicknessMin = thicknessMin
-		self._thicknessMax = thicknessMax
-		self._omega = omega
-	def shade(self, stroke):
-		slength = stroke.length_2d
-		tmp = 0.33*slength
-		maxT = self._thicknessMax
-		if tmp < self._thicknessMax:
-			maxT = tmp
-		n = stroke.stroke_vertices_size()
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			c = float(i)/float(n)
-			if i < float(n)/2.0:
-				t = math.sin((1-c)*self._omega)/math.sinh(self._omega)*self._thicknessMin + math.sin(c*self._omega)/math.sinh(self._omega) * maxT
-			else:
-				t = math.sin((1-c)*self._omega)/math.sinh(self._omega)*maxT + math.sin(c*self._omega)/math.sinh(self._omega) * self._thicknessMin
-			it.object.attribute.thickness = (t/2.0, t/2.0)
-			i = i+1
-			it.increment()
-
-class pyTVertexThickenerShader(StrokeShader): ## FIXME
-	def __init__(self, a=1.5, n=3):
-		StrokeShader.__init__(self)
-		self._a = a
-		self._n = n
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)
-		while not it.is_end:
-			if predTVertex(it) == 1:
-				it2 = StrokeVertexIterator(it)
-				it2.increment()
-				if not (it.is_begin or it2.is_end):
-					it.increment()
-					continue
-				n = self._n
-				a = self._a
-				if it.is_begin:
-					it3 = StrokeVertexIterator(it)
-					count = 0
-					while (not it3.is_end) and count < n:
-						att = it3.object.attribute
-						(tr, tl) = att.thickness
-						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
-						#r = (1.0-a)/float(n-1)*count + a
-						att.thickness = (r*tr, r*tl)	
-						it3.increment()
-						count = count + 1
-				if it2.is_end:
-					it4 = StrokeVertexIterator(it)
-					count = 0
-					while (not it4.is_begin) and count < n:
-						att = it4.object.attribute
-						(tr, tl) = att.thickness
-						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
-						#r = (1.0-a)/float(n-1)*count + a
-						att.thickness = (r*tr, r*tl)	
-						it4.decrement()
-						count = count + 1
-					if it4.is_begin:
-						att = it4.object.attribute
-						(tr, tl) = att.thickness
-						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
-						#r = (1.0-a)/float(n-1)*count + a
-						att.thickness = (r*tr, r*tl)	
-			it.increment()
-
-class pyImportance2DThicknessShader(StrokeShader):
-	def __init__(self, x, y, w, kmin, kmax):
-		StrokeShader.__init__(self)
-		self._x = x
-		self._y = y
-		self._w = float(w)
-		self._kmin = float(kmin)
-		self._kmax = float(kmax)
-	def shade(self, stroke):
-		origin = mathutils.Vector([self._x, self._y])
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			v = it.object
-			p = mathutils.Vector([v.projected_x, v.projected_y])
-			d = (p-origin).length
-			if d > self._w:
-				k = self._kmin
-			else:
-				k = (self._kmax*(self._w-d) + self._kmin*d)/self._w
-			att = v.attribute
-			(tr, tl) = att.thickness
-			att.thickness = (k*tr/2.0, k*tl/2.0)
-			it.increment()
-
-class pyImportance3DThicknessShader(StrokeShader):
-	def __init__(self, x, y, z, w, kmin, kmax):
-		StrokeShader.__init__(self)
-		self._x = x
-		self._y = y
-		self._z = z
-		self._w = float(w)
-		self._kmin = float(kmin)
-		self._kmax = float(kmax)
-	def shade(self, stroke):
-		origin = mathutils.Vector([self._x, self._y, self._z])
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			v = it.object
-			p = v.point_3d
-			d = (p-origin).length
-			if d > self._w:
-				k = self._kmin
-			else:
-				k = (self._kmax*(self._w-d) + self._kmin*d)/self._w
-			att = v.attribute
-			(tr, tl) = att.thickness
-			att.thickness = (k*tr/2.0, k*tl/2.0)
-			it.increment()
-
-class pyZDependingThicknessShader(StrokeShader):
-	def __init__(self, min, max):
-		StrokeShader.__init__(self)
-		self.__min = min
-		self.__max = max
-		self.__func = GetProjectedZF0D()
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		z_min = 1
-		z_max = 0
-		while not it.is_end:
-			z = self.__func(Interface0DIterator(it))
-			if z < z_min:
-				z_min = z
-			if z > z_max:
-				z_max = z
-			it.increment()
-		z_diff = 1 / (z_max - z_min)
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			z = (self.__func(Interface0DIterator(it)) - z_min) * z_diff
-			thickness = (1 - z) * self.__max + z * self.__min
-			it.object.attribute.thickness = (thickness, thickness)
-			it.increment()
-
-
-## color modifiers
-##################
-
-class pyConstantColorShader(StrokeShader):
-	def __init__(self,r,g,b, a = 1):
-		StrokeShader.__init__(self)
-		self._r = r
-		self._g = g
-		self._b = b
-		self._a = a
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			att = it.object.attribute
-			att.color = (self._r, self._g, self._b)
-			att.alpha = self._a
-			it.increment()
-
-#c1->c2
-class pyIncreasingColorShader(StrokeShader):
-	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
-		StrokeShader.__init__(self)
-		self._c1 = [r1,g1,b1,a1]
-		self._c2 = [r2,g2,b2,a2]
-	def shade(self, stroke):
-		n = stroke.stroke_vertices_size() - 1
-		inc = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			att = it.object.attribute
-			c = float(inc)/float(n)
-
-			att.color = ((1-c)*self._c1[0] + c*self._c2[0], 
-				     (1-c)*self._c1[1] + c*self._c2[1],
-				     (1-c)*self._c1[2] + c*self._c2[2])
-			att.alpha = (1-c)*self._c1[3] + c*self._c2[3]
-			inc = inc+1
-			it.increment()
-
-# c1->c2->c1
-class pyInterpolateColorShader(StrokeShader):
-	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
-		StrokeShader.__init__(self)
-		self._c1 = [r1,g1,b1,a1]
-		self._c2 = [r2,g2,b2,a2]
-	def shade(self, stroke):
-		n = stroke.stroke_vertices_size() - 1
-		inc = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			att = it.object.attribute
-			u = float(inc)/float(n)
-			c = 1-2*(math.fabs(u-0.5))
-			att.color = ((1-c)*self._c1[0] + c*self._c2[0], 
-				     (1-c)*self._c1[1] + c*self._c2[1],
-				     (1-c)*self._c1[2] + c*self._c2[2])
-			att.alpha = (1-c)*self._c1[3] + c*self._c2[3]
-			inc = inc+1
-			it.increment()
-
-class pyMaterialColorShader(StrokeShader):
-	def __init__(self, threshold=50):
-		StrokeShader.__init__(self)
-		self._threshold = threshold
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		func = MaterialF0D()
-		xn = 0.312713
-		yn = 0.329016
-		Yn = 1.0
-		un = 4.* xn/ ( -2.*xn + 12.*yn + 3. )
-		vn= 9.* yn/ ( -2.*xn + 12.*yn +3. )	
-		while not it.is_end:
-			mat = func(Interface0DIterator(it))
-			
-			r = mat.diffuse[0]
-			g = mat.diffuse[1]
-			b = mat.diffuse[2]
-
-			X = 0.412453*r + 0.35758 *g + 0.180423*b
-			Y = 0.212671*r + 0.71516 *g + 0.072169*b
-			Z = 0.019334*r + 0.119193*g + 0.950227*b
-
-			if X == 0 and Y == 0 and Z == 0:
-				X = 0.01
-				Y = 0.01
-				Z = 0.01
-			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
-			U = 13. * L * (u - un)
-			V = 13. * L * (v - vn)
-			
-			if L > self._threshold:
-				L = L/1.3
-				U = U+10
-			else:
-				L = L +2.5*(100-L)/5.
-				U = U/3.0
-				V = V/3.0				
-			u = U / (13. * L) + un
-			v = V / (13. * L) + vn
-			
-			Y = Yn * math.pow( ((L+16.)/116.), 3.)
-			X = -9. * Y * u / ((u - 4.)* v - u * v)
-			Z = (9. * Y - 15*v*Y - v*X) /( 3. * v)
-			
-			r = 3.240479 * X - 1.53715 * Y - 0.498535 * Z
-			g = -0.969256 * X + 1.875991 * Y + 0.041556 * Z
-			b = 0.055648 * X - 0.204043 * Y + 1.057311 * Z
-
-			r = max(0,r)
-			g = max(0,g)
-			b = max(0,b)
-
-			it.object.attribute.color = (r, g, b)
-			it.increment()
-
-class pyRandomColorShader(StrokeShader):
-	def __init__(self, s=1):
-		StrokeShader.__init__(self)
-		random.seed(s)
-	def shade(self, stroke):
-		## pick a random color
-		c0 = float(random.uniform(15,75))/100.0
-		c1 = float(random.uniform(15,75))/100.0
-		c2 = float(random.uniform(15,75))/100.0
-		#print(c0, c1, c2)
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			it.object.attribute.color = (c0,c1,c2)
-			it.increment()
-
-class py2DCurvatureColorShader(StrokeShader):
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		func = Curvature2DAngleF0D()
-		while not it.is_end:
-			c = func(Interface0DIterator(it))
-			if c < 0:
-				print("negative 2D curvature")
-			color = 10.0 * c/3.1415
-			it.object.attribute.color = (color, color, color)
-			it.increment()
-
-class pyTimeColorShader(StrokeShader):
-	def __init__(self, step=0.01):
-		StrokeShader.__init__(self)
-		self._t = 0
-		self._step = step
-	def shade(self, stroke):
-		c = self._t*1.0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			it.object.attribute.color = (c,c,c)
-			it.increment()
-		self._t = self._t+self._step
-
-## geometry modifiers
-
-class pySamplingShader(StrokeShader):
-	def __init__(self, sampling):
-		StrokeShader.__init__(self)
-		self._sampling = sampling
-	def shade(self, stroke):
-		stroke.resample(float(self._sampling)) 
-		stroke.update_length()
-
-class pyBackboneStretcherShader(StrokeShader):
-	def __init__(self, l):
-		StrokeShader.__init__(self)
-		self._l = l
-	def shade(self, stroke):
-		it0 = stroke.stroke_vertices_begin()
-		it1 = StrokeVertexIterator(it0)
-		it1.increment()
-		itn = stroke.stroke_vertices_end()
-		itn.decrement()
-		itn_1 = StrokeVertexIterator(itn)
-		itn_1.decrement()
-		v0 = it0.object
-		v1 = it1.object
-		vn_1 = itn_1.object
-		vn = itn.object
-		p0 = mathutils.Vector([v0.projected_x, v0.projected_y])
-		pn = mathutils.Vector([vn.projected_x, vn.projected_y])
-		p1 = mathutils.Vector([v1.projected_x, v1.projected_y])
-		pn_1 = mathutils.Vector([vn_1.projected_x, vn_1.projected_y])
-		d1 = p0-p1
-		d1.normalize()
-		dn = pn-pn_1
-		dn.normalize()
-		newFirst = p0+d1*float(self._l)
-		newLast = pn+dn*float(self._l)
-		v0.point = newFirst
-		vn.point = newLast
-		stroke.update_length()
-		
-class pyLengthDependingBackboneStretcherShader(StrokeShader):
-	def __init__(self, l):
-		StrokeShader.__init__(self)
-		self._l = l
-	def shade(self, stroke):
-		l = stroke.length_2d
-		stretch = self._l*l 
-		it0 = stroke.stroke_vertices_begin()
-		it1 = StrokeVertexIterator(it0)
-		it1.increment()
-		itn = stroke.stroke_vertices_end()
-		itn.decrement()
-		itn_1 = StrokeVertexIterator(itn)
-		itn_1.decrement()
-		v0 = it0.object
-		v1 = it1.object
-		vn_1 = itn_1.object
-		vn = itn.object
-		p0 = mathutils.Vector([v0.projected_x, v0.projected_y])
-		pn = mathutils.Vector([vn.projected_x, vn.projected_y])
-		p1 = mathutils.Vector([v1.projected_x, v1.projected_y])
-		pn_1 = mathutils.Vector([vn_1.projected_x, vn_1.projected_y])
-		d1 = p0-p1
-		d1.normalize()
-		dn = pn-pn_1
-		dn.normalize()
-		newFirst = p0+d1*float(stretch)
-		newLast = pn+dn*float(stretch)
-		v0.point = newFirst
-		vn.point = newLast
-		stroke.update_length()
-
-
-## Shader to replace a stroke by its corresponding tangent
-class pyGuidingLineShader(StrokeShader):
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin() 	## get the first vertex
-		itlast = stroke.stroke_vertices_end() 	## 
-		itlast.decrement()			## get the last one
-		t = itlast.object.point - it.object.point	## tangent direction
-		itmiddle = StrokeVertexIterator(it)	## 
-		while itmiddle.object.u < 0.5:	## look for the stroke middle vertex
-			itmiddle.increment()		##
-		it = StrokeVertexIterator(itmiddle)	
-		it.increment()
-		while not it.is_end:			## position all the vertices along the tangent for the right part
-			it.object.point = itmiddle.object.point \
-			    +t*(it.object.u-itmiddle.object.u)
-			it.increment()
-		it = StrokeVertexIterator(itmiddle)
-		it.decrement()
-		while not it.is_begin:			## position all the vertices along the tangent for the left part
-			it.object.point = itmiddle.object.point \
-			    -t*(itmiddle.object.u-it.object.u)
-			it.decrement()
-		it.object.point = itmiddle.object.point-t*itmiddle.object.u ## first vertex
-		stroke.update_length()
-
-
-class pyBackboneStretcherNoCuspShader(StrokeShader):
-	def __init__(self, l):
-		StrokeShader.__init__(self)
-		self._l = l
-	def shade(self, stroke):
-		it0 = stroke.stroke_vertices_begin()
-		it1 = StrokeVertexIterator(it0)
-		it1.increment()
-		itn = stroke.stroke_vertices_end()
-		itn.decrement()
-		itn_1 = StrokeVertexIterator(itn)
-		itn_1.decrement()
-		v0 = it0.object
-		v1 = it1.object
-		if (v0.nature & Nature.CUSP) == 0 and (v1.nature & Nature.CUSP) == 0:
-			p0 = v0.point
-			p1 = v1.point
-			d1 = p0-p1
-			d1.normalize()
-			newFirst = p0+d1*float(self._l)
-			v0.point = newFirst
-		vn_1 = itn_1.object
-		vn = itn.object
-		if (vn.nature & Nature.CUSP) == 0 and (vn_1.nature & Nature.CUSP) == 0:
-			pn = vn.point
-			pn_1 = vn_1.point
-			dn = pn-pn_1
-			dn.normalize()
-			newLast = pn+dn*float(self._l)	
-			vn.point = newLast
-		stroke.update_length()
-
-class pyDiffusion2Shader(StrokeShader):
-	"""This shader iteratively adds an offset to the position of each
-	stroke vertex in the direction perpendicular to the stroke direction
-	at the point.  The offset is scaled by the 2D curvature (i.e., how
-	quickly the stroke curve is) at the point."""
-	def __init__(self, lambda1, nbIter):
-		StrokeShader.__init__(self)
-		self._lambda = lambda1
-		self._nbIter = nbIter
-		self._normalInfo = Normal2DF0D()
-		self._curvatureInfo = Curvature2DAngleF0D()
-	def shade(self, stroke):
-		for i in range (1, self._nbIter):
-			it = stroke.stroke_vertices_begin()
-			while not it.is_end:
-				v = it.object
-				p1 = v.point
-				p2 = self._normalInfo(Interface0DIterator(it))*self._lambda*self._curvatureInfo(Interface0DIterator(it))
-				v.point = p1+p2
-				it.increment()
-		stroke.update_length()
-
-class pyTipRemoverShader(StrokeShader):
-	def __init__(self, l):
-		StrokeShader.__init__(self)
-		self._l = l
-	def shade(self, stroke):
-		originalSize = stroke.stroke_vertices_size()
-		if originalSize < 4:
-			return
-		verticesToRemove = []
-		oldAttributes = []
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			v = it.object
-			if v.curvilinear_abscissa < self._l or v.stroke_length-v.curvilinear_abscissa < self._l:
-				verticesToRemove.append(v)
-			oldAttributes.append(StrokeAttribute(v.attribute))
-			it.increment()
-		if originalSize-len(verticesToRemove) < 2:
-			return
-		for sv in verticesToRemove:
-			stroke.remove_vertex(sv)
-		stroke.update_length()
-		stroke.resample(originalSize)
-		if stroke.stroke_vertices_size() != originalSize:
-			print("pyTipRemover: Warning: resampling problem")
-		it = stroke.stroke_vertices_begin()
-		for a in oldAttributes:
-			if it.is_end:
-				break
-			it.object.attribute = a
-			it.increment()
-		stroke.update_length()
-
-class pyTVertexRemoverShader(StrokeShader):
-	def shade(self, stroke):
-		if stroke.stroke_vertices_size() <= 3:
-			return
-		predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)
-		it = stroke.stroke_vertices_begin()
-		itlast = stroke.stroke_vertices_end()
-		itlast.decrement()
-		if predTVertex(it):
-			stroke.remove_vertex(it.object)
-		if predTVertex(itlast):
-			stroke.remove_vertex(itlast.object)
-		stroke.update_length()
-
-#class pyExtremitiesOrientationShader(StrokeShader):
-#	def __init__(self, x1,y1,x2=0,y2=0):
-#		StrokeShader.__init__(self)
-#		self._v1 = mathutils.Vector([x1,y1])
-#		self._v2 = mathutils.Vector([x2,y2])
-#	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)
-
-class pyHLRShader(StrokeShader):
-	def shade(self, stroke):
-		originalSize = stroke.stroke_vertices_size()
-		if originalSize < 4:
-			return
-		it = stroke.stroke_vertices_begin()
-		invisible = 0
-		it2 = StrokeVertexIterator(it)
-		it2.increment()
-		fe = self.get_fedge(it.object, it2.object)
-		if fe.viewedge.qi != 0:
-			invisible = 1
-		while not it2.is_end:
-			v = it.object
-			vnext = it2.object
-			if (v.nature & Nature.VIEW_VERTEX) != 0:
-				#if (v.nature & Nature.T_VERTEX) != 0:
-				fe = self.get_fedge(v, vnext)
-				qi = fe.viewedge.qi
-				if qi != 0:
-					invisible = 1
-				else:
-					invisible = 0
-			if invisible:
-				v.attribute.visible = False
-			it.increment()
-			it2.increment()
-	def get_fedge(self, it1, it2):
-		return it1.get_fedge(it2)
-
-class pyTVertexOrientationShader(StrokeShader):
-	def __init__(self):
-		StrokeShader.__init__(self)
-		self._Get2dDirection = Orientation2DF1D()
-	## finds the TVertex orientation from the TVertex and 
-	## the previous or next edge
-	def findOrientation(self, tv, ve):
-		mateVE = tv.get_mate(ve)
-		if ve.qi != 0 or mateVE.qi != 0:
-			ait = AdjacencyIterator(tv,1,0)
-			winner = None
-			incoming = True
-			while not ait.is_end:
-				ave = ait.object
-				if  ave.id != ve.id and ave.id != mateVE.id:
-					winner = ait.object
-					if not ait.isIncoming(): # FIXME
-						incoming = False
-						break
-				ait.increment()
-			if winner is not None:
-				if not incoming:
-					direction = self._Get2dDirection(winner.last_fedge)
-				else:
-					direction = self._Get2dDirection(winner.first_fedge)
-				return direction
-		return None
-	def castToTVertex(self, cp):
-		if cp.t2d() == 0.0:
-			return cp.first_svertex.viewvertex
-		elif cp.t2d() == 1.0:
-			return cp.second_svertex.viewvertex
-		return None
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		it2 = StrokeVertexIterator(it)
-		it2.increment()
-		## case where the first vertex is a TVertex
-		v = it.object
-		if (v.nature & Nature.T_VERTEX) != 0:
-			tv = self.castToTVertex(v)
-			if tv is not None:
-				ve = self.get_fedge(v, it2.object).viewedge
-				dir = self.findOrientation(tv, ve)
-				if dir is not None:
-					#print(dir.x, dir.y)
-					v.attribute.set_attribute_vec2("orientation", dir)
-		while not it2.is_end:
-			vprevious = it.object
-			v = it2.object
-			if (v.nature & Nature.T_VERTEX) != 0:
-				tv = self.castToTVertex(v)
-				if tv is not None:
-					ve = self.get_fedge(vprevious, v).viewedge
-					dir = self.findOrientation(tv, ve)
-					if dir is not None:
-						#print(dir.x, dir.y)
-						v.attribute.set_attribute_vec2("orientation", dir)
-			it.increment()
-			it2.increment()
-		## case where the last vertex is a TVertex
-		v = it.object 
-		if (v.nature & Nature.T_VERTEX) != 0:
-			itPrevious = StrokeVertexIterator(it)
-			itPrevious.decrement()
-			tv = self.castToTVertex(v)
-			if tv is not None:
-				ve = self.get_fedge(itPrevious.object, v).viewedge
-				dir = self.findOrientation(tv, ve)
-				if dir is not None:
-					#print(dir.x, dir.y)
-					v.attribute.set_attribute_vec2("orientation", dir)
-	def get_fedge(self, it1, it2):
-		return it1.get_fedge(it2)
-
-class pySinusDisplacementShader(StrokeShader):
-	def __init__(self, f, a):
-		StrokeShader.__init__(self)
-		self._f = f
-		self._a = a
-		self._getNormal = Normal2DF0D()
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			v = it.object
-			#print(self._getNormal.name)
-			n = self._getNormal(Interface0DIterator(it))
-			p = v.point
-			u = v.u
-			a = self._a*(1-2*(math.fabs(u-0.5)))
-			n = n*a*math.cos(self._f*u*6.28)
-			#print(n.x, n.y)
-			v.point = p+n
-			#v.point = v.point+n*a*math.cos(f*v.u)
-			it.increment()
-		stroke.update_length()
-
-class pyPerlinNoise1DShader(StrokeShader):
-	def __init__(self, freq = 10, amp = 10, oct = 4, seed = -1):
-		StrokeShader.__init__(self)
-		self.__noise = Noise(seed)
-		self.__freq = freq
-		self.__amp = amp
-		self.__oct = oct
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			v = it.object
-			i = v.projected_x + v.projected_y
-			nres = self.__noise.turbulence1(i, self.__freq, self.__amp, self.__oct)
-			v.point = (v.projected_x + nres, v.projected_y + nres)
-			it.increment()
-		stroke.update_length()
-
-class pyPerlinNoise2DShader(StrokeShader):
-	def __init__(self, freq = 10, amp = 10, oct = 4, seed = -1):
-		StrokeShader.__init__(self)
-		self.__noise = Noise(seed)
-		self.__freq = freq
-		self.__amp = amp
-		self.__oct = oct
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			v = it.object
-			vec = mathutils.Vector([v.projected_x, v.projected_y])
-			nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
-			v.point = (v.projected_x + nres, v.projected_y + nres)
-			it.increment()
-		stroke.update_length()
-
-class pyBluePrintCirclesShader(StrokeShader):
-	def __init__(self, turns = 1, random_radius = 3, random_center = 5):
-		StrokeShader.__init__(self)
-		self.__turns = turns
-		self.__random_center = random_center
-		self.__random_radius = random_radius
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		if it.is_end:
-			return
-		p_min = it.object.point.copy()
-		p_max = it.object.point.copy()
-		while not it.is_end:
-			p = it.object.point
-			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.stroke_vertices_size()
-#		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 = mathutils.Vector([0, 0])
-#######################################################
-		R = self.__random_radius
-		C = self.__random_center
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		for j in range(self.__turns):
-			prev_radius = radius
-			prev_center = center
-			radius = radius + random.randint(-R, R)
-			center = center + mathutils.Vector([random.randint(-C, C), random.randint(-C, C)])
-			while i < sv_nb and not it.is_end:
-				t = float(i) / float(sv_nb - 1)
-				r = prev_radius + (radius - prev_radius) * t
-				c = prev_center + (center - prev_center) * t
-				p_new.x = c.x + r * math.cos(2 * math.pi * t)
-				p_new.y = c.y + r * math.sin(2 * math.pi * t)
-				it.object.point = p_new
-				i = i + 1
-				it.increment()
-			i = 1
-		verticesToRemove = []
-		while not it.is_end:
-			verticesToRemove.append(it.object)
-			it.increment()
-		for sv in verticesToRemove:
-			stroke.remove_vertex(sv)
-		stroke.update_length()
-
-class pyBluePrintEllipsesShader(StrokeShader):
-	def __init__(self, turns = 1, random_radius = 3, random_center = 5):
-		StrokeShader.__init__(self)
-		self.__turns = turns
-		self.__random_center = random_center
-		self.__random_radius = random_radius
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		if it.is_end:
-			return
-		p_min = it.object.point.copy()
-		p_max = it.object.point.copy()
-		while not it.is_end:
-			p = it.object.point
-			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.stroke_vertices_size()
-		sv_nb = sv_nb // self.__turns
-		center = (p_min + p_max) / 2
-		radius = center - p_min
-		p_new = mathutils.Vector([0, 0])
-#######################################################
-		R = self.__random_radius
-		C = self.__random_center
-		i = 0
-		it = stroke.stroke_vertices_begin()
-		for j in range(self.__turns):
-			prev_radius = radius
-			prev_center = center
-			radius = radius + mathutils.Vector([random.randint(-R, R), random.randint(-R, R)])
-			center = center + mathutils.Vector([random.randint(-C, C), random.randint(-C, C)])
-			while i < sv_nb and not it.is_end:
-				t = float(i) / float(sv_nb - 1)
-				r = prev_radius + (radius - prev_radius) * t
-				c = prev_center + (center - prev_center) * t
-				p_new.x = c.x + r.x * math.cos(2 * math.pi * t)
-				p_new.y = c.y + r.y * math.sin(2 * math.pi * t)
-				it.object.point = p_new
-				i = i + 1
-				it.increment()
-			i = 1
-		verticesToRemove = []
-		while not it.is_end:
-			verticesToRemove.append(it.object)
-			it.increment()
-		for sv in verticesToRemove:
-			stroke.remove_vertex(sv)
-		stroke.update_length()
-
-
-class pyBluePrintSquaresShader(StrokeShader):
-	def __init__(self, turns = 1, bb_len = 10, bb_rand = 0):
-		StrokeShader.__init__(self)
-		self.__turns = turns
-		self.__bb_len = bb_len
-		self.__bb_rand = bb_rand
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		if it.is_end:
-			return
-		p_min = it.object.point.copy()
-		p_max = it.object.point.copy()
-		while not it.is_end:
-			p = it.object.point
-			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.stroke_vertices_size()
-#######################################################	
-		sv_nb = sv_nb // self.__turns
-		first = sv_nb // 4
-		second = 2 * first
-		third = 3 * first
-		fourth = sv_nb
-		p_first = mathutils.Vector([p_min.x - self.__bb_len, p_min.y])
-		p_first_end = mathutils.Vector([p_max.x + self.__bb_len, p_min.y])
-		p_second = mathutils.Vector([p_max.x, p_min.y - self.__bb_len])
-		p_second_end = mathutils.Vector([p_max.x, p_max.y + self.__bb_len])
-		p_third = mathutils.Vector([p_max.x + self.__bb_len, p_max.y])
-		p_third_end = mathutils.Vector([p_min.x - self.__bb_len, p_max.y])
-		p_fourth = mathutils.Vector([p_min.x, p_max.y + self.__bb_len])
-		p_fourth_end = mathutils.Vector([p_min.x, p_min.y - self.__bb_len])
-#######################################################
-		R = self.__bb_rand
-		r = self.__bb_rand // 2
-		it = stroke.stroke_vertices_begin()
-		visible = True
-		for j in range(self.__turns):
-			p_first = p_first + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
-			p_first_end = p_first_end + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
-			p_second = p_second + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
-			p_second_end = p_second_end + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
-			p_third = p_third + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
-			p_third_end = p_third_end + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
-			p_fourth = p_fourth + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
-			p_fourth_end = p_fourth_end + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
-			vec_first = p_first_end - p_first
-			vec_second = p_second_end - p_second
-			vec_third = p_third_end - p_third
-			vec_fourth = p_fourth_end - p_fourth
-			i = 0
-			while i < sv_nb and not it.is_end:
-				if i < first:
-					p_new = p_first + vec_first * float(i)/float(first - 1)
-					if i == first - 1:
-						visible = False
-				elif i < second:
-					p_new = p_second + vec_second * float(i - first)/float(second - first - 1)
-					if i == second - 1:
-						visible = False
-				elif i < third:
-					p_new = p_third + vec_third * float(i - second)/float(third - second - 1)
-					if i == third - 1:
-						visible = False
-				else:
-					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
-					if i == fourth - 1:
-						visible = False
-				if it.object == None:
-					i = i + 1
-					it.increment()
-					if not visible:
-						visible = True
-					continue
-				it.object.point = p_new
-				it.object.attribute.visible = visible
-				if not visible:
-					visible = True
-				i = i + 1
-				it.increment()
-		verticesToRemove = []
-		while not it.is_end:
-			verticesToRemove.append(it.object)
-			it.increment()
-		for sv in verticesToRemove:
-			stroke.remove_vertex(sv)
-		stroke.update_length()
-
-
-class pyBluePrintDirectedSquaresShader(StrokeShader):
-	def __init__(self, turns = 1, bb_len = 10, mult = 1):
-		StrokeShader.__init__(self)
-		self.__mult = mult
-		self.__turns = turns
-		self.__bb_len = 1 + float(bb_len) / 100
-	def shade(self, stroke):
-		stroke.resample(32 * self.__turns)
-		p_mean = mathutils.Vector([0, 0])
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			p = it.object.point
-			p_mean = p_mean + p
-			it.increment()
-		sv_nb = stroke.stroke_vertices_size()
-		p_mean = p_mean / sv_nb
-		p_var_xx = 0
-		p_var_yy = 0
-		p_var_xy = 0
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			p = it.object.point
-			p_var_xx = p_var_xx + math.pow(p.x - p_mean.x, 2)
-			p_var_yy = p_var_yy + math.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
-		p_var_xy = p_var_xy / sv_nb
-##		print(p_var_xx, p_var_yy, p_var_xy)
-		trace = p_var_xx + p_var_yy
-		det = p_var_xx * p_var_yy - p_var_xy * p_var_xy
-		sqrt_coeff = math.sqrt(trace * trace - 4 * det)
-		lambda1 = (trace + sqrt_coeff) / 2
-		lambda2 = (trace - sqrt_coeff) / 2
-##		print(lambda1, lambda2)
-		theta = math.atan(2 * p_var_xy / (p_var_xx - p_var_yy)) / 2
-##		print(theta)
-		if p_var_yy > p_var_xx:
-			e1 = mathutils.Vector([math.cos(theta + math.pi / 2), math.sin(theta + math.pi / 2)]) * math.sqrt(lambda1) * self.__mult
-			e2 = mathutils.Vector([math.cos(theta + math.pi), math.sin(theta + math.pi)]) *  math.sqrt(lambda2) * self.__mult
-		else:
-			e1 = mathutils.Vector([math.cos(theta), math.sin(theta)]) * math.sqrt(lambda1) * self.__mult
-			e2 = mathutils.Vector([math.cos(theta + math.pi / 2), math.sin(theta + math.pi / 2)]) * math.sqrt(lambda2) * self.__mult
-#######################################################	
-		sv_nb = sv_nb // self.__turns
-		first = sv_nb // 4
-		second = 2 * first
-		third = 3 * first
-		fourth = sv_nb
-		bb_len1 = self.__bb_len
-		bb_len2 = 1 + (bb_len1 - 1) * math.sqrt(lambda1 / lambda2)
-		p_first = p_mean - e1 - e2 * bb_len2
-		p_second = p_mean - e1 * bb_len1 + e2
-		p_third = p_mean + e1 + e2 * bb_len2
-		p_fourth = p_mean + e1 * bb_len1 - e2
-		vec_first = e2 * bb_len2 * 2
-		vec_second = e1 * bb_len1 * 2
-		vec_third = vec_first * -1
-		vec_fourth = vec_second * -1
-#######################################################
-		it = stroke.stroke_vertices_begin()
-		visible = True
-		for j in range(self.__turns):
-			i = 0
-			while i < sv_nb:
-				if i < first:
-					p_new = p_first + vec_first * float(i)/float(first - 1)
-					if i == first - 1:
-						visible = False
-				elif i < second:
-					p_new = p_second + vec_second * float(i - first)/float(second - first - 1)
-					if i == second - 1:
-						visible = False
-				elif i < third:
-					p_new = p_third + vec_third * float(i - second)/float(third - second - 1)
-					if i == third - 1:
-						visible = False
-				else:
-					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
-					if i == fourth - 1:
-						visible = False
-				it.object.point = p_new
-				it.object.attribute.visible = visible
-				if not visible:
-					visible = True
-				i = i + 1
-				it.increment()
-		verticesToRemove = []
-		while not it.is_end:
-			verticesToRemove.append(it.object)
-			it.increment()
-		for sv in verticesToRemove:
-			stroke.remove_vertex(sv)
-		stroke.update_length()
-
-class pyModulateAlphaShader(StrokeShader):
-	def __init__(self, min = 0, max = 1):
-		StrokeShader.__init__(self)
-		self.__min = min
-		self.__max = max
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			alpha = it.object.attribute.alpha
-			p = it.object.point
-			alpha = alpha * p.y / 400
-			if alpha < self.__min:
-				alpha = self.__min
-			elif alpha > self.__max:
-				alpha = self.__max
-			it.object.attribute.alpha = alpha
-			it.increment()
-
-## various
-class pyDummyShader(StrokeShader):
-	def shade(self, stroke):
-		it = stroke.stroke_vertices_begin()
-		while not it.is_end:
-			toto = Interface0DIterator(it)
-			att = it.object.attribute
-			att.color = (0.3, 0.4, 0.4)
-			att.thickness = (0, 5)
-			it.increment()
-
-class pyDebugShader(StrokeShader):
-	def shade(self, stroke):
-		fe = CF.get_selected_fedge()
-		id1 = fe.first_svertex.id
-		id2 = fe.second_svertex.id
-		#print(id1.first, id1.second)
-		#print(id2.first, id2.second)
-		it = stroke.stroke_vertices_begin()
-		found = True
-		foundfirst = True
-		foundsecond = False
-		while not it.is_end:
-			cp = it.object
-			if cp.first_svertex.id == id1 or cp.second_svertex.id == id1:
-				foundfirst = True
-			if cp.first_svertex.id == id2 or cp.second_svertex.id == id2:
-				foundsecond = True
-			if foundfirst and foundsecond:
-				found = True
-				break
-			it.increment()
-		if found:
-			print("The selected Stroke id is: ", stroke.id.first, stroke.id.second)
diff --git a/release/scripts/freestyle/style_modules/sketchy_multiple_parameterization.py b/release/scripts/freestyle/style_modules/sketchy_multiple_parameterization.py
deleted file mode 100644
index c1cc4361f7f..00000000000
--- a/release/scripts/freestyle/style_modules/sketchy_multiple_parameterization.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : sketchy_multiple_parameterization.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Builds sketchy strokes whose topology relies on a 
-#             parameterization that covers the complete lines (visible+invisible)
-#             whereas only the visible portions are actually drawn
-
-from ChainingIterators import pySketchyChainSilhouetteIterator
-from freestyle import IncreasingColorShader, IncreasingThicknessShader, Operators, \
-    QuantitativeInvisibilityUP1D, SamplingShader, SmoothingShader, SpatialNoiseShader, \
-    TextureAssignerShader, TrueUP1D
-from shaders import pyHLRShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(3, False))
-shaders_list = [
-    SamplingShader(2),
-    SpatialNoiseShader(15, 120, 2, True, True),
-    IncreasingThicknessShader(5, 30),
-    SmoothingShader(100, 0.05, 0, 0.2, 0, 0, 0, 1),
-    IncreasingColorShader(0, 0.2, 0, 1, 0.2, 0.7, 0.2, 1),
-    TextureAssignerShader(6),
-    pyHLRShader(),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/sketchy_topology_broken.py b/release/scripts/freestyle/style_modules/sketchy_topology_broken.py
deleted file mode 100644
index 27669d20a4e..00000000000
--- a/release/scripts/freestyle/style_modules/sketchy_topology_broken.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : sketchy_topology_broken.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : The topology of the strokes is, first, built
-#             independantly from the 3D topology of objects, 
-#             and, second, so as to chain several times the same ViewEdge.
-
-from ChainingIterators import pySketchyChainingIterator
-from freestyle import IncreasingColorShader, IncreasingThicknessShader, Operators, \
-    QuantitativeInvisibilityUP1D, SamplingShader, SmoothingShader, SpatialNoiseShader, \
-    TextureAssignerShader, TrueUP1D
-from shaders import pyBackboneStretcherNoCuspShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-## Chain 3 times each ViewEdge indpendantly from the 
-## initial objects topology
-Operators.bidirectional_chain(pySketchyChainingIterator(3))
-shaders_list = [
-    SamplingShader(4),
-    SpatialNoiseShader(6, 120, 2, True, True),
-    IncreasingThicknessShader(4, 10),
-    SmoothingShader(100, 0.1, 0, 0.2, 0, 0, 0, 1),
-    pyBackboneStretcherNoCuspShader(20),
-    #ConstantColorShader(0.0, 0.0, 0.0)
-    IncreasingColorShader(0.2, 0.2, 0.2, 1, 0.5, 0.5, 0.5, 1),
-    #IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
-    TextureAssignerShader(4),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/sketchy_topology_preserved.py b/release/scripts/freestyle/style_modules/sketchy_topology_preserved.py
deleted file mode 100644
index 25e593b7c99..00000000000
--- a/release/scripts/freestyle/style_modules/sketchy_topology_preserved.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : sketchy_topology_preserved.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : The topology of the strokes is built
-#             so as to chain several times the same ViewEdge.
-#             The topology of the objects is preserved
-
-from ChainingIterators import pySketchyChainSilhouetteIterator
-from freestyle import ConstantColorShader, IncreasingThicknessShader, Operators, \
-    QuantitativeInvisibilityUP1D, SamplingShader, SmoothingShader, SpatialNoiseShader, \
-    TextureAssignerShader, TrueUP1D
-
-upred = QuantitativeInvisibilityUP1D(0)
-Operators.select(upred)
-Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(3, True))
-shaders_list = [
-    SamplingShader(4),
-    SpatialNoiseShader(20, 220, 2, True, True),
-    IncreasingThicknessShader(4, 8),
-    SmoothingShader(300, 0.05, 0, 0.2, 0, 0, 0, 0.5),
-    ConstantColorShader(0.6, 0.2, 0.0),
-    TextureAssignerShader(4),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/split_at_highest_2d_curvatures.py b/release/scripts/freestyle/style_modules/split_at_highest_2d_curvatures.py
deleted file mode 100644
index 474183c3810..00000000000
--- a/release/scripts/freestyle/style_modules/split_at_highest_2d_curvatures.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : split_at_highest_2d_curvature.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws the visible lines (chaining follows same nature lines)
-#             (most basic style module)
-
-from freestyle import ChainSilhouetteIterator, ConstantThicknessShader, IncreasingColorShader, \
-    Operators, QuantitativeInvisibilityUP1D, TextureAssignerShader, TrueUP1D
-from Functions0D import pyInverseCurvature2DAngleF0D
-from PredicatesU0D import pyParameterUP0D
-from PredicatesU1D import pyHigherLengthUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-func = pyInverseCurvature2DAngleF0D()
-Operators.recursive_split(func, pyParameterUP0D(0.4, 0.6), NotUP1D(pyHigherLengthUP1D(100)), 2)
-shaders_list = [
-    ConstantThicknessShader(10),
-    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
-    TextureAssignerShader(3),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/split_at_tvertices.py b/release/scripts/freestyle/style_modules/split_at_tvertices.py
deleted file mode 100644
index 70446e0178e..00000000000
--- a/release/scripts/freestyle/style_modules/split_at_tvertices.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : split_at_tvertices.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws strokes that starts and stops at Tvertices (visible or not)
-
-from freestyle import ChainSilhouetteIterator, ConstantThicknessShader, IncreasingColorShader, \
-    Nature, Operators, QuantitativeInvisibilityUP1D, TextureAssignerShader, TrueUP1D
-from PredicatesU0D import pyVertexNatureUP0D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-start = pyVertexNatureUP0D(Nature.T_VERTEX)
-## use the same predicate to decide where to start and where to stop
-## the strokes:
-Operators.sequential_split(start, start, 10)
-shaders_list = [
-    ConstantThicknessShader(5),
-    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
-    TextureAssignerShader(3),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/stroke_texture.py b/release/scripts/freestyle/style_modules/stroke_texture.py
deleted file mode 100644
index c925633b579..00000000000
--- a/release/scripts/freestyle/style_modules/stroke_texture.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : stroke_texture.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws textured strokes (illustrate the StrokeTextureShader shader)
-
-from freestyle import BezierCurveShader, ChainSilhouetteIterator, ConstantColorShader, \
-    ConstantThicknessShader, Operators, QuantitativeInvisibilityUP1D, SamplingShader, \
-    Stroke, StrokeTextureShader, TrueUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    SamplingShader(3),
-    BezierCurveShader(4),
-    StrokeTextureShader("washbrushAlpha.bmp", Stroke.DRY_MEDIUM, True),
-    ConstantThicknessShader(40),
-    ConstantColorShader(0, 0, 0, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/suggestive.py b/release/scripts/freestyle/style_modules/suggestive.py
deleted file mode 100644
index bb5e20f2a2e..00000000000
--- a/release/scripts/freestyle/style_modules/suggestive.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : suggestive.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Draws the suggestive contours.
-#             ***** The suggestive contours must be enabled
-#             in the options dialog *****
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, IncreasingThicknessShader, \
-    Nature, Operators, QuantitativeInvisibilityUP1D, TrueUP1D
-from PredicatesU1D import pyNatureUP1D
-from logical_operators import AndUP1D, NotUP1D
-
-upred = AndUP1D(pyNatureUP1D(Nature.SUGGESTIVE_CONTOUR), QuantitativeInvisibilityUP1D(0))
-Operators.select(upred)
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
-shaders_list = [
-    IncreasingThicknessShader(1, 3),
-    ConstantColorShader(0.2, 0.2, 0.2, 1),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/thickness_fof_depth_discontinuity.py b/release/scripts/freestyle/style_modules/thickness_fof_depth_discontinuity.py
deleted file mode 100644
index 20c8240b3cd..00000000000
--- a/release/scripts/freestyle/style_modules/thickness_fof_depth_discontinuity.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : thickness_fof_depth_discontinuity.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Assigns to strokes a thickness that depends on the depth discontinuity
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from logical_operators import NotUP1D
-from shaders import pyDepthDiscontinuityThicknessShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    SamplingShader(1),
-    ConstantThicknessShader(3),
-    ConstantColorShader(0.0, 0.0, 0.0),
-    pyDepthDiscontinuityThicknessShader(0.8, 6),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/tipremover.py b/release/scripts/freestyle/style_modules/tipremover.py
deleted file mode 100644
index efcddb7321f..00000000000
--- a/release/scripts/freestyle/style_modules/tipremover.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : tipremover.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Removes strokes extremities
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TipRemoverShader, TrueUP1D
-from logical_operators import NotUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    SamplingShader(5),
-    ConstantThicknessShader(3),
-    ConstantColorShader(0, 0, 0),
-    TipRemoverShader(20),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/tvertex_remover.py b/release/scripts/freestyle/style_modules/tvertex_remover.py
deleted file mode 100644
index 565962c1b0e..00000000000
--- a/release/scripts/freestyle/style_modules/tvertex_remover.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : tvertex_remover.py
-#  Author   : Stephane Grabli
-#  Date     : 04/08/2005
-#  Purpose  : Removes TVertices
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, IncreasingThicknessShader, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
-from logical_operators import NotUP1D
-from shaders import pyTVertexRemoverShader
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
-shaders_list = [
-    IncreasingThicknessShader(3, 5),
-    ConstantColorShader(0.2, 0.2, 0.2, 1),
-    SamplingShader(10.0),
-    pyTVertexRemoverShader(),
-    ]
-Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/uniformpruning_zsort.py b/release/scripts/freestyle/style_modules/uniformpruning_zsort.py
deleted file mode 100644
index efa977ccf5f..00000000000
--- a/release/scripts/freestyle/style_modules/uniformpruning_zsort.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-#  Filename : uniformpruning_zsort.py
-#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
-#  Date     : 08/04/2005
-
-from freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, IntegrationType, \
-    Operators, QuantitativeInvisibilityUP1D, SamplingShader, Stroke, StrokeTextureShader
-from PredicatesB1D import pyZBP1D
-from PredicatesU1D import pyDensityUP1D
-
-Operators.select(QuantitativeInvisibilityUP1D(0))
-Operators.bidirectional_chain(ChainSilhouetteIterator())
-#Operators.sequential_split(pyVertexNatureUP0D(Nature.VIEW_VERTEX), 2)
-Operators.sort(pyZBP1D())
-shaders_list = [
-    StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, False),
-    ConstantThicknessShader(3),
-    SamplingShader(5.0),
-    ConstantColorShader(0, 0, 0, 1),
-    ]
-Operators.create(pyDensityUP1D(2, 0.05, IntegrationType.MEAN, 4), shaders_list)
-#Operators.create(pyDensityFunctorUP1D(8, 0.03, pyGetInverseProjectedZF1D(), 0, 1, IntegrationType.MEAN), shaders_list)