Differential D319 Diff 1982 release/scripts/freestyle/modules/freestyle/chainingiterators.py

Changeset View

Standalone View

release/scripts/freestyle/modules/freestyle/chainingiterators.py

Context not available.
	chaining iterators in Python	chaining iterators in Python
	"""	"""

		__all__ = (
		"pyChainSilhouetteIterator",
		"pyChainSilhouetteGenericIterator",
		"pyExternalContourChainingIterator",
		"pySketchyChainSilhouetteIterator",
		"pySketchyChainingIterator",
		"pyFillOcclusionsRelativeChainingIterator",
		"pyFillOcclusionsAbsoluteChainingIterator",
		"pyFillOcclusionsAbsoluteAndRelativeChainingIterator",
		"pyFillQi0AbsoluteAndRelativeChainingIterator",
		"pyNoIdChainSilhouetteIterator",
		)


	# module members	# module members
	from _freestyle import (	from _freestyle import (
	ChainPredicateIterator,	ChainPredicateIterator,
Context not available.
	)	)
	from freestyle.utils import (	from freestyle.utils import (
	ContextFunctions as CF,	ContextFunctions as CF,
	stroke_normal,	get_chain_length,
	)	)
	import bpy

		import bpy, time


		NATURES = (
		Nature.SILHOUETTE,
		Nature.BORDER,
		Nature.CREASE,
		Nature.MATERIAL_BOUNDARY,
		Nature.EDGE_MARK,
		Nature.SUGGESTIVE_CONTOUR,
		Nature.VALLEY,
		Nature.RIDGE
		)


		def nature_in_preceding(nature, index):
		return any(nature & nat for nat in NATURES[:index])

	class pyChainSilhouetteIterator(ChainingIterator):	class pyChainSilhouetteIterator(ChainingIterator):
	"""Natural chaining iterator	"""Natural chaining iterator
Context not available.
	def init(self):	def init(self):
	pass	pass

	def traverse(self, iter):	def traverse(self, iter):
	winner = None
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	## case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	mate_id = vertex.get_mate(self.current_edge).id
	ve = it.object	# return the first vertex that matches the id, None if no matches
	if ve.id == mateVE.id:	return next((ve for ve in it if ve.id == mate_id), None)
		kjym3Unsubmitted Not Done Inline Actions Just a thought: We could define a local function (predicate) and use `filter` built-in function to make this generator-based expression: mate_id = vertex.get_mate(self.current_edge).id def is_mate(ve): return ve.id == mate_id return next(filter(is_mate, it), None) The predicate can be an unnamed lambda function in this case, there are similar cases in other chaining iterators that could employ the same idiom. Regular use of the same idiom is preferable. kjym3: Just a thought: We could define a local function (predicate) and use `filter` built-in function…
		flokkievidsAuthorUnsubmitted Not Done Inline Actions I prefer using a generator expression over an anonymous function and a barely-used built-in. I'll look into a broader usage of the idiom. flokkievids: I prefer using a generator expression over an anonymous function and a barely-used built-in.
	winner = ve	## case of NonTVertex
	break	winner = None
	it.increment()	for i, nat in enumerate(NATURES):
	else:	if (nat & self.current_edge.nature):
	## case of NonTVertex	for ve in it:
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	ve_nat = ve.nature
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	if (ve_nat & nat):
	for i in range(len(natures)):	# search for matches in previous natures. if match -> break
	currentNature = self.current_edge.nature	if nat != ve_nat and nature_in_preceding(ve_nat, index=i):
	if (natures[i] & currentNature) != 0:	break
	count=0	# a second match must be an error
	while not it.is_end:	if winner is not None:
	visitNext = 0	return None
	oNature = it.object.nature	# assign winner
	if (oNature & natures[i]) != 0:	winner = ve
	if natures[i] != oNature:	return winner
	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


	class pyChainSilhouetteGenericIterator(ChainingIterator):	class pyChainSilhouetteGenericIterator(ChainingIterator):
