Freestyle Python API improvements - part 4.

Major API updates were made as in part 3 to address code review comments.
This revision focuses on Python wrappers of C++ iterators.

* Most getter/setter methods were reimplemented as attributes using PyGetSetDef.

* The naming of methods and attributes was fixed to follow the naming conventions
of the Blender Python API (i.e., lower case + underscores for methods and attributes,
and CamelCase for classes).  The only irregular naming change is the following, to
better indicate the functionality:

- ChainingIterator: getVertex --> next_vertex

* In addition, some code clean-up was done in both C++ and Python.  Also duplicated
definitions of predicate classes were removed.

8 files changed, 377 insertions, 421 deletions

diff --git a/release/scripts/freestyle/style_modules/ChainingIterators.py b/release/scripts/freestyle/style_modules/ChainingIterators.py
index 20b92d62613..5ef4b9c61dc 100644
--- a/release/scripts/freestyle/style_modules/ChainingIterators.py
+++ b/release/scripts/freestyle/style_modules/ChainingIterators.py
@@ -42,11 +42,11 @@ class pyChainSilhouetteIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
+			mateVE = tvertex.get_mate(self.current_edge)
+			while not it.is_end:
+				ve = it.object
 				if ve.id == mateVE.id:
 					winner = ve
 					break
@@ -55,12 +55,12 @@ class pyChainSilhouetteIterator(ChainingIterator):
 			## 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.getCurrentEdge().nature
+				currentNature = self.current_edge.nature
 				if (natures[i] & currentNature) != 0:
 					count=0
-					while not it.isEnd():
+					while not it.is_end:
 						visitNext = 0
-						oNature = it.getObject().nature
+						oNature = it.object.nature
 						if (oNature & natures[i]) != 0:
 							if natures[i] != oNature:
 								for j in range(i):
@@ -70,7 +70,7 @@ class pyChainSilhouetteIterator(ChainingIterator):
 								if visitNext != 0:
 									break	 
 							count = count+1
-							winner = it.getObject()
+							winner = it.object
 						it.increment()
 					if count != 1:
 						winner = None
@@ -94,11 +94,11 @@ class pyChainSilhouetteGenericIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
+			mateVE = tvertex.get_mate(self.current_edge)
+			while not it.is_end:
+				ve = it.object
 				if ve.id == mateVE.id:
 					winner = ve
 					break
@@ -107,14 +107,14 @@ class pyChainSilhouetteGenericIterator(ChainingIterator):
 			## 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.getCurrentEdge().nature
+				currentNature = self.current_edge.nature
 				if (natures[i] & currentNature) != 0:
 					count=0
-					while not it.isEnd():
+					while not it.is_end:
 						visitNext = 0
-						oNature = it.getObject().nature
-						ve = it.getObject()
-						if ve.id == self.getCurrentEdge().id:
+						oNature = it.object.nature
+						ve = it.object
+						if ve.id == self.current_edge.id:
 							it.increment()
 							continue
 						if (oNature & natures[i]) != 0:
@@ -137,22 +137,19 @@ class pyExternalContourChainingIterator(ChainingIterator):
 	def __init__(self):
 		ChainingIterator.__init__(self, 0, 1,None,1)
 		self._isExternalContour = ExternalContourUP1D()
-		
 	def getExactTypeName(self):
 		return "pyExternalContourIterator"
-	
 	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.isEnd():
-			ave = it.getObject()
+		while not it.is_end:
+			ave = it.object
 			if self._isExternalContour(ave):
 				return 1
 			it.increment()
@@ -161,8 +158,8 @@ class pyExternalContourChainingIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		while not it.isEnd():
-			ve = it.getObject()
+		while not it.is_end:
+			ve = it.object
 			if self._isExternalContour(ve):
 				if ve.time_stamp == GetTimeStampCF():
 					winner = ve
@@ -172,9 +169,9 @@ class pyExternalContourChainingIterator(ChainingIterator):
 		if winner is None:
 			orient = 1
 			it = AdjacencyIterator(iter)
-			while not it.isEnd():
-				ve = it.getObject()
-				if it.isIncoming() != 0: # FIXME
+			while not it.is_end:
+				ve = it.object
+				if it.is_incoming:
 					orient = 0
 				good = self.checkViewEdge(ve,orient)
 				if good != 0:
@@ -196,11 +193,11 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
+			mateVE = tvertex.get_mate(self.current_edge)
+			while not it.is_end:
+				ve = it.object
 				if ve.id == mateVE.id:
 					winner = ve
 					break
@@ -209,14 +206,14 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
 			## 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.getCurrentEdge().nature
+				currentNature = self.current_edge.nature
 				if (natures[i] & currentNature) != 0:
 					count=0
-					while not it.isEnd():
+					while not it.is_end:
 						visitNext = 0
-						oNature = it.getObject().nature
-						ve = it.getObject()
-						if ve.id == self.getCurrentEdge().id:
+						oNature = it.object.nature
+						ve = it.object
+						if ve.id == self.current_edge.id:
 							it.increment()
 							continue
 						if (oNature & natures[i]) != 0:
@@ -234,7 +231,7 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
 						winner = None
 					break
 		if winner is None:
-			winner = self.getCurrentEdge()
+			winner = self.current_edge
 		if winner.chaining_time_stamp == self._timeStamp:
 			winner = None
 		return winner
@@ -250,22 +247,20 @@ class pySketchyChainingIterator(ChainingIterator):
 		self._nRounds = nRounds
 	def getExactTypeName(self):
 		return "pySketchyChainingIterator"
-
 	def init(self):
 		self._timeStamp = GetTimeStampCF()+self._nRounds
-
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		while not it.isEnd():
-			ve = it.getObject()
-			if ve.id == self.getCurrentEdge().id:
+		while not it.is_end:
+			ve = it.object
+			if ve.id == self.current_edge.id:
 				it.increment()
 				continue
 			winner = ve
 			it.increment()
 		if winner is None:
-			winner = self.getCurrentEdge()
+			winner = self.current_edge
 		if winner.chaining_time_stamp == self._timeStamp:
 			return None
 		return winner
@@ -290,16 +285,16 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		winnerOrientation = 0
-		print(self.getCurrentEdge().id.first, self.getCurrentEdge().id.second)
+		print(self.current_edge.id.first, self.current_edge.id.second)
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
+			mateVE = tvertex.get_mate(self.current_edge)
+			while not it.is_end:
+				ve = it.object
 				if ve.id == mateVE.id:
 					winner = ve
-					if it.isIncoming() == 0: # FIXME
+					if not it.is_incoming:
 						winnerOrientation = 1
 					else:
 						winnerOrientation = 0
@@ -309,14 +304,14 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
 			## case of NonTVertex
 			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
 			for nat in natures:
-				if (self.getCurrentEdge().nature & nat) != 0:
+				if (self.current_edge.nature & nat) != 0:
 					count=0
-					while not it.isEnd():
-						ve = it.getObject()
+					while not it.is_end:
+						ve = it.object
 						if (ve.nature & nat) != 0:
 							count = count+1
 							winner = ve
-							if it.isIncoming() == 0: # FIXME
+							if not it.is_incoming:
 								winnerOrientation = 1
 							else:
 								winnerOrientation = 0
@@ -335,24 +330,24 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
 				if self._length == 0:
 					#if not, let's do it
 					_it = pyChainSilhouetteGenericIterator(0,0)
-					_it.setBegin(winner)
-					_it.setCurrentEdge(winner)
-					_it.setOrientation(winnerOrientation)
+					_it.begin = winner
+					_it.current_edge = winner
+					_it.orientation = winnerOrientation
 					_it.init()
-					while not _it.isEnd():
-						ve = _it.getObject()
+					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.isBegin():
+						if _it.is_begin:
 							break;