Context not available.
	pass	pass

	def traverse(self, iter):	def traverse(self, iter):
	winner = None
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	## case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	mate_id = vertex.get_mate(self.current_edge).id
	ve = it.object	for ve in it:
	if ve.id == mateVE.id:	if ve.id == mate_id:
	winner = ve	return ve
	break	return None
	it.increment()	## case of NonTVertex
	else:	winner = None
	## case of NonTVertex	for i, nat in enumerate(NATURES):
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	if (nat & self.current_edge.nature):
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	for ve in it:
	for i in range(len(natures)):	ve_nat = ve.nature
	currentNature = self.current_edge.nature	if ve.id == self.current_edge.id:
	if (natures[i] & currentNature) != 0:	continue
	count=0	if (ve_nat & nat):
	while not it.is_end:	if nat != ve_nat and nature_in_preceding(ve_nat, index=i):
	visitNext = 0	break
	oNature = it.object.nature
	ve = it.object	if winner is not None:
	if ve.id == self.current_edge.id:	return None
	it.increment()
	continue	winner = ve
	if (oNature & natures[i]) != 0:	return winner
	if natures[i] != oNature:	return None
	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):	class pyExternalContourChainingIterator(ChainingIterator):
	"""Chains by external contour"""	"""Chains by external contour"""

	def __init__(self):	def __init__(self):
	ChainingIterator.__init__(self, False, True, None, True)	ChainingIterator.__init__(self, False, True, None, True)
	self._isExternalContour = ExternalContourUP1D()	self.ExternalContour = ExternalContourUP1D()

	def init(self):	def init(self):
	self._nEdges = 0	self._nEdges = 0
	self._isInSelection = 1

	def checkViewEdge(self, ve, orientation):	def checkViewEdge(self, ve, orientation):
	if orientation != 0:	vertex = (ve.first_viewvertex if orientation else
	vertex = ve.second_svertex()	ve.last_viewvertex)
	else:
	vertex = ve.first_svertex()	it = AdjacencyIterator(vertex, True, True)
	it = AdjacencyIterator(vertex,1,1)	result = any(self.ExternalContour(ave) for ave in it)
	while not it.is_end:	# report if there is no result (that's bad)
		kjym3Unsubmitted Not Done Inline Actions Minor comment: `not result and bpy.app.debug_freestyle` would a bit faster. kjym3: Minor comment: `not result and bpy.app.debug_freestyle` would a bit faster.
		flokkievidsAuthorUnsubmitted Not Done Inline Actions Just interested here: would it really, significantly matter? Adjusted in rev. 7 flokkievids: Just interested here: would it really, significantly matter? Adjusted in rev. 7
		kjym3Unsubmitted Not Done Inline Actions No, not really. My comment was mostly for consistency (in other cases, we have put bpy.app.debug_freestyle at the end of conditions). kjym3: No, not really. My comment was mostly for consistency (in other cases, we have put bpy.app.
	ave = it.object	if bpy.app.debug_freestyle and not result:
	if self._isExternalContour(ave):
	return True
	it.increment()
	if bpy.app.debug_freestyle:
	print("pyExternalContourChainingIterator : didn't find next edge")	print("pyExternalContourChainingIterator : didn't find next edge")
	return False
		return result

	def traverse(self, iter):	def traverse(self, iter):
	winner = None	winner = None
		self._nEdges += 1

	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	while not it.is_end:	time_stamp = CF.get_time_stamp()
	ve = it.object
	if self._isExternalContour(ve):	for ve in it:
	if ve.time_stamp == CF.get_time_stamp():	if self.ExternalContour(ve) and ve.time_stamp == time_stamp:
	winner = ve	winner = ve
	it.increment()

		kjym3Unsubmitted Not Done Inline Actions If type(vertex) is TVertex, the method has to end here and return None. kjym3: If type(vertex) is TVertex, the method has to end here and return None.
	self._nEdges = self._nEdges+1
	if winner is None:	if winner is None:
	orient = 1
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	while not it.is_end:	for ve in it:
	ve = it.object	if self.checkViewEdge(ve, not it.is_incoming):
	if it.is_incoming:
	orient = 0
	good = self.checkViewEdge(ve,orient)
	if good != 0:
	winner = ve	winner = ve
	it.increment()
	return winner	return winner


		kjym3Unsubmitted Not Done Inline Actions The revised traverse() needs an explicit return statement at the end of the method. kjym3: The revised traverse() needs an explicit return statement at the end of the method.
Context not available.

	def __init__(self, nRounds=3,stayInSelection=True):	def __init__(self, nRounds=3,stayInSelection=True):
	ChainingIterator.__init__(self, stayInSelection, False, None, True)	ChainingIterator.__init__(self, stayInSelection, False, None, True)
	self._timeStamp = CF.get_time_stamp()+nRounds	self._timeStamp = CF.get_time_stamp() + nRounds
	self._nRounds = nRounds	self._nRounds = nRounds

	def init(self):	def init(self):
	self._timeStamp = CF.get_time_stamp()+self._nRounds	self._timeStamp = CF.get_time_stamp() + self._nRounds

		# keeping this local saves passing a reference to 'self' around
		kjym3Unsubmitted Not Done Inline Actions self._isInSelection seems not necessary. This line can be removed. kjym3: self._isInSelection seems not necessary. This line can be removed.
		def make_sketchy(self, ve):
		"""
		Creates the skeychy effect by causing the chain to run from
		the start again. (loop over itself again)
		"""
		if ve is None:
		ve = self.current_edge
		kjym3Unsubmitted Not Done Inline Actions It would be faster just to return True here if result is True (as in the original code). kjym3: It would be faster just to return True here if result is True (as in the original code).
		flokkievidsAuthorUnsubmitted Not Done Inline Actions In what way? I didn't really test this but it seems to me that any() made for situations exactly like this. I would assume that it has also been optimized (memory usage ect.) It shouldn't be slower and the code shows exactly what you want to achieve. flokkievids: In what way? I didn't really test this but it seems to me that any() made for situations…
		kjym3Unsubmitted Not Done Inline Actions You are right, it looks like I was confused with all(). kjym3: You are right, it looks like I was confused with all().
		if ve.chaining_time_stamp == self._timeStamp:
		return None
		return ve

	def traverse(self, iter):	def traverse(self, iter):
	winner = None
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	## case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	mate_id = vertex.get_mate(self.current_edge).id
	ve = it.object	# return the first vertex that matches the id, None if no matches
	if ve.id == mateVE.id:	for ve in it:
	winner = ve	if ve.id == mate_id:
	break	return self.make_sketchy(ve)
	it.increment()	return self.make_sketchy(None)
	else:
	## case of NonTVertex	## case of NonTVertex
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	winner = None
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	for i, nat in enumerate(NATURES):
	for i in range(len(natures)):	if (nat & self.current_edge.nature):
	currentNature = self.current_edge.nature	for ve in it:
	if (natures[i] & currentNature) != 0:	if ve.id == self.current_edge.id:
	count=0	continue
	while not it.is_end:	ve_nat = ve.nature
		kjym3Unsubmitted Not Done Inline Actions In the original code, once 'orient' is set to 0 it stays as so. Can you confirm the new logic is okay? kjym3: In the original code, once 'orient' is set to 0 it stays as so. Can you confirm the new logic…
		flokkievidsAuthorUnsubmitted Not Done Inline Actions tests with imagemagick over the past two months have not once given an error here. I will however look into it. flokkievids: tests with imagemagick over the past two months have not once given an error here. I will…
	visitNext = 0	if (ve_nat & nat):
	oNature = it.object.nature	if nat != ve_nat and nature_in_preceding(ve_nat, i):
	ve = it.object	break
	if ve.id == self.current_edge.id:
	it.increment()	if winner is not None:
	continue	return self.make_sketchy(None)
	if (oNature & natures[i]) != 0:
	if (natures[i] != oNature) != 0:	winner = ve
	for j in range(i):	break
	if (natures[j] & oNature) != 0:
	visitNext = 1	return self.make_sketchy(winner)
	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


	class pySketchyChainingIterator(ChainingIterator):	class pySketchyChainingIterator(ChainingIterator):
Context not available.
	"""	"""
	def __init__(self, nRounds=3, stayInSelection=True):	def __init__(self, nRounds=3, stayInSelection=True):
	ChainingIterator.__init__(self, stayInSelection, False, None, True)	ChainingIterator.__init__(self, stayInSelection, False, None, True)
	self._timeStamp = CF.get_time_stamp()+nRounds	self._timeStamp = CF.get_time_stamp() + nRounds
	self._nRounds = nRounds	self._nRounds = nRounds
		self.t = False

	def init(self):	def init(self):
	self._timeStamp = CF.get_time_stamp()+self._nRounds	self._timeStamp = CF.get_time_stamp() + self._nRounds

	def traverse(self, iter):	def traverse(self, iter):
	winner = None	winner = None
	found = False	found = False
	it = AdjacencyIterator(iter)
	while not it.is_end:	for ve in AdjacencyIterator(iter):
	ve = it.object	if self.current_edge.id == ve.id:
	if ve.id == self.current_edge.id:
	found = True	found = True
	it.increment()
	continue	continue
	winner = ve	winner = ve
	it.increment()
	if not found:	if not found:
	# This is a fatal error condition: self.current_edge must be found	# This is a fatal error condition: self.current_edge must be found
	# among the edges seen by the AdjacencyIterator [bug #35695].	# among the edges seen by the AdjacencyIterator [bug #35695].
		kjym3Unsubmitted Not Done Inline Actions If type(vertex) is TVertex, the method has to end here and return None. kjym3: If type(vertex) is TVertex, the method has to end here and return None.
	if bpy.app.debug_freestyle:	if bpy.app.debug_freestyle:
	print('pySketchyChainingIterator: current edge not found')	print('pySketchyChainingIterator: current edge not found')
	return None	return None

	if winner is None:	if winner is None:
	winner = self.current_edge	winner = self.current_edge
	if winner.chaining_time_stamp == self._timeStamp:	if winner.chaining_time_stamp == self._timeStamp:
Context not available.

	def __init__(self, percent):	def __init__(self, percent):
		kjym3Unsubmitted Not Done Inline Actions I like the idea of introducing the .make_sketchy() helper method which helps code reading :) kjym3: I like the idea of introducing the .make_sketchy() helper method which helps code reading :)
	ChainingIterator.__init__(self, False, True, None, True)	ChainingIterator.__init__(self, False, True, None, True)
	self._length = 0	self._length = 0.0
	self._percent = float(percent)	self._percent = float(percent)
		self.timestamp = CF.get_time_stamp()

	def init(self):	def init(self):
	# A chain's length should preferably be evaluated only once.	# A chain's length should preferably be evaluated only once.
	# Therefore, the chain length is reset here.	# Therefore, the chain length is reset here.
	self._length = 0	self._length = 0.0

		kjym3Unsubmitted Not Done Inline Actions Should be `TVertex`. Please, double-check all chaining iterators for this typo. kjym3: Should be `TVertex`. Please, double-check all chaining iterators for this typo.
	def traverse(self, iter):	def traverse(self, iter):
	winner = None	winner = None
		winnerOrientation = False
	winnerOrientation = False
	winnerOrientation = 0
	#print(self.current_edge.id.first, self.current_edge.id.second)
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	## case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	mate_id = vertex.get_mate(self.current_edge).id
	ve = it.object	for ve in it:
	if ve.id == mateVE.id:	if ve.id == mate_id:
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	break	break
	it.increment()	## case of NonTVertex
	else:	else:
	## case of NonTVertex	for nat in NATURES:
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	if (self.current_edge.nature & nat):
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	for ve in it:
	for nat in natures:	if (ve.nature & nat):
	if (self.current_edge.nature & nat) != 0:	if winner is not None:
	count=0	return None
	while not it.is_end:
	ve = it.object
	if (ve.nature & nat) != 0:
	count = count+1
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	it.increment()
	if count != 1:
	winner = None
	break	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(False, False)
	_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(False, False)	# check timestamp to see if this edge was part of the selection
	_cit.begin = winner	#ts = CF.get_time_stamp()
	_cit.current_edge = winner	if winner is not None and winner.time_stamp != self.timestamp:
	_cit.orientation = winnerOrientation	# if the edge wasn't part of the selection, let's see
	_cit.init()	# whether it's short enough (with respect to self.percent)
	while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():	# to be included.
	ve = _cit.object	if self._length == 0.0:
	#print("-------- --------", ve.id.first, ve.id.second)	self._length = get_chain_length(winner, winnerOrientation)
	connexl = connexl + ve.length_2d
	_cit.increment()	# check if the gap can be bridged
	if connexl > self._percent * self._length:	connexl = 0.0
	winner = None	_cit = pyChainSilhouetteGenericIterator(False, False)
		_cit.begin = winner
		_cit.current_edge = winner
		_cit.orientation = winnerOrientation
		_cit.init()

		while (not _cit.is_end) and _cit.object.time_stamp != self.timestamp:
		connexl += _cit.object.length_2d
		_cit.increment()
		if _cit.is_begin: break

		if connexl > self._percent * self._length:
		return None

	return winner	return winner