-					_it.setBegin(winner)
-					_it.setCurrentEdge(winner)
-					_it.setOrientation(winnerOrientation)
-					if not _it.isBegin():
+					_it.begin = winner
+					_it.current_edge = winner
+					_it.orientation = winnerOrientation
+					if not _it.is_begin:
 						_it.decrement()
-						while (not _it.isEnd()) and (not _it.isBegin()):
-							ve = _it.getObject()
+						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()
@@ -361,12 +356,12 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
 				# nw let's compute the length of this connex non selected part:
 				connexl = 0
 				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.setBegin(winner)
-				_cit.setCurrentEdge(winner)
-				_cit.setOrientation(winnerOrientation)
+				_cit.begin = winner
+				_cit.current_edge = winner
+				_cit.orientation = winnerOrientation
 				_cit.init()
-				while _cit.isEnd() == 0 and _cit.getObject().time_stamp != GetTimeStampCF():
-					ve = _cit.getObject()
+				while _cit.is_end == 0 and _cit.object.time_stamp != GetTimeStampCF():
+					ve = _cit.object
 					#print("-------- --------", ve.id.first, ve.id.second)
 					connexl = connexl + ve.length_2d
 					_cit.increment()
@@ -389,16 +384,16 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		winnerOrientation = 0
-		#print(self.getCurrentEdge().id.first, self.getCurrentEdge().id.second)
+		#print(self.current_edge.id.first, self.current_edge.id.second)
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
+			mateVE = tvertex.get_mate(self.current_edge)
+			while not it.is_end:
+				ve = it.object
 				if ve.id == mateVE.id:
 					winner = ve
-					if it.isIncoming() == 0: # FIXME
+					if not it.is_incoming:
 						winnerOrientation = 1
 					else:
 						winnerOrientation = 0
@@ -408,14 +403,14 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
 			## case of NonTVertex
 			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
 			for nat in natures:
-				if (self.getCurrentEdge().nature & nat) != 0:
+				if (self.current_edge.nature & nat) != 0:
 					count=0
-					while not it.isEnd():
-						ve = it.getObject()
+					while not it.is_end:
+						ve = it.object
 						if (ve.nature & nat) != 0:
 							count = count+1
 							winner = ve
-							if it.isIncoming() == 0: # FIXME
+							if not it.is_incoming:
 								winnerOrientation = 1
 							else:
 								winnerOrientation = 0
@@ -430,12 +425,12 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
 				# nw let's compute the length of this connex non selected part:
 				connexl = 0
 				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.setBegin(winner)
-				_cit.setCurrentEdge(winner)
-				_cit.setOrientation(winnerOrientation)
+				_cit.begin = winner
+				_cit.current_edge = winner
+				_cit.orientation = winnerOrientation
 				_cit.init()
-				while _cit.isEnd() == 0 and _cit.getObject().time_stamp != GetTimeStampCF():
-					ve = _cit.getObject()
+				while _cit.is_end == 0 and _cit.object.time_stamp != GetTimeStampCF():
+					ve = _cit.object
 					#print("-------- --------", ve.id.first, ve.id.second)
 					connexl = connexl + ve.length_2d
 					_cit.increment()
@@ -464,16 +459,16 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		winnerOrientation = 0
-		print(self.getCurrentEdge().id.first, self.getCurrentEdge().id.second)
+		print(self.current_edge.id.first, self.current_edge.id.second)
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
+			mateVE = tvertex.get_mate(self.current_edge)
+			while not it.is_end:
+				ve = it.object
 				if ve.id == mateVE.id:
 					winner = ve
-					if it.isIncoming() == 0: # FIXME
+					if not it.is_incoming:
 						winnerOrientation = 1
 					else:
 						winnerOrientation = 0
@@ -483,14 +478,14 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
 			## case of NonTVertex
 			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
 			for nat in natures:
-				if (self.getCurrentEdge().nature & nat) != 0:
+				if (self.current_edge.nature & nat) != 0:
 					count=0
-					while not it.isEnd():
-						ve = it.getObject()
+					while not it.is_end:
+						ve = it.object
 						if (ve.nature & nat) != 0:
 							count = count+1
 							winner = ve
-							if it.isIncoming() == 0: # FIXME
+							if not it.is_incoming:
 								winnerOrientation = 1
 							else:
 								winnerOrientation = 0
@@ -509,24 +504,24 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
 				if self._length == 0:
 					#if not, let's do it
 					_it = pyChainSilhouetteGenericIterator(0,0)
-					_it.setBegin(winner)
-					_it.setCurrentEdge(winner)
-					_it.setOrientation(winnerOrientation)
+					_it.begin = winner
+					_it.current_edge = winner
+					_it.orientation = winnerOrientation
 					_it.init()
-					while not _it.isEnd():
-						ve = _it.getObject()
+					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.isBegin():
+						if _it.is_begin:
 							break;
-					_it.setBegin(winner)
-					_it.setCurrentEdge(winner)
-					_it.setOrientation(winnerOrientation)
-					if not _it.isBegin():
+					_it.begin = winner
+					_it.current_edge = winner
+					_it.orientation = winnerOrientation
+					if not _it.is_begin:
 						_it.decrement()
-						while (not _it.isEnd()) and (not _it.isBegin()):
-							ve = _it.getObject()
+						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()
@@ -535,12 +530,12 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
 				# nw let's compute the length of this connex non selected part:
 				connexl = 0
 				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.setBegin(winner)
-				_cit.setCurrentEdge(winner)
-				_cit.setOrientation(winnerOrientation)
+				_cit.begin = winner
+				_cit.current_edge = winner
+				_cit.orientation = winnerOrientation
 				_cit.init()
-				while _cit.isEnd() == 0 and _cit.getObject().time_stamp != GetTimeStampCF():
-					ve = _cit.getObject()
+				while _cit.is_end == 0 and _cit.object.time_stamp != GetTimeStampCF():
+					ve = _cit.object
 					#print("-------- --------", ve.id.first, ve.id.second)
 					connexl = connexl + ve.length_2d
 					_cit.increment()
@@ -569,16 +564,16 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		winnerOrientation = 0
-		print(self.getCurrentEdge().id.first, self.getCurrentEdge().id.second)
+		print(self.current_edge.id.first, self.current_edge.id.second)
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
+			mateVE = tvertex.get_mate(self.current_edge)
+			while not it.is_end:
+				ve = it.object
 				if ve.id == mateVE.id:
 					winner = ve
-					if it.isIncoming() == 0: # FIXME
+					if not it.is_incoming:
 						winnerOrientation = 1
 					else:
 						winnerOrientation = 0
@@ -588,14 +583,14 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
 			## case of NonTVertex
 			natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
 			for nat in natures:
-				if (self.getCurrentEdge().nature & nat) != 0:
+				if (self.current_edge.nature & nat) != 0:
 					count=0
-					while not it.isEnd():
-						ve = it.getObject()
+					while not it.is_end:
+						ve = it.object
 						if (ve.nature & nat) != 0:
 							count = count+1
 							winner = ve
-							if it.isIncoming() == 0: # FIXME
+							if not it.is_incoming:
 								winnerOrientation = 1
 							else:
 								winnerOrientation = 0
@@ -614,24 +609,24 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
 				if self._length == 0:
 					#if not, let's do it
 					_it = pyChainSilhouetteGenericIterator(0,0)
-					_it.setBegin(winner)
-					_it.setCurrentEdge(winner)
-					_it.setOrientation(winnerOrientation)
+					_it.begin = winner
+					_it.current_edge = winner
+					_it.orientation = winnerOrientation
 					_it.init()
-					while not _it.isEnd():
-						ve = _it.getObject()
+					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.isBegin():
+						if _it.is_begin:
 							break;
-					_it.setBegin(winner)
-					_it.setCurrentEdge(winner)
-					_it.setOrientation(winnerOrientation)
-					if not _it.isBegin():
+					_it.begin = winner
+					_it.current_edge = winner
+					_it.orientation = winnerOrientation
+					if not _it.is_begin:
 						_it.decrement()
-						while (not _it.isEnd()) and (not _it.isBegin()):
-							ve = _it.getObject()
+						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()
@@ -640,12 +635,12 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
 				# nw let's compute the length of this connex non selected part:
 				connexl = 0
 				_cit = pyChainSilhouetteGenericIterator(0,0)
-				_cit.setBegin(winner)
-				_cit.setCurrentEdge(winner)
-				_cit.setOrientation(winnerOrientation)
+				_cit.begin = winner
+				_cit.current_edge = winner
+				_cit.orientation = winnerOrientation
 				_cit.init()
-				while not _cit.isEnd() and _cit.getObject().qi != 0:
-					ve = _cit.getObject()
+				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()
@@ -669,33 +664,33 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator):
 	def traverse(self, iter):
 		winner = None
 		it = AdjacencyIterator(iter)
-		tvertex = self.getVertex()
+		tvertex = self.next_vertex
 		if type(tvertex) is TVertex:
-			mateVE = tvertex.get_mate(self.getCurrentEdge())
-			while not it.isEnd():
-				ve = it.getObject()
-				feB = self.getCurrentEdge().last_fedge
+			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.getCurrentEdge().first_fedge
+				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.getCurrentEdge().last_fedge
+				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.getCurrentEdge().first_fedge
+				feA = self.current_edge.first_fedge
 				feB = ve.first_fedge
 				vB = feB.first_svertex
 				vA = feA.first_svertex
@@ -707,12 +702,12 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator):
 			## 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.getCurrentEdge().nature
+				currentNature = self.current_edge.nature
 				if (natures[i] & currentNature) != 0:
 					count=0
-					while not it.isEnd():
+					while not it.is_end:
 						visitNext = 0
-						oNature = it.getObject().nature
+						oNature = it.object.nature
 						if (oNature & natures[i]) != 0:
 							if natures[i] != oNature:
 								for j in range(i):
@@ -722,7 +717,7 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator):
 								if visitNext != 0:
 									break	 
 							count = count+1
-							winner = it.getObject()
+							winner = it.object
 						it.increment()
 					if count != 1:
 						winner = None
diff --git a/release/scripts/freestyle/style_modules/Functions0D.py b/release/scripts/freestyle/style_modules/Functions0D.py
index 90e7765d505..2cd852180f8 100644
--- a/release/scripts/freestyle/style_modules/Functions0D.py
+++ b/release/scripts/freestyle/style_modules/Functions0D.py
@@ -6,7 +6,7 @@ class CurveMaterialF0D(UnaryFunction0DMaterial):
 	def getName(self):
 		return "CurveMaterialF0D"
 	def __call__(self, inter):
-		cp = inter.getObject()
+		cp = inter.object
 		assert(isinstance(cp, CurvePoint))
 		fe = cp.first_svertex.get_fedge(cp.second_svertex)
 		assert(fe is not None)
@@ -26,7 +26,7 @@ class pyCurvilinearLengthF0D(UnaryFunction0DDouble):
 		return "CurvilinearLengthF0D"
 
 	def __call__(self, inter):
-		cp = inter.getObject()		
+		cp = inter.object		
 		assert(isinstance(cp, CurvePoint))
 		return cp.t2d
 
@@ -66,7 +66,7 @@ class pyViewMapGradientVectorF0D(UnaryFunction0DVec2f):
 	def getName(self):
 		return "pyViewMapGradientVectorF0D"
 	def __call__(self, iter):
-		p = iter.getObject().point_2d
+		p = iter.object.point_2d
 		gx = ReadCompleteViewMapPixelCF(self._l, int(p.x+self._step), int(p.y))- ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y))
 		gy = ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y))
 		return Vector([gx, gy])
@@ -79,7 +79,7 @@ class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
 	def getName(self):
 		return "pyViewMapGradientNormF0D"
 	def __call__(self, iter):
-		p = iter.getObject().point_2d
+		p = iter.object.point_2d
 		gx = ReadCompleteViewMapPixelCF(self._l, int(p.x+self._step), int(p.y))- ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y))
 		gy = ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x), int(p.y))
 		grad = Vector([gx, gy])
diff --git a/release/scripts/freestyle/style_modules/PredicatesU0D.py b/release/scripts/freestyle/style_modules/PredicatesU0D.py
index 0f7f1925624..1f657235d99 100644
--- a/release/scripts/freestyle/style_modules/PredicatesU0D.py
+++ b/release/scripts/freestyle/style_modules/PredicatesU0D.py
@@ -31,7 +31,7 @@ class pyVertexNatureUP0D(UnaryPredicate0D):
 	def getName(self):
 		return "pyVertexNatureUP0D"
 	def __call__(self, inter):
-		v = inter.getObject()
+		v = inter.object
 		return (v.nature & self._nature) != 0
 
 ## check whether an Interface0DIterator
@@ -44,14 +44,11 @@ class pyBackTVertexUP0D(UnaryPredicate0D):
 	def getName(self):
 		return "pyBackTVertexUP0D"
 	def __call__(self, iter):
-		v = iter.getObject()
-		nat = v.nature
-		if (nat & Nature.T_VERTEX) == 0:
+		if (iter.object.nature & Nature.T_VERTEX) == 0:
 			return 0
-		next = iter
-		if next.isEnd():
+		if iter.is_end:
 			return 0
-		if self._getQI(next) != 0:
+		if self._getQI(iter) != 0:
 			return 1
 		return 0
 
@@ -65,7 +62,7 @@ class pyParameterUP0DGoodOne(UnaryPredicate0D):
 		return "pyCurvilinearAbscissaHigherThanUP0D"
 	def __call__(self, inter):
 		#s = self.getCurvilinearAbscissa(inter)
-		u = inter.u() # FIXME
+		u = inter.u
 		#print(u)
 		return ((u>=self._m) and (u<=self._M))
 
@@ -82,7 +79,7 @@ class pyParameterUP0D(UnaryPredicate0D):
 		c = func(inter)
 		b1 = (c>0.1)
 		#s = self.getCurvilinearAbscissa(inter)
-		u = inter.u() # FIXME
+		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
index 73c35d542b3..3938bbb2d02 100644
--- a/release/scripts/freestyle/style_modules/PredicatesU1D.py
+++ b/release/scripts/freestyle/style_modules/PredicatesU1D.py
@@ -45,7 +45,7 @@ class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
 		count = 0
 		func = Curvature2DAngleF0D()
 		it = inter.vertices_begin()
-		while not it.isEnd():
+		while not it.is_end:
 			if func(it) > self._a:
 				count = count+1
 			if count > self._n:
@@ -198,14 +198,14 @@ class pyIsOccludedByUP1D(UnaryPredicate1D):
 		it = inter.vertices_begin()
 		itlast = inter.vertices_end()
 		itlast.decrement()
-		v =  it.getObject()
-		vlast = itlast.getObject()
+		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.isEnd():
-				ve, incoming = eit.getObject()
+			while not eit.is_end:
+				ve, incoming = eit.object
 				if ve.id == self._id:
 					return 1
 				print("-------", ve.id.first, "-", ve.id.second)
@@ -214,8 +214,8 @@ class pyIsOccludedByUP1D(UnaryPredicate1D):
 		if type(tvertex) is TVertex:
 			print("TVertex: [ ", tvertex.id.first, ",",  tvertex.id.second," ]")
 			eit = tvertex.edges_begin()
-			while not eit.isEnd():
-				ve, incoming = eit.getObject()
+			while not eit.is_end:
+				ve, incoming = eit.object
 				if ve.id == self._id:
 					return 1
 				print("-------", ve.id.first, "-", ve.id.second)