Context not available.
	def __init__(self, length):	def __init__(self, length):
	ChainingIterator.__init__(self, False, True, None, True)	ChainingIterator.__init__(self, False, True, None, True)
	self._length = float(length)	self._length = float(length)
		self.timestamp = CF.get_time_stamp()

	def init(self):	def init(self):
	pass	pass

	def traverse(self, iter):	def traverse(self, iter):
	winner = None	winner = None
	winnerOrientation = False	winnerOrientation = False
	#print(self.current_edge.id.first, self.current_edge.id.second)
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	## case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	mate_id = vertex.get_mate(self.current_edge).id
	ve = it.object	for ve in it:
	if ve.id == mateVE.id:	if ve.id == mate_id:
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	break	break
		kjym3Unsubmitted Not Done Inline Actions Not sure if a docstring here is useful. Usual comment lines would suffice. kjym3: Not sure if a docstring here is useful. Usual comment lines would suffice.
	it.increment()	## case of NonTVertex
		kjym3Unsubmitted Not Done Inline Actions The original `length == 0` appears more logical than `not length`. Please, find a few more occurrence of the same notation change in the rest of the code. kjym3: The original `length == 0` appears more logical than `not length`. Please, find a few more…
	else:	else:
	## case of NonTVertex	for nat in NATURES:
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	if (self.current_edge.nature & nat):
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	for ve in it:
	for nat in natures:	if (ve.nature & nat):
	if (self.current_edge.nature & nat) != 0:	if winner is not None:
	count=0	return None
	while not it.is_end:
	ve = it.object
	if (ve.nature & nat) != 0:
	count = count+1
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	it.increment()
	if count != 1:
	winner = None
	break	break
	if winner is not None:
	# check whether this edge was part of the selection	if winner is not None and winner.time_stamp != self.timestamp:
	if winner.time_stamp != CF.get_time_stamp():	connexl = 0.0
	#print("---", winner.id.first, winner.id.second)	_cit = pyChainSilhouetteGenericIterator(False, False)
		kjym3Unsubmitted Not Done Inline Actions This `if ... break` block does not exist in the original code. Was it left here by mistake? There are a few more occurrence of the additional `if ... break` block. Please, double-check them all. kjym3: This `if ... break` block does not exist in the original code. Was it left here by mistake?
		flokkievidsAuthorUnsubmitted Not Done Inline Actions We spoke about this earlier. there is a chance the iterator will turn back on itself, creating an infinite loop. This eliminates the chance of that happening. flokkievids: We spoke about this earlier. there is a chance the iterator will turn back on itself, creating…
		kjym3Unsubmitted Not Done Inline Actions Thanks for the reminder. The code revision looks okay. kjym3: Thanks for the reminder. The code revision looks okay.
	# nw let's compute the length of this connex non selected part:	_cit.begin = winner
	connexl = 0	_cit.current_edge = winner
	_cit = pyChainSilhouetteGenericIterator(False, False)	_cit.orientation = winnerOrientation
	_cit.begin = winner	_cit.init()
	_cit.current_edge = winner
	_cit.orientation = winnerOrientation	while (not _cit.is_end) and _cit.object.time_stamp != self.timestamp:
	_cit.init()	connexl += _cit.object.length_2d
	while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():	_cit.increment()
	ve = _cit.object	if _cit.is_begin: break
	#print("-------- --------", ve.id.first, ve.id.second)
	connexl = connexl + ve.length_2d	if connexl > self._length:
	_cit.increment()	return None
	if connexl > self._length:
	winner = None
	return winner	return winner