@@ -349,8 +349,8 @@ class pyClosedCurveUP1D(UnaryPredicate1D):
 		it = inter.vertices_begin()
 		itlast = inter.vertices_end()
 		itlast.decrement()	
-		vlast = itlast.getObject()
-		v = it.getObject()
+		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:
diff --git a/release/scripts/freestyle/style_modules/parameter_editor.py b/release/scripts/freestyle/style_modules/parameter_editor.py
index e297a913e53..75a948b8623 100644
--- a/release/scripts/freestyle/style_modules/parameter_editor.py
+++ b/release/scripts/freestyle/style_modules/parameter_editor.py
@@ -159,8 +159,8 @@ class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
         return "BaseThicknessShader"
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
-        while it.isEnd() == 0:
-            sv = it.getObject()
+        while not it.is_end:
+            sv = it.object
             self.set_thickness(sv, self.__outer, self.__inner)
             it.increment()
 
@@ -170,9 +170,9 @@ def iter_t2d_along_stroke(stroke):
     total = stroke.length_2d
     distance = 0.0
     it = stroke.stroke_vertices_begin()
-    while not it.isEnd():
-        p = it.getObject().point
-        if not it.isBegin():
+    while not it.is_end:
+        p = it.object.point
+        if not it.is_begin:
             distance += (prev - p).length
         prev = p
         t = min(distance / total, 1.0)
@@ -184,7 +184,7 @@ class ColorAlongStrokeShader(ColorRampModifier):
         return "ColorAlongStrokeShader"
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
-            sv = it.getObject()
+            sv = it.object
             a = sv.attribute.color
             b = self.evaluate(t)
             sv.attribute.color = self.blend_ramp(a, b)
@@ -194,7 +194,7 @@ class AlphaAlongStrokeShader(CurveMappingModifier):
         return "AlphaAlongStrokeShader"
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
-            sv = it.getObject()
+            sv = it.object
             a = sv.attribute.alpha
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
@@ -210,7 +210,7 @@ class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
         return "ThicknessAlongStrokeShader"
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
-            sv = it.getObject()
+            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)
@@ -221,8 +221,8 @@ class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
 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.isEnd():
-        p = it.getObject().point_3d # in the camera coordinate
+    while not it.is_end:
+        p = it.object.point_3d # in the camera coordinate
         distance = p.length
         if distance < range_min:
             t = 0.0
@@ -242,7 +242,7 @@ class ColorDistanceFromCameraShader(ColorRampModifier):
         return "ColorDistanceFromCameraShader"
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
-            sv = it.getObject()
+            sv = it.object
             a = sv.attribute.color
             b = self.evaluate(t)
             sv.attribute.color = self.blend_ramp(a, b)
@@ -256,7 +256,7 @@ class AlphaDistanceFromCameraShader(CurveMappingModifier):
         return "AlphaDistanceFromCameraShader"
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
-            sv = it.getObject()
+            sv = it.object
             a = sv.attribute.alpha
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
@@ -274,7 +274,7 @@ class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModif
         return "ThicknessDistanceFromCameraShader"
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
-            sv = it.getObject()
+            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)
@@ -289,8 +289,8 @@ def iter_distance_from_object(stroke, object, range_min, range_max):
     loc = mv * object.location # loc in the camera coordinate
     normfac = range_max - range_min # normalization factor
     it = stroke.stroke_vertices_begin()
-    while not it.isEnd():
-        p = it.getObject().point_3d # in the camera coordinate
+    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
@@ -313,7 +313,7 @@ class ColorDistanceFromObjectShader(ColorRampModifier):
         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.getObject()
+            sv = it.object
             a = sv.attribute.color
             b = self.evaluate(t)
             sv.attribute.color = self.blend_ramp(a, b)
@@ -330,7 +330,7 @@ class AlphaDistanceFromObjectShader(CurveMappingModifier):
         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.getObject()
+            sv = it.object
             a = sv.attribute.alpha
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
@@ -351,7 +351,7 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
         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.getObject()
+            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)
@@ -362,8 +362,8 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
 def iter_material_color(stroke, material_attr):
     func = CurveMaterialF0D()
     it = stroke.stroke_vertices_begin()
-    while not it.isEnd():
-        material = func(it.castToInterface0DIterator())
+    while not it.is_end:
+        material = func(it.cast_to_interface0diterator())
         if material_attr == "DIFF":
             color = (material.diffuse[0],
                      material.diffuse[1],
@@ -380,8 +380,8 @@ def iter_material_color(stroke, material_attr):
 def iter_material_value(stroke, material_attr):
     func = CurveMaterialF0D()
     it = stroke.stroke_vertices_begin()
-    while not it.isEnd():
-        material = func(it.castToInterface0DIterator())
+    while not it.is_end:
+        material = func(it.cast_to_interface0diterator())
         if material_attr == "DIFF":
             r = material.diffuse[0]
             g = material.diffuse[1]
@@ -423,12 +423,12 @@ class ColorMaterialShader(ColorRampModifier):
     def shade(self, stroke):
         if self.__material_attr in ["DIFF", "SPEC"] and not self.__use_ramp:
             for it, b in iter_material_color(stroke, self.__material_attr):
-                sv = it.getObject()
+                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_attr):
-                sv = it.getObject()
+                sv = it.object
                 a = sv.attribute.color
                 b = self.evaluate(t)
                 sv.attribute.color = self.blend_ramp(a, b)
@@ -441,7 +441,7 @@ class AlphaMaterialShader(CurveMappingModifier):
         return "AlphaMaterialShader"
     def shade(self, stroke):
         for it, t in iter_material_value(stroke, self.__material_attr):
-            sv = it.getObject()
+            sv = it.object
             a = sv.attribute.alpha
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
@@ -458,7 +458,7 @@ class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
         return "ThicknessMaterialShader"
     def shade(self, stroke):
         for it, t in iter_material_value(stroke, self.__material_attr):
-            sv = it.getObject()
+            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)
@@ -477,12 +477,12 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
     def shade(self, stroke):
         func = VertexOrientation2DF0D()
         it = stroke.stroke_vertices_begin()
-        while not it.isEnd():
-            dir = func(it.castToInterface0DIterator())
+        while not it.is_end:
+            dir = func(it.cast_to_interface0diterator())
             orthDir = mathutils.Vector((-dir.y, dir.x))
             orthDir.normalize()
             fac = abs(orthDir * self.__orientation)
-            sv = it.getObject()
+            sv = it.object
             a = sv.attribute.thickness
             b = self.__min_thickness + fac * (self.__max_thickness - self.__min_thickness)
             b = max(b, 0.0)
@@ -495,9 +495,9 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
 def iter_distance_along_stroke(stroke):
     distance = 0.0
     it = stroke.stroke_vertices_begin()
-    while not it.isEnd():
-        p = it.getObject().point
-        if not it.isBegin():
+    while not it.is_end:
+        p = it.object.point
+        if not it.is_begin:
             distance += (prev - p).length
         prev = p
         yield it, distance
@@ -514,8 +514,8 @@ class SinusDisplacementShader(StrokeShader):
         return "SinusDisplacementShader"
     def shade(self, stroke):
         for it, distance in iter_distance_along_stroke(stroke):
-            v = it.getObject()
-            n = self._getNormal(it.castToInterface0DIterator())
+            v = it.object
+            n = self._getNormal(it.cast_to_interface0diterator())
             n = n * self._amplitude * math.cos(distance / self._wavelength * 2 * math.pi + self._phase)
             v.point = v.point + n
         stroke.update_length()
@@ -533,8 +533,8 @@ class PerlinNoise1DShader(StrokeShader):
     def shade(self, stroke):
         length = stroke.length_2d
         it = stroke.stroke_vertices_begin()