Context not available.
	"""	"""
	def __init__(self, percent, l):	def __init__(self, percent, l):
	ChainingIterator.__init__(self, False, True, None, True)	ChainingIterator.__init__(self, False, True, None, True)
	self._length = 0	self._length = 0.0
	self._absLength = l	self._absLength = l
	self._percent = float(percent)	self._percent = float(percent)

Context not available.
	# each time we're evaluating a chain length	# each time we're evaluating a chain length
	# we try to do it once. Thus we reinit	# we try to do it once. Thus we reinit
	# the chain length here:	# the chain length here:
	self._length = 0	self._length = 0.0

	def traverse(self, iter):	def traverse(self, iter):
	winner = None	winner = None
	winnerOrientation = False	winnerOrientation = False
	#print(self.current_edge.id.first, self.current_edge.id.second)
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	## case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	mate_id = vertex.get_mate(self.current_edge).id
	ve = it.object	for ve in it:
	if ve.id == mateVE.id:	if ve.id == mate_id:
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	break	break
	it.increment()	## case of NonTVertex
	else:	else:
	## case of NonTVertex	for nat in NATURES:
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	if (self.current_edge.nature & nat):
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	for ve in it:
	for nat in natures:	if (ve.nature & nat):
	if (self.current_edge.nature & nat) != 0:	if winner is not None:
	count=0	return None
	while not it.is_end:
	ve = it.object
	if (ve.nature & nat) != 0:
	count = count+1
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	it.increment()
	if count != 1:
	winner = None
	break	break
	if winner is not None:
	# check whether this edge was part of the selection	if winner is not None and winner.time_stamp != CF.get_time_stamp():
	if winner.time_stamp != CF.get_time_stamp():
	#print("---", winner.id.first, winner.id.second)	if self._length == 0.0:
	# if not, let's check whether it's short enough with	self._length = get_chain_length(winner, winnerOrientation)
	# respect to the chain made without staying in the selection
	#------------------------------------------------------------	connexl = 0.0
	# Did we compute the prospective chain length already ?
	if self._length == 0:
	#if not, let's do it
	_it = pyChainSilhouetteGenericIterator(False, False)
	_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(False, False)	_cit = pyChainSilhouetteGenericIterator(False, False)
	_cit.begin = winner	_cit.begin = winner
	_cit.current_edge = winner	_cit.current_edge = winner
	_cit.orientation = winnerOrientation	_cit.orientation = winnerOrientation
	_cit.init()	_cit.init()
	while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():	while (not _cit.is_end) and _cit.object.time_stamp != CF.get_time_stamp():
	ve = _cit.object	connexl += _cit.object.length_2d
	#print("-------- --------", ve.id.first, ve.id.second)
	connexl = connexl + ve.length_2d
	_cit.increment()	_cit.increment()
		if _cit.is_begin: break

	if (connexl > self._percent * self._length) or (connexl > self._absLength):	if (connexl > self._percent * self._length) or (connexl > self._absLength):
	winner = None	return None
	return winner	return winner


		kjym3Unsubmitted Not Done Inline Actions This comment should be `## case of TVertex`. Please, correct a few more occurrence of the same typo in other places. kjym3: This comment should be `## case of TVertex`. Please, correct a few more occurrence of the same…