-        while not it.isEnd():
-            v = it.getObject()
+        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()
@@ -552,8 +552,8 @@ class PerlinNoise2DShader(StrokeShader):
         return "PerlinNoise2DShader"
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
-        while not it.isEnd():
-            v = it.getObject()
+        while not it.is_end:
+            v = it.object
             vec = 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
@@ -571,11 +571,11 @@ class Offset2DShader(StrokeShader):
         return "Offset2DShader"
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
-        while not it.isEnd():
-            v = it.getObject()
+        while not it.is_end:
+            v = it.object
             u = v.u
             a = self.__start + u * (self.__end - self.__start)
-            n = self.__getNormal(it.castToInterface0DIterator())
+            n = self.__getNormal(it.cast_to_interface0diterator())
             n = n * a
             v.point = v.point + n + self.__xy
             it.increment()
@@ -597,17 +597,17 @@ class Transform2DShader(StrokeShader):
         # determine the pivot of scaling and rotation operations
         if self.__pivot == "START":
             it = stroke.stroke_vertices_begin()
-            pivot = it.getObject().point
+            pivot = it.object.point
         elif self.__pivot == "END":
             it = stroke.stroke_vertices_end()
             it.decrement()
-            pivot = it.getObject().point
+            pivot = it.object.point
         elif self.__pivot == "PARAM":
             p = None
             it = stroke.stroke_vertices_begin()
-            while not it.isEnd():
+            while not it.is_end:
                 prev = p
-                v = it.getObject()
+                v = it.object
                 p = v.point
                 u = v.u
                 if self.__pivot_u < u:
@@ -622,8 +622,8 @@ class Transform2DShader(StrokeShader):
             pivot = Vector([0.0, 0.0])
             n = 0
             it = stroke.stroke_vertices_begin()
-            while not it.isEnd():
-                p = it.getObject().point
+            while not it.is_end:
+                p = it.object.point
                 pivot = pivot + p
                 n = n + 1
                 it.increment()
@@ -635,8 +635,8 @@ class Transform2DShader(StrokeShader):
         cos_theta = math.cos(self.__angle)
         sin_theta = math.sin(self.__angle)
         it = stroke.stroke_vertices_begin()
-        while not it.isEnd():
-            v = it.getObject()
+        while not it.is_end:
+            v = it.object
             p = v.point
             p = p - pivot
             x = p.x * self.__scale_x
@@ -687,8 +687,8 @@ class ObjectNamesUP1D(UnaryPredicate1D):
 def iter_stroke_vertices(stroke):
     it = stroke.stroke_vertices_begin()
     prev_p = None
-    while not it.isEnd():
-        sv = it.getObject()
+    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
@@ -848,8 +848,8 @@ class DashedLineShader(StrokeShader):
         visible = True
         sampling = 1.0
         it = stroke.stroke_vertices_begin(sampling)
-        while not it.isEnd():
-            pos = it.t()
+        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
@@ -860,7 +860,7 @@ class DashedLineShader(StrokeShader):
                 if index == len(self._pattern):
                     index = 0
                 visible = not visible
-            it.getObject().attribute.visible = visible
+            it.object.attribute.visible = visible
             it.increment()
 
 # predicates for chaining
@@ -955,17 +955,17 @@ class MaterialBoundaryUP0D(UnaryPredicate0D):
     def getName(self):
         return "MaterialBoundaryUP0D"
     def __call__(self, it):
-        if it.isBegin():
+        if it.is_begin:
             return False
         it_prev = Interface0DIterator(it) 
         it_prev.decrement()
-        v = it.getObject()
+        v = it.object
         it.increment()
-        if it.isEnd():
+        if it.is_end:
             return False
-        fe = v.get_fedge(it_prev.getObject())
+        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.getObject())
+        fe = v.get_fedge(it.object)
         idx2 = fe.material_index if fe.is_smooth else fe.material_index_left
         return idx1 != idx2
 
@@ -993,7 +993,7 @@ class Length2DThresholdUP0D(UnaryPredicate0D):
     def getName(self):
         return "Length2DThresholdUP0D"
     def __call__(self, inter):
-        t = inter.t() # curvilinear abscissa
+        t = inter.t # curvilinear abscissa
         if t < self._t:
             self._t = 0.0
             return False
diff --git a/release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py b/release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py
index 53fa03103aa..d72a3730e25 100644
--- a/release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py
+++ b/release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py
@@ -33,24 +33,6 @@ from PredicatesU1D import *
 from PredicatesU0D import *
 from Functions0D import *
 
-## Predicate to tell whether a TVertex
-## corresponds to a change from 0 to 1 or not.
-class pyBackTVertexUP0D(UnaryPredicate0D):
-	def __init__(self):
-		UnaryPredicate0D.__init__(self)
-		self._getQI = QuantitativeInvisibilityF0D()
-	def getName(self):
-		return "pyBackTVertexUP0D"
-	def __call__(self, iter):
-		v = iter.getObject()
-		nat = v.getNature()
-		if(nat & Nature.T_VERTEX == 0):
-			return 0
-		if(self._getQI(iter) != 0):
-			return 1
-		return 0
-
-
 upred = QuantitativeInvisibilityUP1D(0)
 Operators.select(upred)
 Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
diff --git a/release/scripts/freestyle/style_modules/shaders.py b/release/scripts/freestyle/style_modules/shaders.py
index bd682336462..7a363e3273f 100644
--- a/release/scripts/freestyle/style_modules/shaders.py
+++ b/release/scripts/freestyle/style_modules/shaders.py
@@ -24,10 +24,10 @@ class pyDepthDiscontinuityThicknessShader(StrokeShader):
 		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.isEnd():
-			z = self.__func(it.castToInterface0DIterator())
+		while not it.is_end:
+			z = self.__func(it.cast_to_interface0diterator())
 			thickness = a*z+b
-			it.getObject().attribute.thickness = (thickness, thickness)
+			it.object.attribute.thickness = (thickness, thickness)
 			it.increment()
 
 class pyConstantThicknessShader(StrokeShader):
@@ -38,9 +38,9 @@ class pyConstantThicknessShader(StrokeShader):
 		return "pyConstantThicknessShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
+		while not it.is_end:
 			t = self._thickness/2.0
-			it.getObject().attribute.thickness = (t, t)
+			it.object.attribute.thickness = (t, t)
 			it.increment()
 
 class pyFXSThicknessShader(StrokeShader):
@@ -51,9 +51,9 @@ class pyFXSThicknessShader(StrokeShader):
 		return "pyFXSThicknessShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
+		while not it.is_end:
 			t = self._thickness/2.0
-			it.getObject().attribute.thickness = (t, t)
+			it.object.attribute.thickness = (t, t)
 			it.increment()
 
 class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
@@ -71,8 +71,8 @@ class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
 		i = 0
 		it = stroke.stroke_vertices_begin()
 		func = DensityF0D(self.wsize)
-		while not it.isEnd():
-			toto = it.castToInterface0DIterator()
+		while not it.is_end:
+			toto = it.cast_to_interface0diterator()
 			c= func(toto)
 			if c < self.threshold_min:
 				c = self.threshold_min
@@ -80,7 +80,7 @@ class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
 				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.getObject().attribute.thickness = (t/2.0, t/2.0)
+			it.object.attribute.thickness = (t/2.0, t/2.0)
 			i = i+1
 			it.increment()
 
@@ -95,13 +95,13 @@ class pyIncreasingThicknessShader(StrokeShader):
 		n = stroke.stroke_vertices_size()
 		i = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
+		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.getObject().attribute.thickness = (t/2.0, t/2.0)
+			it.object.attribute.thickness = (t/2.0, t/2.0)
 			i = i+1
 			it.increment()
 