Context not available.
	"""	"""
	def __init__(self, percent, l):	def __init__(self, percent, l):
	ChainingIterator.__init__(self, False, True, None, True)	ChainingIterator.__init__(self, False, True, None, True)
	self._length = 0	self._length = 0.0
	self._absLength = l	self._absLength = l
	self._percent = float(percent)	self._percent = percent

	def init(self):	def init(self):
	# A chain's length should preverably be evaluated only once.	# A chain's length should preverably be evaluated only once.
	# Therefore, the chain length is reset here.	# Therefore, the chain length is reset here.
	self._length = 0	self._length = 0.0

	def traverse(self, iter):	def traverse(self, iter):
	winner = None	winner = None
	winnerOrientation = False	winnerOrientation = False

	#print(self.current_edge.id.first, self.current_edge.id.second)
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	## case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	mate_id = vertex.get_mate(self.current_edge).id
	ve = it.object	for ve in it:
	if ve.id == mateVE.id:	if ve.id == mate_id:
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	break	break
	it.increment()	## case of NonTVertex
	else:	else:
	## case of NonTVertex	for nat in NATURES:
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	if (self.current_edge.nature & nat):
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	for ve in it:
	for nat in natures:	if (ve.nature & nat):
	if (self.current_edge.nature & nat) != 0:	if winner is not None:
	count=0	return None
	while not it.is_end:
	ve = it.object
	if (ve.nature & nat) != 0:
	count = count+1
	winner = ve	winner = ve
	winnerOrientation = not it.is_incoming	winnerOrientation = not it.is_incoming
	it.increment()
	if count != 1:
	winner = None
	break	break
	if winner is not None:
	# check whether this edge was part of the selection	if winner is not None and winner.qi:
	if winner.qi != 0:
	#print("---", winner.id.first, winner.id.second)
	# if not, let's check whether it's short enough with	if self._length == 0.0:
	# respect to the chain made without staying in the selection	self._length = get_chain_length(winner, winnerOrientation)
	#------------------------------------------------------------
	# Did we compute the prospective chain length already ?
	if self._length == 0:
	#if not, let's do it
	_it = pyChainSilhouetteGenericIterator(False, False)
	_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	connexl = 0
	_cit = pyChainSilhouetteGenericIterator(False, False)	_cit = pyChainSilhouetteGenericIterator(False, False)
	_cit.begin = winner	_cit.begin = winner
	_cit.current_edge = winner	_cit.current_edge = winner
	_cit.orientation = winnerOrientation	_cit.orientation = winnerOrientation
	_cit.init()	_cit.init()
	while not _cit.is_end and _cit.object.qi != 0:	while (not _cit.is_end) and _cit.object.qi != 0:
	ve = _cit.object	connexl += _cit.object.length_2d
	#print("-------- --------", ve.id.first, ve.id.second)
	connexl = connexl + ve.length_2d
	_cit.increment()	_cit.increment()
		if _cit.is_begin: break
	if (connexl > self._percent * self._length) or (connexl > self._absLength):	if (connexl > self._percent * self._length) or (connexl > self._absLength):
	winner = None	return None
	return winner	return winner