@@ -124,8 +124,8 @@ class pyConstrainedIncreasingThicknessShader(StrokeShader):
 		n = stroke.stroke_vertices_size()
 		i = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			att = it.getObject().attribute
+		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
@@ -155,10 +155,10 @@ class pyDecreasingThicknessShader(StrokeShader):
 		n = stroke.stroke_vertices_size()
 		i = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
+		while not it.is_end:
 			c = float(i)/float(n)
 			t = (1.0 - c)*tMax +c*tMin
-			it.getObject().attribute.thickness = (t/2.0, t/2.0)
+			it.object.attribute.thickness = (t/2.0, t/2.0)
 			i = i+1
 			it.increment()
 
@@ -178,14 +178,14 @@ class pyNonLinearVaryingThicknessShader(StrokeShader):
 		n = stroke.stroke_vertices_size()
 		i = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
+		while not it.is_end:
 			if i < float(n)/2.0:
 				c = float(i)/float(n)
 			else:
 				c = float(n-i)/float(n)
 			c = smoothC(c, self._exponent)
 			t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin
-			it.getObject().attribute.thickness = (t/2.0, t/2.0)
+			it.object.attribute.thickness = (t/2.0, t/2.0)
 			i = i+1
 			it.increment()
 
@@ -207,13 +207,13 @@ class pySLERPThicknessShader(StrokeShader):
 		n = stroke.stroke_vertices_size()
 		i = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
+		while not it.is_end:
 			c = float(i)/float(n)
 			if i < float(n)/2.0:
 				t = sin((1-c)*self._omega)/sinh(self._omega)*self._thicknessMin + sin(c*self._omega)/sinh(self._omega) * maxT
 			else:
 				t = sin((1-c)*self._omega)/sinh(self._omega)*maxT + sin(c*self._omega)/sinh(self._omega) * self._thicknessMin
-			it.getObject().attribute.thickness = (t/2.0, t/2.0)
+			it.object.attribute.thickness = (t/2.0, t/2.0)
 			i = i+1
 			it.increment()
 
@@ -227,39 +227,39 @@ class pyTVertexThickenerShader(StrokeShader): ## FIXME
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
 		predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)
-		while not it.isEnd():
+		while not it.is_end:
 			if predTVertex(it) == 1:
 				it2 = StrokeVertexIterator(it)
 				it2.increment()
-				if not (it.isBegin() or it2.isEnd()):
+				if not (it.is_begin or it2.is_end):
 					it.increment()
 					continue
 				n = self._n
 				a = self._a
-				if it.isBegin():
+				if it.is_begin:
 					it3 = StrokeVertexIterator(it)
 					count = 0
-					while (not it3.isEnd()) and count < n:
-						att = it3.getObject().attribute
+					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.isEnd():
+				if it2.is_end:
 					it4 = StrokeVertexIterator(it)
 					count = 0
-					while (not it4.isBegin()) and count < n:
-						att = it4.getObject().attribute
+					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.isBegin():
-						att = it4.getObject().attribute
+					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
@@ -279,8 +279,8 @@ class pyImportance2DThicknessShader(StrokeShader):
 	def shade(self, stroke):
 		origin = Vector([self._x, self._y])
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			v = it.getObject()
+		while not it.is_end:
+			v = it.object
 			p = Vector([v.projected_x, v.projected_y])
 			d = (p-origin).length
 			if d > self._w:
@@ -306,8 +306,8 @@ class pyImportance3DThicknessShader(StrokeShader):
 	def shade(self, stroke):
 		origin = Vector([self._x, self._y, self._z])
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			v = it.getObject()
+		while not it.is_end:
+			v = it.object
 			p = v.point_3d
 			d = (p-origin).length
 			if d > self._w:
@@ -331,8 +331,8 @@ class pyZDependingThicknessShader(StrokeShader):
 		it = stroke.stroke_vertices_begin()
 		z_min = 1
 		z_max = 0
-		while not it.isEnd():
-			z = self.__func(it.castToInterface0DIterator())
+		while not it.is_end:
+			z = self.__func(it.cast_to_interface0diterator())
 			if z < z_min:
 				z_min = z
 			if z > z_max:
@@ -340,10 +340,10 @@ class pyZDependingThicknessShader(StrokeShader):
 			it.increment()
 		z_diff = 1 / (z_max - z_min)
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			z = (self.__func(it.castToInterface0DIterator()) - z_min) * z_diff
+		while not it.is_end:
+			z = (self.__func(it.cast_to_interface0diterator()) - z_min) * z_diff
 			thickness = (1 - z) * self.__max + z * self.__min
-			it.getObject().attribute.thickness = (thickness, thickness)
+			it.object.attribute.thickness = (thickness, thickness)
 			it.increment()
 
 
@@ -361,8 +361,8 @@ class pyConstantColorShader(StrokeShader):
 		return "pyConstantColorShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			att = it.getObject().attribute
+		while not it.is_end:
+			att = it.object.attribute
 			att.color = (self._r, self._g, self._b)
 			att.alpha = self._a
 			it.increment()
@@ -379,8 +379,8 @@ class pyIncreasingColorShader(StrokeShader):
 		n = stroke.stroke_vertices_size() - 1
 		inc = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			att = it.getObject().attribute
+		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], 
@@ -402,8 +402,8 @@ class pyInterpolateColorShader(StrokeShader):
 		n = stroke.stroke_vertices_size() - 1
 		inc = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			att = it.getObject().attribute
+		while not it.is_end:
+			att = it.object.attribute
 			u = float(inc)/float(n)
 			c = 1-2*(fabs(u-0.5))
 			att.color = ((1-c)*self._c1[0] + c*self._c2[0], 
@@ -427,8 +427,8 @@ class pyMaterialColorShader(StrokeShader):
 		Yn = 1.0
 		un = 4.* xn/ ( -2.*xn + 12.*yn + 3. )
 		vn= 9.* yn/ ( -2.*xn + 12.*yn +3. )	
-		while not it.isEnd():
-			toto = it.castToInterface0DIterator()
+		while not it.is_end:
+			toto = it.cast_to_interface0diterator()
 			mat = func(toto)
 			
 			r = mat.diffuse[0]
@@ -472,7 +472,7 @@ class pyMaterialColorShader(StrokeShader):
 			g = max(0,g)
 			b = max(0,b)
 
-			it.getObject().attribute.color = (r, g, b)
+			it.object.attribute.color = (r, g, b)
 			it.increment()
 
 class pyRandomColorShader(StrokeShader):
@@ -488,8 +488,8 @@ class pyRandomColorShader(StrokeShader):
 		c2 = float(uniform(15,75))/100.0
 		print(c0, c1, c2)
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			it.getObject().attribute.color = (c0,c1,c2)
+		while not it.is_end:
+			it.object.attribute.color = (c0,c1,c2)
 			it.increment()
 
 class py2DCurvatureColorShader(StrokeShader):
@@ -498,12 +498,12 @@ class py2DCurvatureColorShader(StrokeShader):
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
 		func = Curvature2DAngleF0D()
-		while not it.isEnd():
-			c = func(it.castToInterface0DIterator())
+		while not it.is_end:
+			c = func(it.cast_to_interface0diterator())
 			if c < 0:
 				print("negative 2D curvature")
 			color = 10.0 * c/3.1415
-			it.getObject().attribute.color = (color, color, color)
+			it.object.attribute.color = (color, color, color)
 			it.increment()
 
 class pyTimeColorShader(StrokeShader):
@@ -514,8 +514,8 @@ class pyTimeColorShader(StrokeShader):
 	def shade(self, stroke):
 		c = self._t*1.0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			it.getObject().attribute.color = (c,c,c)
+		while not it.is_end:
+			it.object.attribute.color = (c,c,c)
 			it.increment()
 		self._t = self._t+self._step
 
@@ -545,10 +545,10 @@ class pyBackboneStretcherShader(StrokeShader):
 		itn.decrement()
 		itn_1 = StrokeVertexIterator(itn)
 		itn_1.decrement()
-		v0 = it0.getObject()
-		v1 = it1.getObject()
-		vn_1 = itn_1.getObject()
-		vn = itn.getObject()
+		v0 = it0.object
+		v1 = it1.object
+		vn_1 = itn_1.object
+		vn = itn.object
 		p0 = Vector([v0.projected_x, v0.projected_y])
 		pn = Vector([vn.projected_x, vn.projected_y])
 		p1 = Vector([v1.projected_x, v1.projected_y])
@@ -579,10 +579,10 @@ class pyLengthDependingBackboneStretcherShader(StrokeShader):
 		itn.decrement()
 		itn_1 = StrokeVertexIterator(itn)
 		itn_1.decrement()
-		v0 = it0.getObject()
-		v1 = it1.getObject()
-		vn_1 = itn_1.getObject()
-		vn = itn.getObject()
+		v0 = it0.object
+		v1 = it1.object
+		vn_1 = itn_1.object
+		vn = itn.object
 		p0 = Vector([v0.projected_x, v0.projected_y])
 		pn = Vector([vn.projected_x, vn.projected_y])
 		p1 = Vector([v1.projected_x, v1.projected_y])
@@ -607,23 +607,23 @@ class pyGuidingLineShader(StrokeShader):
 		it = stroke.stroke_vertices_begin() 	## get the first vertex
 		itlast = stroke.stroke_vertices_end() 	## 
 		itlast.decrement()			## get the last one
-		t = itlast.getObject().point - it.getObject().point	## tangent direction
+		t = itlast.object.point - it.object.point	## tangent direction
 		itmiddle = StrokeVertexIterator(it)	## 
-		while itmiddle.getObject().u < 0.5:	## look for the stroke middle vertex
+		while itmiddle.object.u < 0.5:	## look for the stroke middle vertex
 			itmiddle.increment()		##
 		it = StrokeVertexIterator(itmiddle)	
 		it.increment()
-		while not it.isEnd():			## position all the vertices along the tangent for the right part
-			it.getObject().point = itmiddle.getObject().point \
-			    +t*(it.getObject().u-itmiddle.getObject().u)
+		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.isBegin():			## position all the vertices along the tangent for the left part
-			it.getObject().point = itmiddle.getObject().point \
-			    -t*(itmiddle.getObject().u-it.getObject().u)
+		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.getObject().point = itmiddle.getObject().point-t*itmiddle.getObject().u ## first vertex
+		it.object.point = itmiddle.object.point-t*itmiddle.object.u ## first vertex
 		stroke.update_length()
 
 
@@ -641,8 +641,8 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
 		itn.decrement()
 		itn_1 = StrokeVertexIterator(itn)
 		itn_1.decrement()
-		v0 = it0.getObject()
-		v1 = it1.getObject()
+		v0 = it0.object
+		v1 = it1.object
 		if (v0.nature & Nature.CUSP) == 0 and (v1.nature & Nature.CUSP) == 0:
 			p0 = v0.point
 			p1 = v1.point
@@ -650,8 +650,8 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
 			d1.normalize()
 			newFirst = p0+d1*float(self._l)
 			v0.point = newFirst
-		vn_1 = itn_1.getObject()
-		vn = itn.getObject()
+		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
@@ -677,10 +677,10 @@ class pyDiffusion2Shader(StrokeShader):
 	def shade(self, stroke):
 		for i in range (1, self._nbIter):
 			it = stroke.stroke_vertices_begin()
-			while not it.isEnd():
-				v = it.getObject()
+			while not it.is_end:
+				v = it.object
 				p1 = v.point
-				p2 = self._normalInfo(it.castToInterface0DIterator())*self._lambda*self._curvatureInfo(it.castToInterface0DIterator())
+				p2 = self._normalInfo(it.cast_to_interface0diterator())*self._lambda*self._curvatureInfo(it.cast_to_interface0diterator())
 				v.point = p1+p2
 				it.increment()
 		stroke.update_length()
@@ -698,8 +698,8 @@ class pyTipRemoverShader(StrokeShader):
 		verticesToRemove = []
 		oldAttributes = []
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			v = it.getObject()
+		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))
@@ -714,9 +714,9 @@ class pyTipRemoverShader(StrokeShader):
 			print("pyTipRemover: Warning: resampling problem")
 		it = stroke.stroke_vertices_begin()
 		for a in oldAttributes:
-			if it.isEnd():
+			if it.is_end:
 				break
-			it.getObject().attribute = a
+			it.object.attribute = a
 			it.increment()
 		stroke.update_length()
 
@@ -731,9 +731,9 @@ class pyTVertexRemoverShader(StrokeShader):
 		itlast = stroke.stroke_vertices_end()
 		itlast.decrement()
 		if predTVertex(it):
-			stroke.remove_vertex(it.getObject())
+			stroke.remove_vertex(it.object)
 		if predTVertex(itlast):
-			stroke.remove_vertex(itlast.getObject())
+			stroke.remove_vertex(itlast.object)
 		stroke.update_length()
 
 class pyExtremitiesOrientationShader(StrokeShader):
@@ -762,12 +762,12 @@ class pyHLRShader(StrokeShader):
 		invisible = 0
 		it2 = StrokeVertexIterator(it)
 		it2.increment()
-		fe = get_fedge(it.getObject(), it2.getObject())
+		fe = get_fedge(it.object, it2.object)
 		if fe.viewedge.qi != 0:
 			invisible = 1
-		while not it2.isEnd():
-			v = it.getObject()
-			vnext = it2.getObject()
+		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 = get_fedge(v, vnext)
@@ -795,10 +795,10 @@ class pyTVertexOrientationShader(StrokeShader):
 			ait = AdjacencyIterator(tv,1,0)
 			winner = None
 			incoming = True
-			while not ait.isEnd():
-				ave = ait.getObject()
+			while not ait.is_end:
+				ave = ait.object
 				if  ave.id != ve.id and ave.id != mateVE.id:
-					winner = ait.getObject()
+					winner = ait.object
 					if not ait.isIncoming(): # FIXME
 						incoming = False
 						break
@@ -821,18 +821,18 @@ class pyTVertexOrientationShader(StrokeShader):
 		it2 = StrokeVertexIterator(it)
 		it2.increment()
 		## case where the first vertex is a TVertex
-		v = it.getObject()
+		v = it.object
 		if (v.nature & Nature.T_VERTEX) != 0:
 			tv = self.castToTVertex(v)
 			if tv is not None:
-				ve = get_fedge(v, it2.getObject()).viewedge
+				ve = 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.isEnd():
-			vprevious = it.getObject()
-			v = it2.getObject()
+		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:
@@ -844,13 +844,13 @@ class pyTVertexOrientationShader(StrokeShader):
 			it.increment()
 			it2.increment()
 		## case where the last vertex is a TVertex
-		v = it.getObject() 
+		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 = get_fedge(itPrevious.getObject(), v).viewedge
+				ve = get_fedge(itPrevious.object, v).viewedge
 				dir = self.findOrientation(tv, ve)
 				if dir is not None:
 					#print(dir.x, dir.y)
@@ -866,10 +866,10 @@ class pySinusDisplacementShader(StrokeShader):
 		return "pySinusDisplacementShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			v = it.getObject()
+		while not it.is_end:
+			v = it.object
 			#print(self._getNormal.getName())
-			n = self._getNormal(it.castToInterface0DIterator())
+			n = self._getNormal(it.cast_to_interface0diterator())
 			p = v.point
 			u = v.u
 			a = self._a*(1-2*(fabs(u-0.5)))