Context not available.
	def traverse(self, iter):	def traverse(self, iter):
	winner = None	winner = None
	it = AdjacencyIterator(iter)	it = AdjacencyIterator(iter)
	tvertex = self.next_vertex	# case of TVertex
	if type(tvertex) is TVertex:	vertex = self.next_vertex
	mateVE = tvertex.get_mate(self.current_edge)	if type(vertex) is TVertex:
	while not it.is_end:	for ve in it:
	ve = it.object	# case one
	feB = self.current_edge.last_fedge	vA = self.current_edge.last_fedge.second_svertex
	feA = ve.first_fedge	vB = ve.first_fedge.first_svertex
	vB = feB.second_svertex
	vA = feA.first_svertex
	if vA.id.first == vB.id.first:	if vA.id.first == vB.id.first:
	winner = ve	return ve
	break	# case two
	feA = self.current_edge.first_fedge	vA = self.current_edge.first_fedge.first_svertex
	feB = ve.last_fedge	vB = ve.last_fedge.second_svertex
	vB = feB.second_svertex
	vA = feA.first_svertex
	if vA.id.first == vB.id.first:	if vA.id.first == vB.id.first:
	winner = ve	return ve
	break	# case three
	feA = self.current_edge.last_fedge	vA = self.current_edge.last_fedge.second_svertex
	feB = ve.last_fedge	vB = ve.last_fedge.second_svertex
	vB = feB.second_svertex
	vA = feA.second_svertex
	if vA.id.first == vB.id.first:	if vA.id.first == vB.id.first:
	winner = ve	return ve
		kjym3Unsubmitted Not Done Inline Actions The original `qi != 0` seems more logical. kjym3: The original `qi != 0` seems more logical.
	break	# case four
	feA = self.current_edge.first_fedge	vA = self.current_edge.first_fedge.first_svertex
	feB = ve.first_fedge	vB = ve.first_fedge.first_svertex
	vB = feB.first_svertex
	vA = feA.first_svertex
	if vA.id.first == vB.id.first:	if vA.id.first == vB.id.first:
	winner = ve	return ve
	break	return None
	it.increment()	## case of NonTVertex
	else:	else:
	## case of NonTVertex	for i, nat in enumerate(NATURES):
	natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,	if (nat & self.current_edge.nature):
	Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]	for ve in it:
	for i in range(len(natures)):	ve_nat = ve.nature
	currentNature = self.current_edge.nature	if (ve_nat & nat):
	if (natures[i] & currentNature) != 0:	if (nat != ve_nat) and any(n & ve_nat for n in NATURES[:i]):
	count=0	break
	while not it.is_end:
	visitNext = 0	if winner is not None:
	oNature = it.object.nature	return
	if (oNature & natures[i]) != 0:
	if natures[i] != oNature:	winner = ve
	for j in range(i):	return winner
	if (natures[j] & oNature) != 0:	return None
	visitNext = 1
		kjym3Unsubmitted Not Done Inline Actions Please, consider add an explicit `return None` here. kjym3: Please, consider add an explicit `return None` here.
		kjym3Unsubmitted Not Done Inline Actions Is this comment block (lines 690-702) worth retaining here? kjym3: Is this comment block (lines 690-702) worth retaining here?
	break
	if visitNext != 0:
	break
	count = count+1
	winner = it.object
	it.increment()
	if count != 1:
	winner = None
	break
	return winner
Context not available.