@@ -891,8 +891,8 @@ class pyPerlinNoise1DShader(StrokeShader):
 		return "pyPerlinNoise1DShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			v = it.getObject()
+		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)
@@ -910,8 +910,8 @@ class pyPerlinNoise2DShader(StrokeShader):
 		return "pyPerlinNoise2DShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			v = it.getObject()
+		while not it.is_end:
+			v = it.object
 			vec = 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)
@@ -928,12 +928,12 @@ class pyBluePrintCirclesShader(StrokeShader):
 		return "pyBluePrintCirclesShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		if it.isEnd():
+		if it.is_end:
 			return
-		p_min = it.getObject().point.copy()
-		p_max = it.getObject().point.copy()
-		while not it.isEnd():
-			p = it.getObject().point
+		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:
@@ -964,19 +964,19 @@ class pyBluePrintCirclesShader(StrokeShader):
 			prev_center = center
 			radius = radius + randint(-R, R)
 			center = center + Vector([randint(-C, C), randint(-C, C)])
-			while i < sv_nb and not it.isEnd():
+			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 * cos(2 * pi * t)
 				p_new.y = c.y + r * sin(2 * pi * t)
-				it.getObject().point = p_new
+				it.object.point = p_new
 				i = i + 1
 				it.increment()
 			i = 1
 		verticesToRemove = []
-		while not it.isEnd():
-			verticesToRemove.append(it.getObject())
+		while not it.is_end:
+			verticesToRemove.append(it.object)
 			it.increment()
 		for sv in verticesToRemove:
 			stroke.remove_vertex(sv)
@@ -992,12 +992,12 @@ class pyBluePrintEllipsesShader(StrokeShader):
 		return "pyBluePrintEllipsesShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		if it.isEnd():
+		if it.is_end:
 			return
-		p_min = it.getObject().point.copy()
-		p_max = it.getObject().point.copy()
-		while not it.isEnd():
-			p = it.getObject().point
+		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:
@@ -1023,19 +1023,19 @@ class pyBluePrintEllipsesShader(StrokeShader):
 			prev_center = center
 			radius = radius + Vector([randint(-R, R), randint(-R, R)])
 			center = center + Vector([randint(-C, C), randint(-C, C)])
-			while i < sv_nb and not it.isEnd():
+			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 * cos(2 * pi * t)
 				p_new.y = c.y + r.y * sin(2 * pi * t)
-				it.getObject().point = p_new
+				it.object.point = p_new
 				i = i + 1
 				it.increment()
 			i = 1
 		verticesToRemove = []
-		while not it.isEnd():
-			verticesToRemove.append(it.getObject())
+		while not it.is_end:
+			verticesToRemove.append(it.object)
 			it.increment()
 		for sv in verticesToRemove:
 			stroke.remove_vertex(sv)
@@ -1052,12 +1052,12 @@ class pyBluePrintSquaresShader(StrokeShader):
 		return "pyBluePrintSquaresShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		if it.isEnd():
+		if it.is_end:
 			return
-		p_min = it.getObject().point.copy()
-		p_max = it.getObject().point.copy()
-		while not it.isEnd():
-			p = it.getObject().point
+		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:
@@ -1102,7 +1102,7 @@ class pyBluePrintSquaresShader(StrokeShader):
 			vec_third = p_third_end - p_third
 			vec_fourth = p_fourth_end - p_fourth
 			i = 0
-			while i < sv_nb and not it.isEnd():
+			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:
@@ -1119,21 +1119,21 @@ class pyBluePrintSquaresShader(StrokeShader):
 					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
 					if i == fourth - 1:
 						visible = False
-				if it.getObject() == None:
+				if it.object == None:
 					i = i + 1
 					it.increment()
 					if not visible:
 						visible = True
 					continue
-				it.getObject().point = p_new
-				it.getObject().attribute.visible = visible
+				it.object.point = p_new
+				it.object.attribute.visible = visible
 				if not visible:
 					visible = True
 				i = i + 1
 				it.increment()
 		verticesToRemove = []
-		while not it.isEnd():
-			verticesToRemove.append(it.getObject())
+		while not it.is_end:
+			verticesToRemove.append(it.object)
 			it.increment()
 		for sv in verticesToRemove:
 			stroke.remove_vertex(sv)
@@ -1152,8 +1152,8 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
 		stroke.resample(32 * self.__turns)
 		p_mean = Vector([0, 0])
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			p = it.getObject().point
+		while not it.is_end:
+			p = it.object.point
 			p_mean = p_mean + p
 			it.increment()
 		sv_nb = stroke.stroke_vertices_size()
@@ -1162,8 +1162,8 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
 		p_var_yy = 0
 		p_var_xy = 0
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			p = it.getObject().point
+		while not it.is_end:
+			p = it.object.point
 			p_var_xx = p_var_xx + pow(p.x - p_mean.x, 2)
 			p_var_yy = p_var_yy + pow(p.y - p_mean.y, 2)
 			p_var_xy = p_var_xy + (p.x - p_mean.x) * (p.y - p_mean.y)
@@ -1224,15 +1224,15 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
 					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
 					if i == fourth - 1:
 						visible = False
-				it.getObject().point = p_new
-				it.getObject().attribute.visible = visible
+				it.object.point = p_new
+				it.object.attribute.visible = visible
 				if not visible:
 					visible = True
 				i = i + 1
 				it.increment()
 		verticesToRemove = []
-		while not it.isEnd():
-			verticesToRemove.append(it.getObject())
+		while not it.is_end:
+			verticesToRemove.append(it.object)
 			it.increment()
 		for sv in verticesToRemove:
 			stroke.remove_vertex(sv)
@@ -1247,15 +1247,15 @@ class pyModulateAlphaShader(StrokeShader):
 		return "pyModulateAlphaShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			alpha = it.getObject().attribute.alpha
-			p = it.getObject().point
+		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.getObject().attribute.alpha = alpha
+			it.object.attribute.alpha = alpha
 			it.increment()
 
 ## various
@@ -1264,9 +1264,9 @@ class pyDummyShader(StrokeShader):
 		return "pyDummyShader"
 	def shade(self, stroke):
 		it = stroke.stroke_vertices_begin()
-		while not it.isEnd():
-			toto = it.castToInterface0DIterator()
-			att = it.getObject().attribute
+		while not it.is_end:
+			toto = it.cast_to_interface0diterator()
+			att = it.object.attribute
 			att.color = (0.3, 0.4, 0.4)
 			att.thickness = (0, 5)
 			it.increment()
@@ -1284,8 +1284,8 @@ class pyDebugShader(StrokeShader):
 		found = True
 		foundfirst = True
 		foundsecond = False
-		while not it.isEnd():
-			cp = it.getObject()
+		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:
diff --git a/release/scripts/freestyle/style_modules/uniformpruning_zsort.py b/release/scripts/freestyle/style_modules/uniformpruning_zsort.py
index 50a2f6423fd..9a8ba0d12f8 100644
--- a/release/scripts/freestyle/style_modules/uniformpruning_zsort.py
+++ b/release/scripts/freestyle/style_modules/uniformpruning_zsort.py
@@ -7,24 +7,6 @@ from Functions0D import *
 from Functions1D import *
 from shaders import *
 
-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 getName(self):
-		return "pyDensityUP1D"
-
-	def __call__(self, inter):
-		d = self._func(inter)
-		print("For Chain ", inter.getId().getFirst(), inter.getId().getSecond(), "density is ", d)
-		if(d < self._threshold):
-			return 1
-		return 0
-
 Operators.select(QuantitativeInvisibilityUP1D(0))
 Operators.bidirectionalChain(ChainSilhouetteIterator())
 #Operators.sequentialSplit(pyVertexNatureUP0D(Nature.VIEW_VERTEX), 2)