archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Freestyle Python API improvements - part 4.

Browse Source 
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.
This commit is contained in:
Tamito Kajiyama
2013-02-16 14:21:40 +00:00
parent aa9c01f384
commit b35a893249
17 changed files with 1001 additions and 1074 deletions
Download Patch File Download Diff File Expand all files Collapse all files

297
release/scripts/freestyle/style_modules/ChainingIterators.py
View File

@@ -42,11 +42,11 @@ class pyChainSilhouetteIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
it = AdjacencyIterator(iter) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == mateVE.id: if ve.id == mateVE.id:
winner = ve winner = ve
break break
@@ -55,12 +55,12 @@ class pyChainSilhouetteIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for i in range(len(natures)): for i in range(len(natures)):
currentNature = self.getCurrentEdge().nature currentNature = self.current_edge.nature
if (natures[i] & currentNature) != 0: if (natures[i] & currentNature) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
visitNext = 0 visitNext = 0
oNature = it.getObject().nature oNature = it.object.nature
if (oNature & natures[i]) != 0: if (oNature & natures[i]) != 0:
if natures[i] != oNature: if natures[i] != oNature:
for j in range(i): for j in range(i):
@@ -70,7 +70,7 @@ class pyChainSilhouetteIterator(ChainingIterator):
if visitNext != 0: if visitNext != 0:
break break
count = count+1 count = count+1
winner = it.getObject() winner = it.object
it.increment() it.increment()
if count != 1: if count != 1:
winner = None winner = None
@@ -94,11 +94,11 @@ class pyChainSilhouetteGenericIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
it = AdjacencyIterator(iter) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == mateVE.id: if ve.id == mateVE.id:
winner = ve winner = ve
break break
@@ -107,14 +107,14 @@ class pyChainSilhouetteGenericIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for i in range(len(natures)): for i in range(len(natures)):
currentNature = self.getCurrentEdge().nature currentNature = self.current_edge.nature
if (natures[i] & currentNature) != 0: if (natures[i] & currentNature) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
visitNext = 0 visitNext = 0
oNature = it.getObject().nature oNature = it.object.nature
ve = it.getObject() ve = it.object
if ve.id == self.getCurrentEdge().id: if ve.id == self.current_edge.id:
it.increment() it.increment()
continue continue
if (oNature & natures[i]) != 0: if (oNature & natures[i]) != 0:
@@ -137,22 +137,19 @@ class pyExternalContourChainingIterator(ChainingIterator):
def __init__(self): def __init__(self):
ChainingIterator.__init__(self, 0, 1,None,1) ChainingIterator.__init__(self, 0, 1,None,1)
self._isExternalContour = ExternalContourUP1D() self._isExternalContour = ExternalContourUP1D()
def getExactTypeName(self): def getExactTypeName(self):
return "pyExternalContourIterator" return "pyExternalContourIterator"
def init(self): def init(self):
self._nEdges = 0 self._nEdges = 0
self._isInSelection = 1 self._isInSelection = 1
def checkViewEdge(self, ve, orientation): def checkViewEdge(self, ve, orientation):
if orientation != 0: if orientation != 0:
vertex = ve.second_svertex() vertex = ve.second_svertex()
else: else:
vertex = ve.first_svertex() vertex = ve.first_svertex()
it = AdjacencyIterator(vertex,1,1) it = AdjacencyIterator(vertex,1,1)
while not it.isEnd(): while not it.is_end:
ave = it.getObject() ave = it.object
if self._isExternalContour(ave): if self._isExternalContour(ave):
return 1 return 1
it.increment() it.increment()
@@ -161,8 +158,8 @@ class pyExternalContourChainingIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
it = AdjacencyIterator(iter) it = AdjacencyIterator(iter)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if self._isExternalContour(ve): if self._isExternalContour(ve):
if ve.time_stamp == GetTimeStampCF(): if ve.time_stamp == GetTimeStampCF():
winner = ve winner = ve
@@ -172,9 +169,9 @@ class pyExternalContourChainingIterator(ChainingIterator):
if winner is None: if winner is None:
orient = 1 orient = 1
it = AdjacencyIterator(iter) it = AdjacencyIterator(iter)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if it.isIncoming() != 0: # FIXME if it.is_incoming:
orient = 0 orient = 0
good = self.checkViewEdge(ve,orient) good = self.checkViewEdge(ve,orient)
if good != 0: if good != 0:
@@ -196,11 +193,11 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
it = AdjacencyIterator(iter) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == mateVE.id: if ve.id == mateVE.id:
winner = ve winner = ve
break break
@@ -209,14 +206,14 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for i in range(len(natures)): for i in range(len(natures)):
currentNature = self.getCurrentEdge().nature currentNature = self.current_edge.nature
if (natures[i] & currentNature) != 0: if (natures[i] & currentNature) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
visitNext = 0 visitNext = 0
oNature = it.getObject().nature oNature = it.object.nature
ve = it.getObject() ve = it.object
if ve.id == self.getCurrentEdge().id: if ve.id == self.current_edge.id:
it.increment() it.increment()
continue continue
if (oNature & natures[i]) != 0: if (oNature & natures[i]) != 0:
@@ -234,7 +231,7 @@ class pySketchyChainSilhouetteIterator(ChainingIterator):
winner = None winner = None
break break
if winner is None: if winner is None:
winner = self.getCurrentEdge() winner = self.current_edge
if winner.chaining_time_stamp == self._timeStamp: if winner.chaining_time_stamp == self._timeStamp:
winner = None winner = None
return winner return winner
@@ -250,22 +247,20 @@ class pySketchyChainingIterator(ChainingIterator):
self._nRounds = nRounds self._nRounds = nRounds
def getExactTypeName(self): def getExactTypeName(self):
return "pySketchyChainingIterator" return "pySketchyChainingIterator"
def init(self): def init(self):
self._timeStamp = GetTimeStampCF()+self._nRounds self._timeStamp = GetTimeStampCF()+self._nRounds
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
it = AdjacencyIterator(iter) it = AdjacencyIterator(iter)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == self.getCurrentEdge().id: if ve.id == self.current_edge.id:
it.increment() it.increment()
continue continue
winner = ve winner = ve
it.increment() it.increment()
if winner is None: if winner is None:
winner = self.getCurrentEdge() winner = self.current_edge
if winner.chaining_time_stamp == self._timeStamp: if winner.chaining_time_stamp == self._timeStamp:
return None return None
return winner return winner
@@ -290,16 +285,16 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
winnerOrientation = 0 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) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == mateVE.id: if ve.id == mateVE.id:
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -309,14 +304,14 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for nat in natures: for nat in natures:
if (self.getCurrentEdge().nature & nat) != 0: if (self.current_edge.nature & nat) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if (ve.nature & nat) != 0: if (ve.nature & nat) != 0:
count = count+1 count = count+1
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -335,24 +330,24 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
if self._length == 0: if self._length == 0:
#if not, let's do it #if not, let's do it
_it = pyChainSilhouetteGenericIterator(0,0) _it = pyChainSilhouetteGenericIterator(0,0)
_it.setBegin(winner) _it.begin = winner
_it.setCurrentEdge(winner) _it.current_edge = winner
_it.setOrientation(winnerOrientation) _it.orientation = winnerOrientation
_it.init() _it.init()
while not _it.isEnd(): while not _it.is_end:
ve = _it.getObject() ve = _it.object
#print("--------", ve.id.first, ve.id.second) #print("--------", ve.id.first, ve.id.second)
self._length = self._length + ve.length_2d self._length = self._length + ve.length_2d
_it.increment() _it.increment()
if _it.isBegin(): if _it.is_begin:
break; break;
_it.setBegin(winner) _it.begin = winner
_it.setCurrentEdge(winner) _it.current_edge = winner
_it.setOrientation(winnerOrientation) _it.orientation = winnerOrientation
if not _it.isBegin(): if not _it.is_begin:
_it.decrement() _it.decrement()
while (not _it.isEnd()) and (not _it.isBegin()): while (not _it.is_end) and (not _it.is_begin):
ve = _it.getObject() ve = _it.object
#print("--------", ve.id.first, ve.id.second) #print("--------", ve.id.first, ve.id.second)
self._length = self._length + ve.length_2d self._length = self._length + ve.length_2d
_it.decrement() _it.decrement()
@@ -361,12 +356,12 @@ class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
# nw let's compute the length of this connex non selected part: # nw let's compute the length of this connex non selected part:
connexl = 0 connexl = 0
_cit = pyChainSilhouetteGenericIterator(0,0) _cit = pyChainSilhouetteGenericIterator(0,0)
_cit.setBegin(winner) _cit.begin = winner
_cit.setCurrentEdge(winner) _cit.current_edge = winner
_cit.setOrientation(winnerOrientation) _cit.orientation = winnerOrientation
_cit.init() _cit.init()
while _cit.isEnd() == 0 and _cit.getObject().time_stamp != GetTimeStampCF(): while _cit.is_end == 0 and _cit.object.time_stamp != GetTimeStampCF():
ve = _cit.getObject() ve = _cit.object
#print("-------- --------", ve.id.first, ve.id.second) #print("-------- --------", ve.id.first, ve.id.second)
connexl = connexl + ve.length_2d connexl = connexl + ve.length_2d
_cit.increment() _cit.increment()
@@ -389,16 +384,16 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
winnerOrientation = 0 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) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == mateVE.id: if ve.id == mateVE.id:
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -408,14 +403,14 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for nat in natures: for nat in natures:
if (self.getCurrentEdge().nature & nat) != 0: if (self.current_edge.nature & nat) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if (ve.nature & nat) != 0: if (ve.nature & nat) != 0:
count = count+1 count = count+1
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -430,12 +425,12 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
# nw let's compute the length of this connex non selected part: # nw let's compute the length of this connex non selected part:
connexl = 0 connexl = 0
_cit = pyChainSilhouetteGenericIterator(0,0) _cit = pyChainSilhouetteGenericIterator(0,0)
_cit.setBegin(winner) _cit.begin = winner
_cit.setCurrentEdge(winner) _cit.current_edge = winner
_cit.setOrientation(winnerOrientation) _cit.orientation = winnerOrientation
_cit.init() _cit.init()
while _cit.isEnd() == 0 and _cit.getObject().time_stamp != GetTimeStampCF(): while _cit.is_end == 0 and _cit.object.time_stamp != GetTimeStampCF():
ve = _cit.getObject() ve = _cit.object
#print("-------- --------", ve.id.first, ve.id.second) #print("-------- --------", ve.id.first, ve.id.second)
connexl = connexl + ve.length_2d connexl = connexl + ve.length_2d
_cit.increment() _cit.increment()
@@ -464,16 +459,16 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
winnerOrientation = 0 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) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == mateVE.id: if ve.id == mateVE.id:
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -483,14 +478,14 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for nat in natures: for nat in natures:
if (self.getCurrentEdge().nature & nat) != 0: if (self.current_edge.nature & nat) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if (ve.nature & nat) != 0: if (ve.nature & nat) != 0:
count = count+1 count = count+1
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -509,24 +504,24 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
if self._length == 0: if self._length == 0:
#if not, let's do it #if not, let's do it
_it = pyChainSilhouetteGenericIterator(0,0) _it = pyChainSilhouetteGenericIterator(0,0)
_it.setBegin(winner) _it.begin = winner
_it.setCurrentEdge(winner) _it.current_edge = winner
_it.setOrientation(winnerOrientation) _it.orientation = winnerOrientation
_it.init() _it.init()
while not _it.isEnd(): while not _it.is_end:
ve = _it.getObject() ve = _it.object
#print("--------", ve.id.first, ve.id.second) #print("--------", ve.id.first, ve.id.second)
self._length = self._length + ve.length_2d self._length = self._length + ve.length_2d
_it.increment() _it.increment()
if _it.isBegin(): if _it.is_begin:
break; break;
_it.setBegin(winner) _it.begin = winner
_it.setCurrentEdge(winner) _it.current_edge = winner
_it.setOrientation(winnerOrientation) _it.orientation = winnerOrientation
if not _it.isBegin(): if not _it.is_begin:
_it.decrement() _it.decrement()
while (not _it.isEnd()) and (not _it.isBegin()): while (not _it.is_end) and (not _it.is_begin):
ve = _it.getObject() ve = _it.object
#print("--------", ve.id.first, ve.id.second) #print("--------", ve.id.first, ve.id.second)
self._length = self._length + ve.length_2d self._length = self._length + ve.length_2d
_it.decrement() _it.decrement()
@@ -535,12 +530,12 @@ class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
# nw let's compute the length of this connex non selected part: # nw let's compute the length of this connex non selected part:
connexl = 0 connexl = 0
_cit = pyChainSilhouetteGenericIterator(0,0) _cit = pyChainSilhouetteGenericIterator(0,0)
_cit.setBegin(winner) _cit.begin = winner
_cit.setCurrentEdge(winner) _cit.current_edge = winner
_cit.setOrientation(winnerOrientation) _cit.orientation = winnerOrientation
_cit.init() _cit.init()
while _cit.isEnd() == 0 and _cit.getObject().time_stamp != GetTimeStampCF(): while _cit.is_end == 0 and _cit.object.time_stamp != GetTimeStampCF():
ve = _cit.getObject() ve = _cit.object
#print("-------- --------", ve.id.first, ve.id.second) #print("-------- --------", ve.id.first, ve.id.second)
connexl = connexl + ve.length_2d connexl = connexl + ve.length_2d
_cit.increment() _cit.increment()
@@ -569,16 +564,16 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
winnerOrientation = 0 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) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if ve.id == mateVE.id: if ve.id == mateVE.id:
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -588,14 +583,14 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for nat in natures: for nat in natures:
if (self.getCurrentEdge().nature & nat) != 0: if (self.current_edge.nature & nat) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
if (ve.nature & nat) != 0: if (ve.nature & nat) != 0:
count = count+1 count = count+1
winner = ve winner = ve
if it.isIncoming() == 0: # FIXME if not it.is_incoming:
winnerOrientation = 1 winnerOrientation = 1
else: else:
winnerOrientation = 0 winnerOrientation = 0
@@ -614,24 +609,24 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
if self._length == 0: if self._length == 0:
#if not, let's do it #if not, let's do it
_it = pyChainSilhouetteGenericIterator(0,0) _it = pyChainSilhouetteGenericIterator(0,0)
_it.setBegin(winner) _it.begin = winner
_it.setCurrentEdge(winner) _it.current_edge = winner
_it.setOrientation(winnerOrientation) _it.orientation = winnerOrientation
_it.init() _it.init()
while not _it.isEnd(): while not _it.is_end:
ve = _it.getObject() ve = _it.object
#print("--------", ve.id.first, ve.id.second) #print("--------", ve.id.first, ve.id.second)
self._length = self._length + ve.length_2d self._length = self._length + ve.length_2d
_it.increment() _it.increment()
if _it.isBegin(): if _it.is_begin:
break; break;
_it.setBegin(winner) _it.begin = winner
_it.setCurrentEdge(winner) _it.current_edge = winner
_it.setOrientation(winnerOrientation) _it.orientation = winnerOrientation
if not _it.isBegin(): if not _it.is_begin:
_it.decrement() _it.decrement()
while (not _it.isEnd()) and (not _it.isBegin()): while (not _it.is_end) and (not _it.is_begin):
ve = _it.getObject() ve = _it.object
#print("--------", ve.id.first, ve.id.second) #print("--------", ve.id.first, ve.id.second)
self._length = self._length + ve.length_2d self._length = self._length + ve.length_2d
_it.decrement() _it.decrement()
@@ -640,12 +635,12 @@ class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
# nw let's compute the length of this connex non selected part: # nw let's compute the length of this connex non selected part:
connexl = 0 connexl = 0
_cit = pyChainSilhouetteGenericIterator(0,0) _cit = pyChainSilhouetteGenericIterator(0,0)
_cit.setBegin(winner) _cit.begin = winner
_cit.setCurrentEdge(winner) _cit.current_edge = winner
_cit.setOrientation(winnerOrientation) _cit.orientation = winnerOrientation
_cit.init() _cit.init()
while not _cit.isEnd() and _cit.getObject().qi != 0: while not _cit.is_end and _cit.object.qi != 0:
ve = _cit.getObject() ve = _cit.object
#print("-------- --------", ve.id.first, ve.id.second) #print("-------- --------", ve.id.first, ve.id.second)
connexl = connexl + ve.length_2d connexl = connexl + ve.length_2d
_cit.increment() _cit.increment()
@@ -669,33 +664,33 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator):
def traverse(self, iter): def traverse(self, iter):
winner = None winner = None
it = AdjacencyIterator(iter) it = AdjacencyIterator(iter)
tvertex = self.getVertex() tvertex = self.next_vertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
mateVE = tvertex.get_mate(self.getCurrentEdge()) mateVE = tvertex.get_mate(self.current_edge)
while not it.isEnd(): while not it.is_end:
ve = it.getObject() ve = it.object
feB = self.getCurrentEdge().last_fedge feB = self.current_edge.last_fedge
feA = ve.first_fedge feA = ve.first_fedge
vB = feB.second_svertex vB = feB.second_svertex
vA = feA.first_svertex vA = feA.first_svertex
if vA.id.first == vB.id.first: if vA.id.first == vB.id.first:
winner = ve winner = ve
break break
feA = self.getCurrentEdge().first_fedge feA = self.current_edge.first_fedge
feB = ve.last_fedge feB = ve.last_fedge
vB = feB.second_svertex vB = feB.second_svertex
vA = feA.first_svertex vA = feA.first_svertex
if vA.id.first == vB.id.first: if vA.id.first == vB.id.first:
winner = ve winner = ve
break break
feA = self.getCurrentEdge().last_fedge feA = self.current_edge.last_fedge
feB = ve.last_fedge feB = ve.last_fedge
vB = feB.second_svertex vB = feB.second_svertex
vA = feA.second_svertex vA = feA.second_svertex
if vA.id.first == vB.id.first: if vA.id.first == vB.id.first:
winner = ve winner = ve
break break
feA = self.getCurrentEdge().first_fedge feA = self.current_edge.first_fedge
feB = ve.first_fedge feB = ve.first_fedge
vB = feB.first_svertex vB = feB.first_svertex
vA = feA.first_svertex vA = feA.first_svertex
@@ -707,12 +702,12 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator):
## case of NonTVertex ## case of NonTVertex
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE] natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
for i in range(len(natures)): for i in range(len(natures)):
currentNature = self.getCurrentEdge().nature currentNature = self.current_edge.nature
if (natures[i] & currentNature) != 0: if (natures[i] & currentNature) != 0:
count=0 count=0
while not it.isEnd(): while not it.is_end:
visitNext = 0 visitNext = 0
oNature = it.getObject().nature oNature = it.object.nature
if (oNature & natures[i]) != 0: if (oNature & natures[i]) != 0:
if natures[i] != oNature: if natures[i] != oNature:
for j in range(i): for j in range(i):
@@ -722,7 +717,7 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator):
if visitNext != 0: if visitNext != 0:
break break
count = count+1 count = count+1
winner = it.getObject() winner = it.object
it.increment() it.increment()
if count != 1: if count != 1:
winner = None winner = None

8
release/scripts/freestyle/style_modules/Functions0D.py
View File

@@ -6,7 +6,7 @@ class CurveMaterialF0D(UnaryFunction0DMaterial):
def getName(self): def getName(self):
return "CurveMaterialF0D" return "CurveMaterialF0D"
def __call__(self, inter): def __call__(self, inter):
cp = inter.getObject() cp = inter.object
assert(isinstance(cp, CurvePoint)) assert(isinstance(cp, CurvePoint))
fe = cp.first_svertex.get_fedge(cp.second_svertex) fe = cp.first_svertex.get_fedge(cp.second_svertex)
assert(fe is not None) assert(fe is not None)
@@ -26,7 +26,7 @@ class pyCurvilinearLengthF0D(UnaryFunction0DDouble):
return "CurvilinearLengthF0D" return "CurvilinearLengthF0D"
def __call__(self, inter): def __call__(self, inter):
cp = inter.getObject() cp = inter.object
assert(isinstance(cp, CurvePoint)) assert(isinstance(cp, CurvePoint))
return cp.t2d return cp.t2d
@@ -66,7 +66,7 @@ class pyViewMapGradientVectorF0D(UnaryFunction0DVec2f):
def getName(self): def getName(self):
return "pyViewMapGradientVectorF0D" return "pyViewMapGradientVectorF0D"
def __call__(self, iter): 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)) 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)) 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]) return Vector([gx, gy])
@@ -79,7 +79,7 @@ class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
def getName(self): def getName(self):
return "pyViewMapGradientNormF0D" return "pyViewMapGradientNormF0D"
def __call__(self, iter): 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)) 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)) 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]) grad = Vector([gx, gy])

15
release/scripts/freestyle/style_modules/PredicatesU0D.py
View File

@@ -31,7 +31,7 @@ class pyVertexNatureUP0D(UnaryPredicate0D):
def getName(self): def getName(self):
return "pyVertexNatureUP0D" return "pyVertexNatureUP0D"
def __call__(self, inter): def __call__(self, inter):
v = inter.getObject() v = inter.object
return (v.nature & self._nature) != 0 return (v.nature & self._nature) != 0
## check whether an Interface0DIterator ## check whether an Interface0DIterator
@@ -44,14 +44,11 @@ class pyBackTVertexUP0D(UnaryPredicate0D):
def getName(self): def getName(self):
return "pyBackTVertexUP0D" return "pyBackTVertexUP0D"
def __call__(self, iter): def __call__(self, iter):
v = iter.getObject() if (iter.object.nature & Nature.T_VERTEX) == 0:
nat = v.nature
if (nat & Nature.T_VERTEX) == 0:
return 0 return 0
next = iter if iter.is_end:
if next.isEnd():
return 0 return 0
if self._getQI(next) != 0: if self._getQI(iter) != 0:
return 1 return 1
return 0 return 0
@@ -65,7 +62,7 @@ class pyParameterUP0DGoodOne(UnaryPredicate0D):
return "pyCurvilinearAbscissaHigherThanUP0D" return "pyCurvilinearAbscissaHigherThanUP0D"
def __call__(self, inter): def __call__(self, inter):
#s = self.getCurvilinearAbscissa(inter) #s = self.getCurvilinearAbscissa(inter)
u = inter.u() # FIXME u = inter.u
#print(u) #print(u)
return ((u>=self._m) and (u<=self._M)) return ((u>=self._m) and (u<=self._M))
@@ -82,7 +79,7 @@ class pyParameterUP0D(UnaryPredicate0D):
c = func(inter) c = func(inter)
b1 = (c>0.1) b1 = (c>0.1)
#s = self.getCurvilinearAbscissa(inter) #s = self.getCurvilinearAbscissa(inter)
u = inter.u() # FIXME u = inter.u
#print(u) #print(u)
b = ((u>=self._m) and (u<=self._M)) b = ((u>=self._m) and (u<=self._M))
return b and b1 return b and b1

18
release/scripts/freestyle/style_modules/PredicatesU1D.py
View File

@@ -45,7 +45,7 @@ class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
count = 0 count = 0
func = Curvature2DAngleF0D() func = Curvature2DAngleF0D()
it = inter.vertices_begin() it = inter.vertices_begin()
while not it.isEnd(): while not it.is_end:
if func(it) > self._a: if func(it) > self._a:
count = count+1 count = count+1
if count > self._n: if count > self._n:
@@ -198,14 +198,14 @@ class pyIsOccludedByUP1D(UnaryPredicate1D):
it = inter.vertices_begin() it = inter.vertices_begin()
itlast = inter.vertices_end() itlast = inter.vertices_end()
itlast.decrement() itlast.decrement()
v = it.getObject() v = it.object
vlast = itlast.getObject() vlast = itlast.object
tvertex = v.viewvertex tvertex = v.viewvertex
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
print("TVertex: [ ", tvertex.id.first, ",", tvertex.id.second," ]") print("TVertex: [ ", tvertex.id.first, ",", tvertex.id.second," ]")
eit = tvertex.edges_begin() eit = tvertex.edges_begin()
while not eit.isEnd(): while not eit.is_end:
ve, incoming = eit.getObject() ve, incoming = eit.object
if ve.id == self._id: if ve.id == self._id:
return 1 return 1
print("-------", ve.id.first, "-", ve.id.second) print("-------", ve.id.first, "-", ve.id.second)
@@ -214,8 +214,8 @@ class pyIsOccludedByUP1D(UnaryPredicate1D):
if type(tvertex) is TVertex: if type(tvertex) is TVertex:
print("TVertex: [ ", tvertex.id.first, ",", tvertex.id.second," ]") print("TVertex: [ ", tvertex.id.first, ",", tvertex.id.second," ]")
eit = tvertex.edges_begin() eit = tvertex.edges_begin()
while not eit.isEnd(): while not eit.is_end:
ve, incoming = eit.getObject() ve, incoming = eit.object
if ve.id == self._id: if ve.id == self._id:
return 1 return 1
print("-------", ve.id.first, "-", ve.id.second) print("-------", ve.id.first, "-", ve.id.second)
@@ -349,8 +349,8 @@ class pyClosedCurveUP1D(UnaryPredicate1D):
it = inter.vertices_begin() it = inter.vertices_begin()
itlast = inter.vertices_end() itlast = inter.vertices_end()
itlast.decrement() itlast.decrement()
vlast = itlast.getObject() vlast = itlast.object
v = it.getObject() v = it.object
print(v.id.first, v.id.second) print(v.id.first, v.id.second)
print(vlast.id.first, vlast.id.second) print(vlast.id.first, vlast.id.second)
if v.id == vlast.id: if v.id == vlast.id:

120
release/scripts/freestyle/style_modules/parameter_editor.py
View File

@@ -159,8 +159,8 @@ class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
return "BaseThicknessShader" return "BaseThicknessShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while it.isEnd() == 0: while not it.is_end:
sv = it.getObject() sv = it.object
self.set_thickness(sv, self.__outer, self.__inner) self.set_thickness(sv, self.__outer, self.__inner)
it.increment() it.increment()
@@ -170,9 +170,9 @@ def iter_t2d_along_stroke(stroke):
total = stroke.length_2d total = stroke.length_2d
distance = 0.0 distance = 0.0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
if not it.isBegin(): if not it.is_begin:
distance += (prev - p).length distance += (prev - p).length
prev = p prev = p
t = min(distance / total, 1.0) t = min(distance / total, 1.0)
@@ -184,7 +184,7 @@ class ColorAlongStrokeShader(ColorRampModifier):
return "ColorAlongStrokeShader" return "ColorAlongStrokeShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_t2d_along_stroke(stroke): for it, t in iter_t2d_along_stroke(stroke):
sv = it.getObject() sv = it.object
a = sv.attribute.color a = sv.attribute.color
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.color = self.blend_ramp(a, b) sv.attribute.color = self.blend_ramp(a, b)
@@ -194,7 +194,7 @@ class AlphaAlongStrokeShader(CurveMappingModifier):
return "AlphaAlongStrokeShader" return "AlphaAlongStrokeShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_t2d_along_stroke(stroke): for it, t in iter_t2d_along_stroke(stroke):
sv = it.getObject() sv = it.object
a = sv.attribute.alpha a = sv.attribute.alpha
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.alpha = self.blend(a, b) sv.attribute.alpha = self.blend(a, b)
@@ -210,7 +210,7 @@ class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
return "ThicknessAlongStrokeShader" return "ThicknessAlongStrokeShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_t2d_along_stroke(stroke): for it, t in iter_t2d_along_stroke(stroke):
sv = it.getObject() sv = it.object
a = sv.attribute.thickness a = sv.attribute.thickness
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
c = self.blend_thickness(a[0], a[1], b) 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): def iter_distance_from_camera(stroke, range_min, range_max):
normfac = range_max - range_min # normalization factor normfac = range_max - range_min # normalization factor
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point_3d # in the camera coordinate p = it.object.point_3d # in the camera coordinate
distance = p.length distance = p.length
if distance < range_min: if distance < range_min:
t = 0.0 t = 0.0
@@ -242,7 +242,7 @@ class ColorDistanceFromCameraShader(ColorRampModifier):
return "ColorDistanceFromCameraShader" return "ColorDistanceFromCameraShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max): 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 a = sv.attribute.color
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.color = self.blend_ramp(a, b) sv.attribute.color = self.blend_ramp(a, b)
@@ -256,7 +256,7 @@ class AlphaDistanceFromCameraShader(CurveMappingModifier):
return "AlphaDistanceFromCameraShader" return "AlphaDistanceFromCameraShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max): 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 a = sv.attribute.alpha
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.alpha = self.blend(a, b) sv.attribute.alpha = self.blend(a, b)
@@ -274,7 +274,7 @@ class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModif
return "ThicknessDistanceFromCameraShader" return "ThicknessDistanceFromCameraShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max): 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 a = sv.attribute.thickness
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
c = self.blend_thickness(a[0], a[1], b) 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 loc = mv * object.location # loc in the camera coordinate
normfac = range_max - range_min # normalization factor normfac = range_max - range_min # normalization factor
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point_3d # in the camera coordinate p = it.object.point_3d # in the camera coordinate
distance = (p - loc).length distance = (p - loc).length
if distance < range_min: if distance < range_min:
t = 0.0 t = 0.0
@@ -313,7 +313,7 @@ class ColorDistanceFromObjectShader(ColorRampModifier):
if self.__target is None: if self.__target is None:
return return
for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max): 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 a = sv.attribute.color
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.color = self.blend_ramp(a, b) sv.attribute.color = self.blend_ramp(a, b)
@@ -330,7 +330,7 @@ class AlphaDistanceFromObjectShader(CurveMappingModifier):
if self.__target is None: if self.__target is None:
return return
for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max): 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 a = sv.attribute.alpha
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.alpha = self.blend(a, b) sv.attribute.alpha = self.blend(a, b)
@@ -351,7 +351,7 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
if self.__target is None: if self.__target is None:
return return
for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max): 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 a = sv.attribute.thickness
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
c = self.blend_thickness(a[0], a[1], b) c = self.blend_thickness(a[0], a[1], b)
@@ -362,8 +362,8 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
def iter_material_color(stroke, material_attr): def iter_material_color(stroke, material_attr):
func = CurveMaterialF0D() func = CurveMaterialF0D()
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
material = func(it.castToInterface0DIterator()) material = func(it.cast_to_interface0diterator())
if material_attr == "DIFF": if material_attr == "DIFF":
color = (material.diffuse[0], color = (material.diffuse[0],
material.diffuse[1], material.diffuse[1],
@@ -380,8 +380,8 @@ def iter_material_color(stroke, material_attr):
def iter_material_value(stroke, material_attr): def iter_material_value(stroke, material_attr):
func = CurveMaterialF0D() func = CurveMaterialF0D()
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
material = func(it.castToInterface0DIterator()) material = func(it.cast_to_interface0diterator())
if material_attr == "DIFF": if material_attr == "DIFF":
r = material.diffuse[0] r = material.diffuse[0]
g = material.diffuse[1] g = material.diffuse[1]
@@ -423,12 +423,12 @@ class ColorMaterialShader(ColorRampModifier):
def shade(self, stroke): def shade(self, stroke):
if self.__material_attr in ["DIFF", "SPEC"] and not self.__use_ramp: if self.__material_attr in ["DIFF", "SPEC"] and not self.__use_ramp:
for it, b in iter_material_color(stroke, self.__material_attr): for it, b in iter_material_color(stroke, self.__material_attr):
sv = it.getObject() sv = it.object
a = sv.attribute.color a = sv.attribute.color
sv.attribute.color = self.blend_ramp(a, b) sv.attribute.color = self.blend_ramp(a, b)
else: else:
for it, t in iter_material_value(stroke, self.__material_attr): for it, t in iter_material_value(stroke, self.__material_attr):
sv = it.getObject() sv = it.object
a = sv.attribute.color a = sv.attribute.color
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.color = self.blend_ramp(a, b) sv.attribute.color = self.blend_ramp(a, b)
@@ -441,7 +441,7 @@ class AlphaMaterialShader(CurveMappingModifier):
return "AlphaMaterialShader" return "AlphaMaterialShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_material_value(stroke, self.__material_attr): for it, t in iter_material_value(stroke, self.__material_attr):
sv = it.getObject() sv = it.object
a = sv.attribute.alpha a = sv.attribute.alpha
b = self.evaluate(t) b = self.evaluate(t)
sv.attribute.alpha = self.blend(a, b) sv.attribute.alpha = self.blend(a, b)
@@ -458,7 +458,7 @@ class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
return "ThicknessMaterialShader" return "ThicknessMaterialShader"
def shade(self, stroke): def shade(self, stroke):
for it, t in iter_material_value(stroke, self.__material_attr): for it, t in iter_material_value(stroke, self.__material_attr):
sv = it.getObject() sv = it.object
a = sv.attribute.thickness a = sv.attribute.thickness
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
c = self.blend_thickness(a[0], a[1], b) c = self.blend_thickness(a[0], a[1], b)
@@ -477,12 +477,12 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
def shade(self, stroke): def shade(self, stroke):
func = VertexOrientation2DF0D() func = VertexOrientation2DF0D()
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
dir = func(it.castToInterface0DIterator()) dir = func(it.cast_to_interface0diterator())
orthDir = mathutils.Vector((-dir.y, dir.x)) orthDir = mathutils.Vector((-dir.y, dir.x))
orthDir.normalize() orthDir.normalize()
fac = abs(orthDir * self.__orientation) fac = abs(orthDir * self.__orientation)
sv = it.getObject() sv = it.object
a = sv.attribute.thickness a = sv.attribute.thickness
b = self.__min_thickness + fac * (self.__max_thickness - self.__min_thickness) b = self.__min_thickness + fac * (self.__max_thickness - self.__min_thickness)
b = max(b, 0.0) b = max(b, 0.0)
@@ -495,9 +495,9 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
def iter_distance_along_stroke(stroke): def iter_distance_along_stroke(stroke):
distance = 0.0 distance = 0.0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
if not it.isBegin(): if not it.is_begin:
distance += (prev - p).length distance += (prev - p).length
prev = p prev = p
yield it, distance yield it, distance
@@ -514,8 +514,8 @@ class SinusDisplacementShader(StrokeShader):
return "SinusDisplacementShader" return "SinusDisplacementShader"
def shade(self, stroke): def shade(self, stroke):
for it, distance in iter_distance_along_stroke(stroke): for it, distance in iter_distance_along_stroke(stroke):
v = it.getObject() v = it.object
n = self._getNormal(it.castToInterface0DIterator()) n = self._getNormal(it.cast_to_interface0diterator())
n = n * self._amplitude * math.cos(distance / self._wavelength * 2 * math.pi + self._phase) n = n * self._amplitude * math.cos(distance / self._wavelength * 2 * math.pi + self._phase)
v.point = v.point + n v.point = v.point + n
stroke.update_length() stroke.update_length()
@@ -533,8 +533,8 @@ class PerlinNoise1DShader(StrokeShader):
def shade(self, stroke): def shade(self, stroke):
length = stroke.length_2d length = stroke.length_2d
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
nres = self.__noise.turbulence1(length * v.u, self.__freq, self.__amp, self.__oct) nres = self.__noise.turbulence1(length * v.u, self.__freq, self.__amp, self.__oct)
v.point = v.point + nres * self.__dir v.point = v.point + nres * self.__dir
it.increment() it.increment()
@@ -552,8 +552,8 @@ class PerlinNoise2DShader(StrokeShader):
return "PerlinNoise2DShader" return "PerlinNoise2DShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
vec = Vector([v.projected_x, v.projected_y]) vec = Vector([v.projected_x, v.projected_y])
nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct) nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
v.point = v.point + nres * self.__dir v.point = v.point + nres * self.__dir
@@ -571,11 +571,11 @@ class Offset2DShader(StrokeShader):
return "Offset2DShader" return "Offset2DShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
u = v.u u = v.u
a = self.__start + u * (self.__end - self.__start) a = self.__start + u * (self.__end - self.__start)
n = self.__getNormal(it.castToInterface0DIterator()) n = self.__getNormal(it.cast_to_interface0diterator())
n = n * a n = n * a
v.point = v.point + n + self.__xy v.point = v.point + n + self.__xy
it.increment() it.increment()
@@ -597,17 +597,17 @@ class Transform2DShader(StrokeShader):
# determine the pivot of scaling and rotation operations # determine the pivot of scaling and rotation operations
if self.__pivot == "START": if self.__pivot == "START":
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
pivot = it.getObject().point pivot = it.object.point
elif self.__pivot == "END": elif self.__pivot == "END":
it = stroke.stroke_vertices_end() it = stroke.stroke_vertices_end()
it.decrement() it.decrement()
pivot = it.getObject().point pivot = it.object.point
elif self.__pivot == "PARAM": elif self.__pivot == "PARAM":
p = None p = None
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
prev = p prev = p
v = it.getObject() v = it.object
p = v.point p = v.point
u = v.u u = v.u
if self.__pivot_u < u: if self.__pivot_u < u:
@@ -622,8 +622,8 @@ class Transform2DShader(StrokeShader):
pivot = Vector([0.0, 0.0]) pivot = Vector([0.0, 0.0])
n = 0 n = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
pivot = pivot + p pivot = pivot + p
n = n + 1 n = n + 1
it.increment() it.increment()
@@ -635,8 +635,8 @@ class Transform2DShader(StrokeShader):
cos_theta = math.cos(self.__angle) cos_theta = math.cos(self.__angle)
sin_theta = math.sin(self.__angle) sin_theta = math.sin(self.__angle)
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
p = v.point p = v.point
p = p - pivot p = p - pivot
x = p.x * self.__scale_x x = p.x * self.__scale_x
@@ -687,8 +687,8 @@ class ObjectNamesUP1D(UnaryPredicate1D):
def iter_stroke_vertices(stroke): def iter_stroke_vertices(stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
prev_p = None prev_p = None
while not it.isEnd(): while not it.is_end:
sv = it.getObject() sv = it.object
p = sv.point p = sv.point
if prev_p is None or (prev_p - p).length > 1e-6: if prev_p is None or (prev_p - p).length > 1e-6:
yield sv yield sv
@@ -848,8 +848,8 @@ class DashedLineShader(StrokeShader):
visible = True visible = True
sampling = 1.0 sampling = 1.0
it = stroke.stroke_vertices_begin(sampling) it = stroke.stroke_vertices_begin(sampling)
while not it.isEnd(): while not it.is_end:
pos = it.t() pos = it.t # curvilinear abscissa
# The extra 'sampling' term is added below, because the # The extra 'sampling' term is added below, because the
# visibility attribute of the i-th vertex refers to the # visibility attribute of the i-th vertex refers to the
# visibility of the stroke segment between the i-th and # visibility of the stroke segment between the i-th and
@@ -860,7 +860,7 @@ class DashedLineShader(StrokeShader):
if index == len(self._pattern): if index == len(self._pattern):
index = 0 index = 0
visible = not visible visible = not visible
it.getObject().attribute.visible = visible it.object.attribute.visible = visible
it.increment() it.increment()
# predicates for chaining # predicates for chaining
@@ -955,17 +955,17 @@ class MaterialBoundaryUP0D(UnaryPredicate0D):
def getName(self): def getName(self):
return "MaterialBoundaryUP0D" return "MaterialBoundaryUP0D"
def __call__(self, it): def __call__(self, it):
if it.isBegin(): if it.is_begin:
return False return False
it_prev = Interface0DIterator(it) it_prev = Interface0DIterator(it)
it_prev.decrement() it_prev.decrement()
v = it.getObject() v = it.object
it.increment() it.increment()
if it.isEnd(): if it.is_end:
return False 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 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 idx2 = fe.material_index if fe.is_smooth else fe.material_index_left
return idx1 != idx2 return idx1 != idx2
@@ -993,7 +993,7 @@ class Length2DThresholdUP0D(UnaryPredicate0D):
def getName(self): def getName(self):
return "Length2DThresholdUP0D" return "Length2DThresholdUP0D"
def __call__(self, inter): def __call__(self, inter):
t = inter.t() # curvilinear abscissa t = inter.t # curvilinear abscissa
if t < self._t: if t < self._t:
self._t = 0.0 self._t = 0.0
return False return False

18
release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py
View File

@@ -33,24 +33,6 @@ from PredicatesU1D import *
from PredicatesU0D import * from PredicatesU0D import *
from Functions0D 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) upred = QuantitativeInvisibilityUP1D(0)
Operators.select(upred) Operators.select(upred)
Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred)) Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))

304
release/scripts/freestyle/style_modules/shaders.py
View File

@@ -24,10 +24,10 @@ class pyDepthDiscontinuityThicknessShader(StrokeShader):
a = (self.__max - self.__min)/(z_max-z_min) a = (self.__max - self.__min)/(z_max-z_min)
b = (self.__min*z_max-self.__max*z_min)/(z_max-z_min) b = (self.__min*z_max-self.__max*z_min)/(z_max-z_min)
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
z = self.__func(it.castToInterface0DIterator()) z = self.__func(it.cast_to_interface0diterator())
thickness = a*z+b thickness = a*z+b
it.getObject().attribute.thickness = (thickness, thickness) it.object.attribute.thickness = (thickness, thickness)
it.increment() it.increment()
class pyConstantThicknessShader(StrokeShader): class pyConstantThicknessShader(StrokeShader):
@@ -38,9 +38,9 @@ class pyConstantThicknessShader(StrokeShader):
return "pyConstantThicknessShader" return "pyConstantThicknessShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
t = self._thickness/2.0 t = self._thickness/2.0
it.getObject().attribute.thickness = (t, t) it.object.attribute.thickness = (t, t)
it.increment() it.increment()
class pyFXSThicknessShader(StrokeShader): class pyFXSThicknessShader(StrokeShader):
@@ -51,9 +51,9 @@ class pyFXSThicknessShader(StrokeShader):
return "pyFXSThicknessShader" return "pyFXSThicknessShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
t = self._thickness/2.0 t = self._thickness/2.0
it.getObject().attribute.thickness = (t, t) it.object.attribute.thickness = (t, t)
it.increment() it.increment()
class pyFXSVaryingThicknessWithDensityShader(StrokeShader): class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
@@ -71,8 +71,8 @@ class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
i = 0 i = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
func = DensityF0D(self.wsize) func = DensityF0D(self.wsize)
while not it.isEnd(): while not it.is_end:
toto = it.castToInterface0DIterator() toto = it.cast_to_interface0diterator()
c= func(toto) c= func(toto)
if c < self.threshold_min: if c < self.threshold_min:
c = self.threshold_min c = self.threshold_min
@@ -80,7 +80,7 @@ class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
c = self.threshold_max c = self.threshold_max
## t = (c - self.threshold_min)/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin ## t = (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 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 i = i+1
it.increment() it.increment()
@@ -95,13 +95,13 @@ class pyIncreasingThicknessShader(StrokeShader):
n = stroke.stroke_vertices_size() n = stroke.stroke_vertices_size()
i = 0 i = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
c = float(i)/float(n) c = float(i)/float(n)
if i < float(n)/2.0: if i < float(n)/2.0:
t = (1.0 - c)*self._thicknessMin + c * self._thicknessMax t = (1.0 - c)*self._thicknessMin + c * self._thicknessMax
else: else:
t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin 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 i = i+1
it.increment() it.increment()
@@ -124,8 +124,8 @@ class pyConstrainedIncreasingThicknessShader(StrokeShader):
n = stroke.stroke_vertices_size() n = stroke.stroke_vertices_size()
i = 0 i = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
att = it.getObject().attribute att = it.object.attribute
c = float(i)/float(n) c = float(i)/float(n)
if i < float(n)/2.0: if i < float(n)/2.0:
t = (1.0 - c)*self._thicknessMin + c * maxT t = (1.0 - c)*self._thicknessMin + c * maxT
@@ -155,10 +155,10 @@ class pyDecreasingThicknessShader(StrokeShader):
n = stroke.stroke_vertices_size() n = stroke.stroke_vertices_size()
i = 0 i = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
c = float(i)/float(n) c = float(i)/float(n)
t = (1.0 - c)*tMax +c*tMin 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 i = i+1
it.increment() it.increment()
@@ -178,14 +178,14 @@ class pyNonLinearVaryingThicknessShader(StrokeShader):
n = stroke.stroke_vertices_size() n = stroke.stroke_vertices_size()
i = 0 i = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
if i < float(n)/2.0: if i < float(n)/2.0:
c = float(i)/float(n) c = float(i)/float(n)
else: else:
c = float(n-i)/float(n) c = float(n-i)/float(n)
c = smoothC(c, self._exponent) c = smoothC(c, self._exponent)
t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin 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 i = i+1
it.increment() it.increment()
@@ -207,13 +207,13 @@ class pySLERPThicknessShader(StrokeShader):
n = stroke.stroke_vertices_size() n = stroke.stroke_vertices_size()
i = 0 i = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
c = float(i)/float(n) c = float(i)/float(n)
if i < float(n)/2.0: 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 t = sin((1-c)*self._omega)/sinh(self._omega)*self._thicknessMin + sin(c*self._omega)/sinh(self._omega) * maxT
else: else:
t = sin((1-c)*self._omega)/sinh(self._omega)*maxT + sin(c*self._omega)/sinh(self._omega) * self._thicknessMin 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 i = i+1
it.increment() it.increment()
@@ -227,39 +227,39 @@ class pyTVertexThickenerShader(StrokeShader): ## FIXME
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX) predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)
while not it.isEnd(): while not it.is_end:
if predTVertex(it) == 1: if predTVertex(it) == 1:
it2 = StrokeVertexIterator(it) it2 = StrokeVertexIterator(it)
it2.increment() it2.increment()
if not (it.isBegin() or it2.isEnd()): if not (it.is_begin or it2.is_end):
it.increment() it.increment()
continue continue
n = self._n n = self._n
a = self._a a = self._a
if it.isBegin(): if it.is_begin:
it3 = StrokeVertexIterator(it) it3 = StrokeVertexIterator(it)
count = 0 count = 0
while (not it3.isEnd()) and count < n: while (not it3.is_end) and count < n:
att = it3.getObject().attribute att = it3.object.attribute
(tr, tl) = att.thickness (tr, tl) = att.thickness
r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1 r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
#r = (1.0-a)/float(n-1)*count + a #r = (1.0-a)/float(n-1)*count + a
att.thickness = (r*tr, r*tl) att.thickness = (r*tr, r*tl)
it3.increment() it3.increment()
count = count + 1 count = count + 1
if it2.isEnd(): if it2.is_end:
it4 = StrokeVertexIterator(it) it4 = StrokeVertexIterator(it)
count = 0 count = 0
while (not it4.isBegin()) and count < n: while (not it4.is_begin) and count < n:
att = it4.getObject().attribute att = it4.object.attribute
(tr, tl) = att.thickness (tr, tl) = att.thickness
r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1 r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
#r = (1.0-a)/float(n-1)*count + a #r = (1.0-a)/float(n-1)*count + a
att.thickness = (r*tr, r*tl) att.thickness = (r*tr, r*tl)
it4.decrement() it4.decrement()
count = count + 1 count = count + 1
if it4.isBegin(): if it4.is_begin:
att = it4.getObject().attribute att = it4.object.attribute
(tr, tl) = att.thickness (tr, tl) = att.thickness
r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1 r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
#r = (1.0-a)/float(n-1)*count + a #r = (1.0-a)/float(n-1)*count + a
@@ -279,8 +279,8 @@ class pyImportance2DThicknessShader(StrokeShader):
def shade(self, stroke): def shade(self, stroke):
origin = Vector([self._x, self._y]) origin = Vector([self._x, self._y])
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
p = Vector([v.projected_x, v.projected_y]) p = Vector([v.projected_x, v.projected_y])
d = (p-origin).length d = (p-origin).length
if d > self._w: if d > self._w:
@@ -306,8 +306,8 @@ class pyImportance3DThicknessShader(StrokeShader):
def shade(self, stroke): def shade(self, stroke):
origin = Vector([self._x, self._y, self._z]) origin = Vector([self._x, self._y, self._z])
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
p = v.point_3d p = v.point_3d
d = (p-origin).length d = (p-origin).length
if d > self._w: if d > self._w:
@@ -331,8 +331,8 @@ class pyZDependingThicknessShader(StrokeShader):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
z_min = 1 z_min = 1
z_max = 0 z_max = 0
while not it.isEnd(): while not it.is_end:
z = self.__func(it.castToInterface0DIterator()) z = self.__func(it.cast_to_interface0diterator())
if z < z_min: if z < z_min:
z_min = z z_min = z
if z > z_max: if z > z_max:
@@ -340,10 +340,10 @@ class pyZDependingThicknessShader(StrokeShader):
it.increment() it.increment()
z_diff = 1 / (z_max - z_min) z_diff = 1 / (z_max - z_min)
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
z = (self.__func(it.castToInterface0DIterator()) - z_min) * z_diff z = (self.__func(it.cast_to_interface0diterator()) - z_min) * z_diff
thickness = (1 - z) * self.__max + z * self.__min thickness = (1 - z) * self.__max + z * self.__min
it.getObject().attribute.thickness = (thickness, thickness) it.object.attribute.thickness = (thickness, thickness)
it.increment() it.increment()
@@ -361,8 +361,8 @@ class pyConstantColorShader(StrokeShader):
return "pyConstantColorShader" return "pyConstantColorShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
att = it.getObject().attribute att = it.object.attribute
att.color = (self._r, self._g, self._b) att.color = (self._r, self._g, self._b)
att.alpha = self._a att.alpha = self._a
it.increment() it.increment()
@@ -379,8 +379,8 @@ class pyIncreasingColorShader(StrokeShader):
n = stroke.stroke_vertices_size() - 1 n = stroke.stroke_vertices_size() - 1
inc = 0 inc = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
att = it.getObject().attribute att = it.object.attribute
c = float(inc)/float(n) c = float(inc)/float(n)
att.color = ((1-c)*self._c1[0] + c*self._c2[0], att.color = ((1-c)*self._c1[0] + c*self._c2[0],
@@ -402,8 +402,8 @@ class pyInterpolateColorShader(StrokeShader):
n = stroke.stroke_vertices_size() - 1 n = stroke.stroke_vertices_size() - 1
inc = 0 inc = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
att = it.getObject().attribute att = it.object.attribute
u = float(inc)/float(n) u = float(inc)/float(n)
c = 1-2*(fabs(u-0.5)) c = 1-2*(fabs(u-0.5))
att.color = ((1-c)*self._c1[0] + c*self._c2[0], att.color = ((1-c)*self._c1[0] + c*self._c2[0],
@@ -427,8 +427,8 @@ class pyMaterialColorShader(StrokeShader):
Yn = 1.0 Yn = 1.0
un = 4.* xn/ ( -2.*xn + 12.*yn + 3. ) un = 4.* xn/ ( -2.*xn + 12.*yn + 3. )
vn= 9.* yn/ ( -2.*xn + 12.*yn +3. ) vn= 9.* yn/ ( -2.*xn + 12.*yn +3. )
while not it.isEnd(): while not it.is_end:
toto = it.castToInterface0DIterator() toto = it.cast_to_interface0diterator()
mat = func(toto) mat = func(toto)
r = mat.diffuse[0] r = mat.diffuse[0]
@@ -472,7 +472,7 @@ class pyMaterialColorShader(StrokeShader):
g = max(0,g) g = max(0,g)
b = max(0,b) b = max(0,b)
it.getObject().attribute.color = (r, g, b) it.object.attribute.color = (r, g, b)
it.increment() it.increment()
class pyRandomColorShader(StrokeShader): class pyRandomColorShader(StrokeShader):
@@ -488,8 +488,8 @@ class pyRandomColorShader(StrokeShader):
c2 = float(uniform(15,75))/100.0 c2 = float(uniform(15,75))/100.0
print(c0, c1, c2) print(c0, c1, c2)
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
it.getObject().attribute.color = (c0,c1,c2) it.object.attribute.color = (c0,c1,c2)
it.increment() it.increment()
class py2DCurvatureColorShader(StrokeShader): class py2DCurvatureColorShader(StrokeShader):
@@ -498,12 +498,12 @@ class py2DCurvatureColorShader(StrokeShader):
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
func = Curvature2DAngleF0D() func = Curvature2DAngleF0D()
while not it.isEnd(): while not it.is_end:
c = func(it.castToInterface0DIterator()) c = func(it.cast_to_interface0diterator())
if c < 0: if c < 0:
print("negative 2D curvature") print("negative 2D curvature")
color = 10.0 * c/3.1415 color = 10.0 * c/3.1415
it.getObject().attribute.color = (color, color, color) it.object.attribute.color = (color, color, color)
it.increment() it.increment()
class pyTimeColorShader(StrokeShader): class pyTimeColorShader(StrokeShader):
@@ -514,8 +514,8 @@ class pyTimeColorShader(StrokeShader):
def shade(self, stroke): def shade(self, stroke):
c = self._t*1.0 c = self._t*1.0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
it.getObject().attribute.color = (c,c,c) it.object.attribute.color = (c,c,c)
it.increment() it.increment()
self._t = self._t+self._step self._t = self._t+self._step
@@ -545,10 +545,10 @@ class pyBackboneStretcherShader(StrokeShader):
itn.decrement() itn.decrement()
itn_1 = StrokeVertexIterator(itn) itn_1 = StrokeVertexIterator(itn)
itn_1.decrement() itn_1.decrement()
v0 = it0.getObject() v0 = it0.object
v1 = it1.getObject() v1 = it1.object
vn_1 = itn_1.getObject() vn_1 = itn_1.object
vn = itn.getObject() vn = itn.object
p0 = Vector([v0.projected_x, v0.projected_y]) p0 = Vector([v0.projected_x, v0.projected_y])
pn = Vector([vn.projected_x, vn.projected_y]) pn = Vector([vn.projected_x, vn.projected_y])
p1 = Vector([v1.projected_x, v1.projected_y]) p1 = Vector([v1.projected_x, v1.projected_y])
@@ -579,10 +579,10 @@ class pyLengthDependingBackboneStretcherShader(StrokeShader):
itn.decrement() itn.decrement()
itn_1 = StrokeVertexIterator(itn) itn_1 = StrokeVertexIterator(itn)
itn_1.decrement() itn_1.decrement()
v0 = it0.getObject() v0 = it0.object
v1 = it1.getObject() v1 = it1.object
vn_1 = itn_1.getObject() vn_1 = itn_1.object
vn = itn.getObject() vn = itn.object
p0 = Vector([v0.projected_x, v0.projected_y]) p0 = Vector([v0.projected_x, v0.projected_y])
pn = Vector([vn.projected_x, vn.projected_y]) pn = Vector([vn.projected_x, vn.projected_y])
p1 = Vector([v1.projected_x, v1.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 it = stroke.stroke_vertices_begin() ## get the first vertex
itlast = stroke.stroke_vertices_end() ## itlast = stroke.stroke_vertices_end() ##
itlast.decrement() ## get the last one 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) ## 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() ## itmiddle.increment() ##
it = StrokeVertexIterator(itmiddle) it = StrokeVertexIterator(itmiddle)
it.increment() it.increment()
while not it.isEnd(): ## position all the vertices along the tangent for the right part while not it.is_end: ## position all the vertices along the tangent for the right part
it.getObject().point = itmiddle.getObject().point \ it.object.point = itmiddle.object.point \
+t*(it.getObject().u-itmiddle.getObject().u) +t*(it.object.u-itmiddle.object.u)
it.increment() it.increment()
it = StrokeVertexIterator(itmiddle) it = StrokeVertexIterator(itmiddle)
it.decrement() it.decrement()
while not it.isBegin(): ## position all the vertices along the tangent for the left part while not it.is_begin: ## position all the vertices along the tangent for the left part
it.getObject().point = itmiddle.getObject().point \ it.object.point = itmiddle.object.point \
-t*(itmiddle.getObject().u-it.getObject().u) -t*(itmiddle.object.u-it.object.u)
it.decrement() 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() stroke.update_length()
@@ -641,8 +641,8 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
itn.decrement() itn.decrement()
itn_1 = StrokeVertexIterator(itn) itn_1 = StrokeVertexIterator(itn)
itn_1.decrement() itn_1.decrement()
v0 = it0.getObject() v0 = it0.object
v1 = it1.getObject() v1 = it1.object
if (v0.nature & Nature.CUSP) == 0 and (v1.nature & Nature.CUSP) == 0: if (v0.nature & Nature.CUSP) == 0 and (v1.nature & Nature.CUSP) == 0:
p0 = v0.point p0 = v0.point
p1 = v1.point p1 = v1.point
@@ -650,8 +650,8 @@ class pyBackboneStretcherNoCuspShader(StrokeShader):
d1.normalize() d1.normalize()
newFirst = p0+d1*float(self._l) newFirst = p0+d1*float(self._l)
v0.point = newFirst v0.point = newFirst
vn_1 = itn_1.getObject() vn_1 = itn_1.object
vn = itn.getObject() vn = itn.object
if (vn.nature & Nature.CUSP) == 0 and (vn_1.nature & Nature.CUSP) == 0: if (vn.nature & Nature.CUSP) == 0 and (vn_1.nature & Nature.CUSP) == 0:
pn = vn.point pn = vn.point
pn_1 = vn_1.point pn_1 = vn_1.point
@@ -677,10 +677,10 @@ class pyDiffusion2Shader(StrokeShader):
def shade(self, stroke): def shade(self, stroke):
for i in range (1, self._nbIter): for i in range (1, self._nbIter):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
p1 = v.point 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 v.point = p1+p2
it.increment() it.increment()
stroke.update_length() stroke.update_length()
@@ -698,8 +698,8 @@ class pyTipRemoverShader(StrokeShader):
verticesToRemove = [] verticesToRemove = []
oldAttributes = [] oldAttributes = []
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
if v.curvilinear_abscissa < self._l or v.stroke_length-v.curvilinear_abscissa < self._l: if v.curvilinear_abscissa < self._l or v.stroke_length-v.curvilinear_abscissa < self._l:
verticesToRemove.append(v) verticesToRemove.append(v)
oldAttributes.append(StrokeAttribute(v.attribute)) oldAttributes.append(StrokeAttribute(v.attribute))
@@ -714,9 +714,9 @@ class pyTipRemoverShader(StrokeShader):
print("pyTipRemover: Warning: resampling problem") print("pyTipRemover: Warning: resampling problem")
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
for a in oldAttributes: for a in oldAttributes:
if it.isEnd(): if it.is_end:
break break
it.getObject().attribute = a it.object.attribute = a
it.increment() it.increment()
stroke.update_length() stroke.update_length()
@@ -731,9 +731,9 @@ class pyTVertexRemoverShader(StrokeShader):
itlast = stroke.stroke_vertices_end() itlast = stroke.stroke_vertices_end()
itlast.decrement() itlast.decrement()
if predTVertex(it): if predTVertex(it):
stroke.remove_vertex(it.getObject()) stroke.remove_vertex(it.object)
if predTVertex(itlast): if predTVertex(itlast):
stroke.remove_vertex(itlast.getObject()) stroke.remove_vertex(itlast.object)
stroke.update_length() stroke.update_length()
class pyExtremitiesOrientationShader(StrokeShader): class pyExtremitiesOrientationShader(StrokeShader):
@@ -762,12 +762,12 @@ class pyHLRShader(StrokeShader):
invisible = 0 invisible = 0
it2 = StrokeVertexIterator(it) it2 = StrokeVertexIterator(it)
it2.increment() it2.increment()
fe = get_fedge(it.getObject(), it2.getObject()) fe = get_fedge(it.object, it2.object)
if fe.viewedge.qi != 0: if fe.viewedge.qi != 0:
invisible = 1 invisible = 1
while not it2.isEnd(): while not it2.is_end:
v = it.getObject() v = it.object
vnext = it2.getObject() vnext = it2.object
if (v.nature & Nature.VIEW_VERTEX) != 0: if (v.nature & Nature.VIEW_VERTEX) != 0:
#if (v.nature & Nature.T_VERTEX) != 0: #if (v.nature & Nature.T_VERTEX) != 0:
fe = get_fedge(v, vnext) fe = get_fedge(v, vnext)
@@ -795,10 +795,10 @@ class pyTVertexOrientationShader(StrokeShader):
ait = AdjacencyIterator(tv,1,0) ait = AdjacencyIterator(tv,1,0)
winner = None winner = None
incoming = True incoming = True
while not ait.isEnd(): while not ait.is_end:
ave = ait.getObject() ave = ait.object
if ave.id != ve.id and ave.id != mateVE.id: if ave.id != ve.id and ave.id != mateVE.id:
winner = ait.getObject() winner = ait.object
if not ait.isIncoming(): # FIXME if not ait.isIncoming(): # FIXME
incoming = False incoming = False
break break
@@ -821,18 +821,18 @@ class pyTVertexOrientationShader(StrokeShader):
it2 = StrokeVertexIterator(it) it2 = StrokeVertexIterator(it)
it2.increment() it2.increment()
## case where the first vertex is a TVertex ## case where the first vertex is a TVertex
v = it.getObject() v = it.object
if (v.nature & Nature.T_VERTEX) != 0: if (v.nature & Nature.T_VERTEX) != 0:
tv = self.castToTVertex(v) tv = self.castToTVertex(v)
if tv is not None: if tv is not None:
ve = get_fedge(v, it2.getObject()).viewedge ve = get_fedge(v, it2.object).viewedge
dir = self.findOrientation(tv, ve) dir = self.findOrientation(tv, ve)
if dir is not None: if dir is not None:
#print(dir.x, dir.y) #print(dir.x, dir.y)
v.attribute.set_attribute_vec2("orientation", dir) v.attribute.set_attribute_vec2("orientation", dir)
while not it2.isEnd(): while not it2.is_end:
vprevious = it.getObject() vprevious = it.object
v = it2.getObject() v = it2.object
if (v.nature & Nature.T_VERTEX) != 0: if (v.nature & Nature.T_VERTEX) != 0:
tv = self.castToTVertex(v) tv = self.castToTVertex(v)
if tv is not None: if tv is not None:
@@ -844,13 +844,13 @@ class pyTVertexOrientationShader(StrokeShader):
it.increment() it.increment()
it2.increment() it2.increment()
## case where the last vertex is a TVertex ## case where the last vertex is a TVertex
v = it.getObject() v = it.object
if (v.nature & Nature.T_VERTEX) != 0: if (v.nature & Nature.T_VERTEX) != 0:
itPrevious = StrokeVertexIterator(it) itPrevious = StrokeVertexIterator(it)
itPrevious.decrement() itPrevious.decrement()
tv = self.castToTVertex(v) tv = self.castToTVertex(v)
if tv is not None: if tv is not None:
ve = get_fedge(itPrevious.getObject(), v).viewedge ve = get_fedge(itPrevious.object, v).viewedge
dir = self.findOrientation(tv, ve) dir = self.findOrientation(tv, ve)
if dir is not None: if dir is not None:
#print(dir.x, dir.y) #print(dir.x, dir.y)
@@ -866,10 +866,10 @@ class pySinusDisplacementShader(StrokeShader):
return "pySinusDisplacementShader" return "pySinusDisplacementShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
#print(self._getNormal.getName()) #print(self._getNormal.getName())
n = self._getNormal(it.castToInterface0DIterator()) n = self._getNormal(it.cast_to_interface0diterator())
p = v.point p = v.point
u = v.u u = v.u
a = self._a*(1-2*(fabs(u-0.5))) a = self._a*(1-2*(fabs(u-0.5)))
@@ -891,8 +891,8 @@ class pyPerlinNoise1DShader(StrokeShader):
return "pyPerlinNoise1DShader" return "pyPerlinNoise1DShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
i = v.projected_x + v.projected_y i = v.projected_x + v.projected_y
nres = self.__noise.turbulence1(i, self.__freq, self.__amp, self.__oct) nres = self.__noise.turbulence1(i, self.__freq, self.__amp, self.__oct)
v.point = (v.projected_x + nres, v.projected_y + nres) v.point = (v.projected_x + nres, v.projected_y + nres)
@@ -910,8 +910,8 @@ class pyPerlinNoise2DShader(StrokeShader):
return "pyPerlinNoise2DShader" return "pyPerlinNoise2DShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
v = it.getObject() v = it.object
vec = Vector([v.projected_x, v.projected_y]) vec = Vector([v.projected_x, v.projected_y])
nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct) nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
v.point = (v.projected_x + nres, v.projected_y + nres) v.point = (v.projected_x + nres, v.projected_y + nres)
@@ -928,12 +928,12 @@ class pyBluePrintCirclesShader(StrokeShader):
return "pyBluePrintCirclesShader" return "pyBluePrintCirclesShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
if it.isEnd(): if it.is_end:
return return
p_min = it.getObject().point.copy() p_min = it.object.point.copy()
p_max = it.getObject().point.copy() p_max = it.object.point.copy()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
if p.x < p_min.x: if p.x < p_min.x:
p_min.x = p.x p_min.x = p.x
if p.x > p_max.x: if p.x > p_max.x:
@@ -964,19 +964,19 @@ class pyBluePrintCirclesShader(StrokeShader):
prev_center = center prev_center = center
radius = radius + randint(-R, R) radius = radius + randint(-R, R)
center = center + Vector([randint(-C, C), randint(-C, C)]) 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) t = float(i) / float(sv_nb - 1)
r = prev_radius + (radius - prev_radius) * t r = prev_radius + (radius - prev_radius) * t
c = prev_center + (center - prev_center) * t c = prev_center + (center - prev_center) * t
p_new.x = c.x + r * cos(2 * pi * t) p_new.x = c.x + r * cos(2 * pi * t)
p_new.y = c.y + r * sin(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 i = i + 1
it.increment() it.increment()
i = 1 i = 1
verticesToRemove = [] verticesToRemove = []
while not it.isEnd(): while not it.is_end:
verticesToRemove.append(it.getObject()) verticesToRemove.append(it.object)
it.increment() it.increment()
for sv in verticesToRemove: for sv in verticesToRemove:
stroke.remove_vertex(sv) stroke.remove_vertex(sv)
@@ -992,12 +992,12 @@ class pyBluePrintEllipsesShader(StrokeShader):
return "pyBluePrintEllipsesShader" return "pyBluePrintEllipsesShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
if it.isEnd(): if it.is_end:
return return
p_min = it.getObject().point.copy() p_min = it.object.point.copy()
p_max = it.getObject().point.copy() p_max = it.object.point.copy()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
if p.x < p_min.x: if p.x < p_min.x:
p_min.x = p.x p_min.x = p.x
if p.x > p_max.x: if p.x > p_max.x:
@@ -1023,19 +1023,19 @@ class pyBluePrintEllipsesShader(StrokeShader):
prev_center = center prev_center = center
radius = radius + Vector([randint(-R, R), randint(-R, R)]) radius = radius + Vector([randint(-R, R), randint(-R, R)])
center = center + Vector([randint(-C, C), randint(-C, C)]) 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) t = float(i) / float(sv_nb - 1)
r = prev_radius + (radius - prev_radius) * t r = prev_radius + (radius - prev_radius) * t
c = prev_center + (center - prev_center) * t c = prev_center + (center - prev_center) * t
p_new.x = c.x + r.x * cos(2 * pi * t) p_new.x = c.x + r.x * cos(2 * pi * t)
p_new.y = c.y + r.y * sin(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 i = i + 1
it.increment() it.increment()
i = 1 i = 1
verticesToRemove = [] verticesToRemove = []
while not it.isEnd(): while not it.is_end:
verticesToRemove.append(it.getObject()) verticesToRemove.append(it.object)
it.increment() it.increment()
for sv in verticesToRemove: for sv in verticesToRemove:
stroke.remove_vertex(sv) stroke.remove_vertex(sv)
@@ -1052,12 +1052,12 @@ class pyBluePrintSquaresShader(StrokeShader):
return "pyBluePrintSquaresShader" return "pyBluePrintSquaresShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
if it.isEnd(): if it.is_end:
return return
p_min = it.getObject().point.copy() p_min = it.object.point.copy()
p_max = it.getObject().point.copy() p_max = it.object.point.copy()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
if p.x < p_min.x: if p.x < p_min.x:
p_min.x = p.x p_min.x = p.x
if p.x > p_max.x: if p.x > p_max.x:
@@ -1102,7 +1102,7 @@ class pyBluePrintSquaresShader(StrokeShader):
vec_third = p_third_end - p_third vec_third = p_third_end - p_third
vec_fourth = p_fourth_end - p_fourth vec_fourth = p_fourth_end - p_fourth
i = 0 i = 0
while i < sv_nb and not it.isEnd(): while i < sv_nb and not it.is_end:
if i < first: if i < first:
p_new = p_first + vec_first * float(i)/float(first - 1) p_new = p_first + vec_first * float(i)/float(first - 1)
if i == 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) p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
if i == fourth - 1: if i == fourth - 1:
visible = False visible = False
if it.getObject() == None: if it.object == None:
i = i + 1 i = i + 1
it.increment() it.increment()
if not visible: if not visible:
visible = True visible = True
continue continue
it.getObject().point = p_new it.object.point = p_new
it.getObject().attribute.visible = visible it.object.attribute.visible = visible
if not visible: if not visible:
visible = True visible = True
i = i + 1 i = i + 1
it.increment() it.increment()
verticesToRemove = [] verticesToRemove = []
while not it.isEnd(): while not it.is_end:
verticesToRemove.append(it.getObject()) verticesToRemove.append(it.object)
it.increment() it.increment()
for sv in verticesToRemove: for sv in verticesToRemove:
stroke.remove_vertex(sv) stroke.remove_vertex(sv)
@@ -1152,8 +1152,8 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
stroke.resample(32 * self.__turns) stroke.resample(32 * self.__turns)
p_mean = Vector([0, 0]) p_mean = Vector([0, 0])
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
p_mean = p_mean + p p_mean = p_mean + p
it.increment() it.increment()
sv_nb = stroke.stroke_vertices_size() sv_nb = stroke.stroke_vertices_size()
@@ -1162,8 +1162,8 @@ class pyBluePrintDirectedSquaresShader(StrokeShader):
p_var_yy = 0 p_var_yy = 0
p_var_xy = 0 p_var_xy = 0
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
p = it.getObject().point p = it.object.point
p_var_xx = p_var_xx + pow(p.x - p_mean.x, 2) 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_yy = p_var_yy + pow(p.y - p_mean.y, 2)
p_var_xy = p_var_xy + (p.x - p_mean.x) * (p.y - p_mean.y) p_var_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) p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
if i == fourth - 1: if i == fourth - 1:
visible = False visible = False
it.getObject().point = p_new it.object.point = p_new
it.getObject().attribute.visible = visible it.object.attribute.visible = visible
if not visible: if not visible:
visible = True visible = True
i = i + 1 i = i + 1
it.increment() it.increment()
verticesToRemove = [] verticesToRemove = []
while not it.isEnd(): while not it.is_end:
verticesToRemove.append(it.getObject()) verticesToRemove.append(it.object)
it.increment() it.increment()
for sv in verticesToRemove: for sv in verticesToRemove:
stroke.remove_vertex(sv) stroke.remove_vertex(sv)
@@ -1247,15 +1247,15 @@ class pyModulateAlphaShader(StrokeShader):
return "pyModulateAlphaShader" return "pyModulateAlphaShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
alpha = it.getObject().attribute.alpha alpha = it.object.attribute.alpha
p = it.getObject().point p = it.object.point
alpha = alpha * p.y / 400 alpha = alpha * p.y / 400
if alpha < self.__min: if alpha < self.__min:
alpha = self.__min alpha = self.__min
elif alpha > self.__max: elif alpha > self.__max:
alpha = self.__max alpha = self.__max
it.getObject().attribute.alpha = alpha it.object.attribute.alpha = alpha
it.increment() it.increment()
## various ## various
@@ -1264,9 +1264,9 @@ class pyDummyShader(StrokeShader):
return "pyDummyShader" return "pyDummyShader"
def shade(self, stroke): def shade(self, stroke):
it = stroke.stroke_vertices_begin() it = stroke.stroke_vertices_begin()
while not it.isEnd(): while not it.is_end:
toto = it.castToInterface0DIterator() toto = it.cast_to_interface0diterator()
att = it.getObject().attribute att = it.object.attribute
att.color = (0.3, 0.4, 0.4) att.color = (0.3, 0.4, 0.4)
att.thickness = (0, 5) att.thickness = (0, 5)
it.increment() it.increment()
@@ -1284,8 +1284,8 @@ class pyDebugShader(StrokeShader):
found = True found = True
foundfirst = True foundfirst = True
foundsecond = False foundsecond = False
while not it.isEnd(): while not it.is_end:
cp = it.getObject() cp = it.object
if cp.first_svertex.id == id1 or cp.second_svertex.id == id1: if cp.first_svertex.id == id1 or cp.second_svertex.id == id1:
foundfirst = True foundfirst = True
if cp.first_svertex.id == id2 or cp.second_svertex.id == id2: if cp.first_svertex.id == id2 or cp.second_svertex.id == id2:

18
release/scripts/freestyle/style_modules/uniformpruning_zsort.py
View File

@@ -7,24 +7,6 @@ from Functions0D import *
from Functions1D import * from Functions1D import *
from shaders 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.select(QuantitativeInvisibilityUP1D(0))
Operators.bidirectionalChain(ChainSilhouetteIterator()) Operators.bidirectionalChain(ChainSilhouetteIterator())
#Operators.sequentialSplit(pyVertexNatureUP0D(Nature.VIEW_VERTEX), 2) #Operators.sequentialSplit(pyVertexNatureUP0D(Nature.VIEW_VERTEX), 2)

169
source/blender/freestyle/intern/python/BPy_Iterator.cpp
View File

@@ -12,8 +12,6 @@
#include "Iterator/BPy_ChainPredicateIterator.h" #include "Iterator/BPy_ChainPredicateIterator.h"
#include "Iterator/BPy_ChainSilhouetteIterator.h" #include "Iterator/BPy_ChainSilhouetteIterator.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@@ -21,64 +19,64 @@ extern "C" {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
//-------------------MODULE INITIALIZATION-------------------------------- //-------------------MODULE INITIALIZATION--------------------------------
int Iterator_Init( PyObject *module ) int Iterator_Init(PyObject *module)
{ {
if( module == NULL ) if (module == NULL)
return -1; return -1;
if( PyType_Ready( &Iterator_Type ) < 0 ) if (PyType_Ready(&Iterator_Type) < 0)
return -1; return -1;
Py_INCREF( &Iterator_Type ); Py_INCREF(&Iterator_Type);
PyModule_AddObject(module, "Iterator", (PyObject *)&Iterator_Type); PyModule_AddObject(module, "Iterator", (PyObject *)&Iterator_Type);
if( PyType_Ready( &AdjacencyIterator_Type ) < 0 ) if (PyType_Ready(&AdjacencyIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &AdjacencyIterator_Type ); Py_INCREF(&AdjacencyIterator_Type);
PyModule_AddObject(module, "AdjacencyIterator", (PyObject *)&AdjacencyIterator_Type); PyModule_AddObject(module, "AdjacencyIterator", (PyObject *)&AdjacencyIterator_Type);
if( PyType_Ready( &Interface0DIterator_Type ) < 0 ) if (PyType_Ready(&Interface0DIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &Interface0DIterator_Type ); Py_INCREF(&Interface0DIterator_Type);
PyModule_AddObject(module, "Interface0DIterator", (PyObject *)&Interface0DIterator_Type); PyModule_AddObject(module, "Interface0DIterator", (PyObject *)&Interface0DIterator_Type);
if( PyType_Ready( &CurvePointIterator_Type ) < 0 ) if (PyType_Ready(&CurvePointIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &CurvePointIterator_Type ); Py_INCREF(&CurvePointIterator_Type);
PyModule_AddObject(module, "CurvePointIterator", (PyObject *)&CurvePointIterator_Type); PyModule_AddObject(module, "CurvePointIterator", (PyObject *)&CurvePointIterator_Type);
if( PyType_Ready( &StrokeVertexIterator_Type ) < 0 ) if (PyType_Ready(&StrokeVertexIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &StrokeVertexIterator_Type ); Py_INCREF(&StrokeVertexIterator_Type);
PyModule_AddObject(module, "StrokeVertexIterator", (PyObject *)&StrokeVertexIterator_Type); PyModule_AddObject(module, "StrokeVertexIterator", (PyObject *)&StrokeVertexIterator_Type);
if( PyType_Ready( &SVertexIterator_Type ) < 0 ) if (PyType_Ready(&SVertexIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &SVertexIterator_Type ); Py_INCREF(&SVertexIterator_Type);
PyModule_AddObject(module, "SVertexIterator", (PyObject *)&SVertexIterator_Type); PyModule_AddObject(module, "SVertexIterator", (PyObject *)&SVertexIterator_Type);
if( PyType_Ready( &orientedViewEdgeIterator_Type ) < 0 ) if (PyType_Ready(&orientedViewEdgeIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &orientedViewEdgeIterator_Type ); Py_INCREF(&orientedViewEdgeIterator_Type);
PyModule_AddObject(module, "orientedViewEdgeIterator", (PyObject *)&orientedViewEdgeIterator_Type); PyModule_AddObject(module, "orientedViewEdgeIterator", (PyObject *)&orientedViewEdgeIterator_Type);
if( PyType_Ready( &ViewEdgeIterator_Type ) < 0 ) if (PyType_Ready(&ViewEdgeIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &ViewEdgeIterator_Type ); Py_INCREF(&ViewEdgeIterator_Type);
PyModule_AddObject(module, "ViewEdgeIterator", (PyObject *)&ViewEdgeIterator_Type); PyModule_AddObject(module, "ViewEdgeIterator", (PyObject *)&ViewEdgeIterator_Type);
if( PyType_Ready( &ChainingIterator_Type ) < 0 ) if (PyType_Ready(&ChainingIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &ChainingIterator_Type ); Py_INCREF(&ChainingIterator_Type);
PyModule_AddObject(module, "ChainingIterator", (PyObject *)&ChainingIterator_Type); PyModule_AddObject(module, "ChainingIterator", (PyObject *)&ChainingIterator_Type);
if( PyType_Ready( &ChainPredicateIterator_Type ) < 0 ) if (PyType_Ready(&ChainPredicateIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &ChainPredicateIterator_Type ); Py_INCREF(&ChainPredicateIterator_Type);
PyModule_AddObject(module, "ChainPredicateIterator", (PyObject *)&ChainPredicateIterator_Type); PyModule_AddObject(module, "ChainPredicateIterator", (PyObject *)&ChainPredicateIterator_Type);
if( PyType_Ready( &ChainSilhouetteIterator_Type ) < 0 ) if (PyType_Ready(&ChainSilhouetteIterator_Type) < 0)
return -1; return -1;
Py_INCREF( &ChainSilhouetteIterator_Type ); Py_INCREF(&ChainSilhouetteIterator_Type);
PyModule_AddObject(module, "ChainSilhouetteIterator", (PyObject *)&ChainSilhouetteIterator_Type); PyModule_AddObject(module, "ChainSilhouetteIterator", (PyObject *)&ChainSilhouetteIterator_Type);
return 0; return 0;
@@ -86,97 +84,96 @@ int Iterator_Init( PyObject *module )
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char Iterator___doc__[] = PyDoc_STRVAR(Iterator_doc,
"Base class to define iterators.\n"; "Base class to define iterators.");
static void Iterator___dealloc__(BPy_Iterator* self) static void Iterator_dealloc(BPy_Iterator* self)
{ {
if (self->it) if (self->it)
delete self->it; delete self->it;
Py_TYPE(self)->tp_free((PyObject*)self); Py_TYPE(self)->tp_free((PyObject*)self);
} }
static PyObject * Iterator___repr__(BPy_Iterator* self) static PyObject * Iterator_repr(BPy_Iterator* self)
{ {
return PyUnicode_FromFormat("type: %s - address: %p", self->it->getExactTypeName().c_str(), self->it ); return PyUnicode_FromFormat("type: %s - address: %p", self->it->getExactTypeName().c_str(), self->it);
} }
static char Iterator_getExactTypeName___doc__[] = PyDoc_STRVAR(Iterator_increment_doc,
".. method:: getExactTypeName()\n"
"\n"
" Returns the name of the iterator.\n"
"\n"
" :return: The name of the iterator.\n"
" :rtype: str\n";
static PyObject * Iterator_getExactTypeName(BPy_Iterator* self) {
return PyUnicode_FromString( self->it->getExactTypeName().c_str() );
}
static char Iterator_increment___doc__[] =
".. method:: increment()\n" ".. method:: increment()\n"
"\n" "\n"
" Makes the iterator point the next element.\n"; " Makes the iterator point the next element.");
static PyObject * Iterator_increment(BPy_Iterator* self) { static PyObject * Iterator_increment(BPy_Iterator* self)
{
if (self->it->isEnd()) { if (self->it->isEnd()) {
PyErr_SetString(PyExc_RuntimeError , "cannot increment any more"); PyErr_SetString(PyExc_RuntimeError , "cannot increment any more");
return NULL; return NULL;
} }
self->it->increment(); self->it->increment();
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static char Iterator_decrement___doc__[] = PyDoc_STRVAR(Iterator_decrement_doc,
".. method:: decrement()\n" ".. method:: decrement()\n"
"\n" "\n"
" Makes the iterator point the previous element.\n"; " Makes the iterator point the previous element.");
static PyObject * Iterator_decrement(BPy_Iterator* self) { static PyObject * Iterator_decrement(BPy_Iterator* self)
{
if (self->it->isBegin()) { if (self->it->isBegin()) {
PyErr_SetString(PyExc_RuntimeError , "cannot decrement any more"); PyErr_SetString(PyExc_RuntimeError , "cannot decrement any more");
return NULL; return NULL;
} }
self->it->decrement(); self->it->decrement();
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static char Iterator_isBegin___doc__[] =
".. method:: isBegin()\n"
"\n"
" Returns true if the interator points the first element.\n"
"\n"
" :return: True if the interator points the first element.\n"
" :rtype: bool\n";
static PyObject * Iterator_isBegin(BPy_Iterator* self) {
return PyBool_from_bool( self->it->isBegin() );
}
static char Iterator_isEnd___doc__[] =
".. method:: isEnd()\n"
"\n"
" Returns true if the interator points the last element.\n"
"\n"
" :return: True if the interator points the last element.\n"
" :rtype: bool\n";
static PyObject * Iterator_isEnd(BPy_Iterator* self) {
return PyBool_from_bool( self->it->isEnd() );
}
/*----------------------Iterator instance definitions ----------------------------*/
static PyMethodDef BPy_Iterator_methods[] = { static PyMethodDef BPy_Iterator_methods[] = {
{"getExactTypeName", ( PyCFunction ) Iterator_getExactTypeName, METH_NOARGS, Iterator_getExactTypeName___doc__}, {"increment", (PyCFunction) Iterator_increment, METH_NOARGS, Iterator_increment_doc},
{"increment", ( PyCFunction ) Iterator_increment, METH_NOARGS, Iterator_increment___doc__}, {"decrement", (PyCFunction) Iterator_decrement, METH_NOARGS, Iterator_decrement_doc},
{"decrement", ( PyCFunction ) Iterator_decrement, METH_NOARGS, Iterator_decrement___doc__},
{"isBegin", ( PyCFunction ) Iterator_isBegin, METH_NOARGS, Iterator_isBegin___doc__},
{"isEnd", ( PyCFunction ) Iterator_isEnd, METH_NOARGS, Iterator_isEnd___doc__},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
/*----------------------Iterator get/setters ----------------------------*/
PyDoc_STRVAR(Iterator_exact_type_name_doc,
"The string of the name of this iterator.\n"
"\n"
":type: str");
static PyObject *Iterator_exact_type_name_get(BPy_Iterator *self, void *UNUSED(closure))
{
return PyUnicode_FromString(self->it->getExactTypeName().c_str());
}
PyDoc_STRVAR(Iterator_is_begin_doc,
"True if the interator points the first element.\n"
"\n"
":type: bool");
static PyObject *Iterator_is_begin_get(BPy_Iterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->it->isBegin());
}
PyDoc_STRVAR(Iterator_is_end_doc,
"True if the interator points the last element.\n"
"\n"
":type: bool");
static PyObject *Iterator_is_end_get(BPy_Iterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->it->isEnd());
}
static PyGetSetDef BPy_Iterator_getseters[] = {
{(char *)"exact_type_name", (getter)Iterator_exact_type_name_get, (setter)NULL, (char *)Iterator_exact_type_name_doc, NULL},
{(char *)"is_begin", (getter)Iterator_is_begin_get, (setter)NULL, (char *)Iterator_is_begin_doc, NULL},
{(char *)"is_end", (getter)Iterator_is_end_get, (setter)NULL, (char *)Iterator_is_end_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_Iterator type definition ------------------------------*/ /*-----------------------BPy_Iterator type definition ------------------------------*/
PyTypeObject Iterator_Type = { PyTypeObject Iterator_Type = {
@@ -184,12 +181,12 @@ PyTypeObject Iterator_Type = {
"Iterator", /* tp_name */ "Iterator", /* tp_name */
sizeof(BPy_Iterator), /* tp_basicsize */ sizeof(BPy_Iterator), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)Iterator___dealloc__, /* tp_dealloc */ (destructor)Iterator_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
0, /* tp_setattr */ 0, /* tp_setattr */
0, /* tp_reserved */ 0, /* tp_reserved */
(reprfunc)Iterator___repr__, /* tp_repr */ (reprfunc)Iterator_repr, /* tp_repr */
0, /* tp_as_number */ 0, /* tp_as_number */
0, /* tp_as_sequence */ 0, /* tp_as_sequence */
0, /* tp_as_mapping */ 0, /* tp_as_mapping */
@@ -200,7 +197,7 @@ PyTypeObject Iterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
Iterator___doc__, /* tp_doc */ Iterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -209,7 +206,7 @@ PyTypeObject Iterator_Type = {
0, /* tp_iternext */ 0, /* tp_iternext */
BPy_Iterator_methods, /* tp_methods */ BPy_Iterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_Iterator_getseters, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
@@ -225,5 +222,3 @@ PyTypeObject Iterator_Type = {
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

87
source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp
View File

@@ -11,7 +11,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char AdjacencyIterator___doc__[] = PyDoc_STRVAR(AdjacencyIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`AdjacencyIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`AdjacencyIterator`\n"
"\n" "\n"
"Class for representing adjacency iterators used in the chaining\n" "Class for representing adjacency iterators used in the chaining\n"
@@ -37,26 +37,26 @@ static char AdjacencyIterator___doc__[] =
" Copy constructor.\n" " Copy constructor.\n"
"\n" "\n"
" :arg it: An AdjacencyIterator object.\n" " :arg it: An AdjacencyIterator object.\n"
" :type it: :class:`AdjacencyIterator`\n"; " :type it: :class:`AdjacencyIterator`");
static int AdjacencyIterator___init__(BPy_AdjacencyIterator *self, PyObject *args ) static int AdjacencyIterator_init(BPy_AdjacencyIterator *self, PyObject *args)
{ {
PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0; PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0;
if (! PyArg_ParseTuple(args, "|OOO", &obj1, &obj2, &obj3) ) if (!PyArg_ParseTuple(args, "|OOO", &obj1, &obj2, &obj3))
return -1; return -1;
if( !obj1 && !obj2 && !obj3 ){ if (!obj1) {
self->a_it = new AdjacencyIterator(); self->a_it = new AdjacencyIterator();
} else if( BPy_AdjacencyIterator_Check(obj1) ) { } else if (BPy_AdjacencyIterator_Check(obj1) && !obj2) {
self->a_it = new AdjacencyIterator(*( ((BPy_AdjacencyIterator *) obj1)->a_it )); self->a_it = new AdjacencyIterator(*(((BPy_AdjacencyIterator *)obj1)->a_it));
} else if( BPy_ViewVertex_Check(obj1) ) { } else if (BPy_ViewVertex_Check(obj1) && (!obj2 || PyBool_Check(obj2)) && (!obj3 || PyBool_Check(obj3))) {
bool restrictToSelection = ( obj2 ) ? bool_from_PyBool(obj2) : true; bool restrictToSelection = (obj2) ? bool_from_PyBool(obj2) : true;
bool restrictToUnvisited = ( obj3 ) ? bool_from_PyBool(obj3) : true; bool restrictToUnvisited = (obj3) ? bool_from_PyBool(obj3) : true;
self->a_it = new AdjacencyIterator( ((BPy_ViewVertex *) obj1)->vv, restrictToSelection, restrictToUnvisited ); self->a_it = new AdjacencyIterator(((BPy_ViewVertex *)obj1)->vv, restrictToSelection, restrictToUnvisited);
} else { } else {
PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
@@ -66,55 +66,54 @@ static int AdjacencyIterator___init__(BPy_AdjacencyIterator *self, PyObject *arg
self->py_it.it = self->a_it; self->py_it.it = self->a_it;
return 0; return 0;
} }
static PyObject * AdjacencyIterator_iternext(BPy_AdjacencyIterator *self) { static PyObject * AdjacencyIterator_iternext(BPy_AdjacencyIterator *self)
{
if (self->a_it->isEnd()) { if (self->a_it->isEnd()) {
PyErr_SetNone(PyExc_StopIteration); PyErr_SetNone(PyExc_StopIteration);
return NULL; return NULL;
} }
ViewEdge *ve = self->a_it->operator*(); ViewEdge *ve = self->a_it->operator*();
self->a_it->increment(); self->a_it->increment();
return BPy_ViewEdge_from_ViewEdge( *ve ); return BPy_ViewEdge_from_ViewEdge(*ve);
} }
static char AdjacencyIterator_isIncoming___doc__[] = static PyMethodDef BPy_AdjacencyIterator_methods[] = {
".. method:: isIncoming()\n" {NULL, NULL, 0, NULL}
"\n" };
" Returns true if the current ViewEdge is coming towards the\n"
" iteration vertex. False otherwise.\n"
"\n"
" :return: True if the current ViewEdge is coming towards the\n"
" iteration vertex\n"
" :rtype: bool\n";
static PyObject * AdjacencyIterator_isIncoming(BPy_AdjacencyIterator *self) { /*----------------------AdjacencyIterator get/setters ----------------------------*/
return PyBool_from_bool(self->a_it->isIncoming());
}
static char AdjacencyIterator_getObject___doc__[] = PyDoc_STRVAR(AdjacencyIterator_object_doc,
".. method:: getObject()\n" "The ViewEdge object currently pointed by this iterator.\n"
"\n" "\n"
" Returns the pointed ViewEdge.\n" ":type: :class:`ViewEdge`");
"\n"
" :return: The pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
static PyObject * AdjacencyIterator_getObject(BPy_AdjacencyIterator *self) {
static PyObject *AdjacencyIterator_object_get(BPy_AdjacencyIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->a_it->operator*(); ViewEdge *ve = self->a_it->operator*();
if( ve ) if (ve)
return BPy_ViewEdge_from_ViewEdge( *ve ); return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/*----------------------AdjacencyIterator instance definitions ----------------------------*/ PyDoc_STRVAR(AdjacencyIterator_is_incoming_doc,
static PyMethodDef BPy_AdjacencyIterator_methods[] = { "True if the current ViewEdge is coming towards the iteration vertex, and\n"
{"isIncoming", ( PyCFunction ) AdjacencyIterator_isIncoming, METH_NOARGS, AdjacencyIterator_isIncoming___doc__}, "False otherwise.\n"
{"getObject", ( PyCFunction ) AdjacencyIterator_getObject, METH_NOARGS, AdjacencyIterator_getObject___doc__}, "\n"
{NULL, NULL, 0, NULL} ":type: bool");
static PyObject *AdjacencyIterator_is_incoming_get(BPy_AdjacencyIterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->a_it->isIncoming());
}
static PyGetSetDef BPy_AdjacencyIterator_getseters[] = {
{(char *)"is_incoming", (getter)AdjacencyIterator_is_incoming_get, (setter)NULL, (char *)AdjacencyIterator_is_incoming_doc, NULL},
{(char *)"object", (getter)AdjacencyIterator_object_get, (setter)NULL, (char *)AdjacencyIterator_object_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
}; };
/*-----------------------BPy_AdjacencyIterator type definition ------------------------------*/ /*-----------------------BPy_AdjacencyIterator type definition ------------------------------*/
@@ -140,7 +139,7 @@ PyTypeObject AdjacencyIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
AdjacencyIterator___doc__, /* tp_doc */ AdjacencyIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -149,13 +148,13 @@ PyTypeObject AdjacencyIterator_Type = {
(iternextfunc)AdjacencyIterator_iternext, /* tp_iternext */ (iternextfunc)AdjacencyIterator_iternext, /* tp_iternext */
BPy_AdjacencyIterator_methods, /* tp_methods */ BPy_AdjacencyIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_AdjacencyIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */ &Iterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)AdjacencyIterator___init__, /* tp_init */ (initproc)AdjacencyIterator_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
0, /* tp_new */ 0, /* tp_new */
}; };

155
source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp
View File

@@ -13,7 +13,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char ChainingIterator___doc__[] = PyDoc_STRVAR(ChainingIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator` > :class:`ChainingIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator` > :class:`ChainingIterator`\n"
"\n" "\n"
"Base class for chaining iterators. This class is designed to be\n" "Base class for chaining iterators. This class is designed to be\n"
@@ -47,52 +47,53 @@ static char ChainingIterator___doc__[] =
" Copy constructor.\n" " Copy constructor.\n"
"\n" "\n"
" :arg brother: \n" " :arg brother: \n"
" :type brother: ChainingIterator\n"; " :type brother: ChainingIterator");
static int ChainingIterator___init__(BPy_ChainingIterator *self, PyObject *args ) static int ChainingIterator___init__(BPy_ChainingIterator *self, PyObject *args)
{ {
PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0; PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0;
if (!( PyArg_ParseTuple(args, "|OOOO", &obj1, &obj2, &obj3, &obj4) )) if (!PyArg_ParseTuple(args, "|OOOO", &obj1, &obj2, &obj3, &obj4))
return -1; return -1;
if( obj1 && BPy_ChainingIterator_Check(obj1) ) { if (obj1 && BPy_ChainingIterator_Check(obj1)) {
self->c_it = new ChainingIterator(*( ((BPy_ChainingIterator *) obj1)->c_it )); self->c_it = new ChainingIterator(*(((BPy_ChainingIterator *)obj1)->c_it));
} else { } else {
bool restrictToSelection = ( obj1 ) ? bool_from_PyBool(obj1) : true; bool restrictToSelection = (obj1) ? bool_from_PyBool(obj1) : true;
bool restrictToUnvisited = ( obj2 ) ? bool_from_PyBool(obj2) : true; bool restrictToUnvisited = (obj2) ? bool_from_PyBool(obj2) : true;
ViewEdge *begin; ViewEdge *begin;
if ( !obj3 || obj3 == Py_None ) if (!obj3 || obj3 == Py_None)
begin = NULL; begin = NULL;
else if ( BPy_ViewEdge_Check(obj3) ) else if (BPy_ViewEdge_Check(obj3))
begin = ((BPy_ViewEdge *) obj3)->ve; begin = ((BPy_ViewEdge *)obj3)->ve;
else { else {
PyErr_SetString(PyExc_TypeError, "3rd argument must be either a ViewEdge object or None"); PyErr_SetString(PyExc_TypeError, "3rd argument must be either a ViewEdge object or None");
return -1; return -1;
} }
bool orientation = ( obj4 ) ? bool_from_PyBool(obj4) : true; bool orientation = (obj4) ? bool_from_PyBool(obj4) : true;
self->c_it = new ChainingIterator( restrictToSelection, restrictToUnvisited, begin, orientation); self->c_it = new ChainingIterator(restrictToSelection, restrictToUnvisited, begin, orientation);
} }
self->py_ve_it.ve_it = self->c_it; self->py_ve_it.ve_it = self->c_it;
self->py_ve_it.py_it.it = self->c_it; self->py_ve_it.py_it.it = self->c_it;
self->c_it->py_c_it = (PyObject *) self; self->c_it->py_c_it = (PyObject *)self;
return 0; return 0;
} }
static char ChainingIterator_init___doc__[] = PyDoc_STRVAR(ChainingIterator_init_doc,
".. method:: init()\n" ".. method:: init()\n"
"\n" "\n"
" Initializes the iterator context. This method is called each\n" " Initializes the iterator context. This method is called each\n"
" time a new chain is started. It can be used to reset some\n" " time a new chain is started. It can be used to reset some\n"
" history information that you might want to keep.\n"; " history information that you might want to keep.");
static PyObject *ChainingIterator_init( BPy_ChainingIterator *self ) { static PyObject *ChainingIterator_init(BPy_ChainingIterator *self)
if( typeid(*(self->c_it)) == typeid(ChainingIterator) ) { {
if (typeid(*(self->c_it)) == typeid(ChainingIterator)) {
PyErr_SetString(PyExc_TypeError, "init() method not properly overridden"); PyErr_SetString(PyExc_TypeError, "init() method not properly overridden");
return NULL; return NULL;
} }
@@ -101,7 +102,7 @@ static PyObject *ChainingIterator_init( BPy_ChainingIterator *self ) {
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static char ChainingIterator_traverse___doc__[] = PyDoc_STRVAR(ChainingIterator_traverse_doc,
".. method:: traverse(it)\n" ".. method:: traverse(it)\n"
"\n" "\n"
" This method iterates over the potential next ViewEdges and returns\n" " This method iterates over the potential next ViewEdges and returns\n"
@@ -113,79 +114,79 @@ static char ChainingIterator_traverse___doc__[] =
" restriction rules by only iterating over the valid ViewEdges.\n" " restriction rules by only iterating over the valid ViewEdges.\n"
" :type it: :class:`AdjacencyIterator`\n" " :type it: :class:`AdjacencyIterator`\n"
" :return: Returns the next ViewEdge to follow, or None if chaining ends.\n" " :return: Returns the next ViewEdge to follow, or None if chaining ends.\n"
" :rtype: :class:`ViewEdge` or None\n"; " :rtype: :class:`ViewEdge` or None");
static PyObject *ChainingIterator_traverse( BPy_ChainingIterator *self, PyObject *args ) { static PyObject *ChainingIterator_traverse(BPy_ChainingIterator *self, PyObject *args)
{
PyObject *py_a_it; PyObject *py_a_it;
if(!( PyArg_ParseTuple(args, "O!", &AdjacencyIterator_Type, &py_a_it) )) if(!(PyArg_ParseTuple(args, "O!", &AdjacencyIterator_Type, &py_a_it)))
return NULL; return NULL;
if( typeid(*(self->c_it)) == typeid(ChainingIterator) ) { if (typeid(*(self->c_it)) == typeid(ChainingIterator)) {
PyErr_SetString(PyExc_TypeError, "traverse() method not properly overridden"); PyErr_SetString(PyExc_TypeError, "traverse() method not properly overridden");
return NULL; return NULL;
} }
if( ((BPy_AdjacencyIterator *) py_a_it)->a_it ) if (((BPy_AdjacencyIterator *)py_a_it)->a_it)
self->c_it->traverse(*( ((BPy_AdjacencyIterator *) py_a_it)->a_it )); self->c_it->traverse(*(((BPy_AdjacencyIterator *)py_a_it)->a_it));
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static char ChainingIterator_getVertex___doc__[] =
".. method:: getVertex()\n"
"\n"
" Returns the vertex which is the next crossing.\n"
"\n"
" :return: The vertex which is the next crossing.\n"
" :rtype: :class:`ViewVertex`\n";
static PyObject *ChainingIterator_getVertex( BPy_ChainingIterator *self ) {
ViewVertex *v = self->c_it->getVertex();
if( v )
return Any_BPy_ViewVertex_from_ViewVertex( *v );
Py_RETURN_NONE;
}
static char ChainingIterator_isIncrementing___doc__[] =
".. method:: isIncrementing()\n"
"\n"
" Returns true if the current iteration is an incrementation.\n"
"\n"
" :return: True if the current iteration is an incrementation.\n"
" :rtype: bool\n";
static PyObject *ChainingIterator_isIncrementing( BPy_ChainingIterator *self ) {
return PyBool_from_bool( self->c_it->isIncrementing() );
}
static char ChainingIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed ViewEdge.\n"
"\n"
" :return: The pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
static PyObject * ChainingIterator_getObject( BPy_ChainingIterator *self) {
ViewEdge *ve = self->c_it->operator*();
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
Py_RETURN_NONE;
}
/*----------------------ChainingIterator instance definitions ----------------------------*/
static PyMethodDef BPy_ChainingIterator_methods[] = { static PyMethodDef BPy_ChainingIterator_methods[] = {
{"init", ( PyCFunction ) ChainingIterator_init, METH_NOARGS, ChainingIterator_init___doc__}, {"init", (PyCFunction) ChainingIterator_init, METH_NOARGS, ChainingIterator_init_doc},
{"traverse", ( PyCFunction ) ChainingIterator_traverse, METH_VARARGS, ChainingIterator_traverse___doc__}, {"traverse", (PyCFunction) ChainingIterator_traverse, METH_VARARGS, ChainingIterator_traverse_doc},
{"getVertex", ( PyCFunction ) ChainingIterator_getVertex, METH_NOARGS, ChainingIterator_getVertex___doc__},
{"isIncrementing", ( PyCFunction ) ChainingIterator_isIncrementing, METH_NOARGS, ChainingIterator_isIncrementing___doc__},
{"getObject", ( PyCFunction ) ChainingIterator_getObject, METH_NOARGS, ChainingIterator_getObject___doc__},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
/*----------------------ChainingIterator get/setters ----------------------------*/
PyDoc_STRVAR(ChainingIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ChainingIterator_object_get(BPy_ChainingIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->c_it->operator*();
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;
}
PyDoc_STRVAR(ChainingIterator_next_vertex_doc,
"The ViewVertex that is the next crossing.\n"
"\n"
":type: :class:`ViewVertex`");
static PyObject *ChainingIterator_next_vertex_get(BPy_ChainingIterator *self, void *UNUSED(closure))
{
ViewVertex *v = self->c_it->getVertex();
if (v)
return Any_BPy_ViewVertex_from_ViewVertex(*v);
Py_RETURN_NONE;
}
PyDoc_STRVAR(ChainingIterator_is_incrementing_doc,
"True if the current iteration is an incrementation.\n"
"\n"
":type: bool");
static PyObject *ChainingIterator_is_incrementing_get(BPy_ChainingIterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->c_it->isIncrementing());
}
static PyGetSetDef BPy_ChainingIterator_getseters[] = {
{(char *)"object", (getter)ChainingIterator_object_get, (setter)NULL, (char *)ChainingIterator_object_doc, NULL},
{(char *)"next_vertex", (getter)ChainingIterator_next_vertex_get, (setter)NULL, (char *)ChainingIterator_next_vertex_doc, NULL},
{(char *)"is_incrementing", (getter)ChainingIterator_is_incrementing_get, (setter)NULL, (char *)ChainingIterator_is_incrementing_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_ChainingIterator type definition ------------------------------*/ /*-----------------------BPy_ChainingIterator type definition ------------------------------*/
PyTypeObject ChainingIterator_Type = { PyTypeObject ChainingIterator_Type = {
@@ -209,7 +210,7 @@ PyTypeObject ChainingIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
ChainingIterator___doc__, /* tp_doc */ ChainingIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -218,7 +219,7 @@ PyTypeObject ChainingIterator_Type = {
0, /* tp_iternext */ 0, /* tp_iternext */
BPy_ChainingIterator_methods, /* tp_methods */ BPy_ChainingIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_ChainingIterator_getseters, /* tp_getset */
&ViewEdgeIterator_Type, /* tp_base */ &ViewEdgeIterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */

118
source/blender/freestyle/intern/python/Iterator/BPy_CurvePointIterator.cpp
View File

@@ -11,7 +11,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char CurvePointIterator___doc__[] = PyDoc_STRVAR(CurvePointIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`CurvePointIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`CurvePointIterator`\n"
"\n" "\n"
"Class representing an iterator on a curve. Allows an iterating\n" "Class representing an iterator on a curve. Allows an iterating\n"
@@ -32,23 +32,23 @@ static char CurvePointIterator___doc__[] =
" Copy constructor.\n" " Copy constructor.\n"
"\n" "\n"
" :arg brother: A CurvePointIterator object.\n" " :arg brother: A CurvePointIterator object.\n"
" :type brother: :class:`CurvePointIterator`\n"; " :type brother: :class:`CurvePointIterator`");
static int CurvePointIterator___init__(BPy_CurvePointIterator *self, PyObject *args ) static int CurvePointIterator_init(BPy_CurvePointIterator *self, PyObject *args)
{ {
PyObject *obj = 0; PyObject *obj = 0;
if (! PyArg_ParseTuple(args, "|O", &obj) ) if (!PyArg_ParseTuple(args, "|O", &obj))
return -1; return -1;
if( !obj ){ if (!obj) {
self->cp_it = new CurveInternal::CurvePointIterator(); self->cp_it = new CurveInternal::CurvePointIterator();
} else if( BPy_CurvePointIterator_Check(obj) ) { } else if (BPy_CurvePointIterator_Check(obj)) {
self->cp_it = new CurveInternal::CurvePointIterator(*( ((BPy_CurvePointIterator *) obj)->cp_it )); self->cp_it = new CurveInternal::CurvePointIterator(*(((BPy_CurvePointIterator *)obj)->cp_it));
} else if( PyFloat_Check(obj) ) { } else if (PyFloat_Check(obj)) {
self->cp_it = new CurveInternal::CurvePointIterator( PyFloat_AsDouble(obj) ); self->cp_it = new CurveInternal::CurvePointIterator(PyFloat_AsDouble(obj));
} else { } else {
PyErr_SetString(PyExc_TypeError, "invalid argument"); PyErr_SetString(PyExc_TypeError, "invalid argument");
@@ -60,32 +60,8 @@ static int CurvePointIterator___init__(BPy_CurvePointIterator *self, PyObject *a
return 0; return 0;
} }
static char CurvePointIterator_t___doc__[] = PyDoc_STRVAR(CurvePointIterator_cast_to_interface0diterator_doc,
".. method:: t()\n" ".. method:: cast_to_interface0diterator()\n"
"\n"
" Returns the curvilinear abscissa.\n"
"\n"
" :return: The curvilinear abscissa.\n"
" :rtype: float\n";
static PyObject * CurvePointIterator_t( BPy_CurvePointIterator *self ) {
return PyFloat_FromDouble( self->cp_it->t() );
}
static char CurvePointIterator_u___doc__[] =
".. method:: u()\n"
"\n"
" Returns the point parameter in the curve (0<=u<=1).\n"
"\n"
" :return: The point parameter.\n"
" :rtype: float\n";
static PyObject * CurvePointIterator_u( BPy_CurvePointIterator *self ) {
return PyFloat_FromDouble( self->cp_it->u() );
}
static char CurvePointIterator_castToInterface0DIterator___doc__[] =
".. method:: castToInterface0DIterator()\n"
"\n" "\n"
" Returns an Interface0DIterator converted from this\n" " Returns an Interface0DIterator converted from this\n"
" CurvePointIterator. Useful for any call to a function of the\n" " CurvePointIterator. Useful for any call to a function of the\n"
@@ -93,34 +69,58 @@ static char CurvePointIterator_castToInterface0DIterator___doc__[] =
"\n" "\n"
" :return: An Interface0DIterator object converted from the\n" " :return: An Interface0DIterator object converted from the\n"
" iterator.\n" " iterator.\n"
" :rtype: :class:`Interface0DIterator`\n"; " :rtype: :class:`Interface0DIterator`");
static PyObject * CurvePointIterator_castToInterface0DIterator( BPy_CurvePointIterator *self ) { static PyObject * CurvePointIterator_cast_to_interface0diterator(BPy_CurvePointIterator *self)
Interface0DIterator it( self->cp_it->castToInterface0DIterator() ); {
return BPy_Interface0DIterator_from_Interface0DIterator( it, 0 ); Interface0DIterator it(self->cp_it->castToInterface0DIterator());
return BPy_Interface0DIterator_from_Interface0DIterator(it, 0);
} }
static char CurvePointIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns a CurvePoint pointed by the iterator.\n"
"\n"
" :return: \n"
" :rtype: :class:`CurvePoint`\n";
static PyObject * CurvePointIterator_getObject(BPy_CurvePointIterator *self) {
return BPy_CurvePoint_from_CurvePoint( self->cp_it->operator*() );
}
/*----------------------CurvePointIterator instance definitions ----------------------------*/
static PyMethodDef BPy_CurvePointIterator_methods[] = { static PyMethodDef BPy_CurvePointIterator_methods[] = {
{"t", ( PyCFunction ) CurvePointIterator_t, METH_NOARGS, CurvePointIterator_t___doc__}, {"cast_to_interface0diterator", (PyCFunction) CurvePointIterator_cast_to_interface0diterator, METH_NOARGS, CurvePointIterator_cast_to_interface0diterator_doc},
{"u", ( PyCFunction ) CurvePointIterator_u, METH_NOARGS, CurvePointIterator_u___doc__},
{"castToInterface0DIterator", ( PyCFunction ) CurvePointIterator_castToInterface0DIterator, METH_NOARGS, CurvePointIterator_castToInterface0DIterator___doc__},
{"getObject", ( PyCFunction ) CurvePointIterator_getObject, METH_NOARGS, CurvePointIterator_getObject___doc__},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
/*----------------------CurvePointIterator get/setters ----------------------------*/
PyDoc_STRVAR(CurvePointIterator_object_doc,
"The CurvePoint object currently pointed by this iterator.\n"
"\n"
":type: :class:`CurvePoint`");
static PyObject *CurvePointIterator_object_get(BPy_CurvePointIterator *self, void *UNUSED(closure))
{
return BPy_CurvePoint_from_CurvePoint(self->cp_it->operator*());
}
PyDoc_STRVAR(CurvePointIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *CurvePointIterator_t_get(BPy_CurvePointIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->cp_it->t());
}
PyDoc_STRVAR(CurvePointIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *CurvePointIterator_u_get(BPy_CurvePointIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->cp_it->u());
}
static PyGetSetDef BPy_CurvePointIterator_getseters[] = {
{(char *)"object", (getter)CurvePointIterator_object_get, (setter)NULL, (char *)CurvePointIterator_object_doc, NULL},
{(char *)"t", (getter)CurvePointIterator_t_get, (setter)NULL, (char *)CurvePointIterator_t_doc, NULL},
{(char *)"u", (getter)CurvePointIterator_u_get, (setter)NULL, (char *)CurvePointIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_CurvePointIterator type definition ------------------------------*/ /*-----------------------BPy_CurvePointIterator type definition ------------------------------*/
PyTypeObject CurvePointIterator_Type = { PyTypeObject CurvePointIterator_Type = {
@@ -144,7 +144,7 @@ PyTypeObject CurvePointIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
CurvePointIterator___doc__, /* tp_doc */ CurvePointIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -153,13 +153,13 @@ PyTypeObject CurvePointIterator_Type = {
0, /* tp_iternext */ 0, /* tp_iternext */
BPy_CurvePointIterator_methods, /* tp_methods */ BPy_CurvePointIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_CurvePointIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */ &Iterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)CurvePointIterator___init__, /* tp_init */ (initproc)CurvePointIterator_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
0, /* tp_new */ 0, /* tp_new */
}; };

101
source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp
View File

@@ -10,7 +10,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char Interface0DIterator___doc__[] = PyDoc_STRVAR(Interface0DIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`Interface0DIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`Interface0DIterator`\n"
"\n" "\n"
"Class defining an iterator over Interface0D elements. An instance of\n" "Class defining an iterator over Interface0D elements. An instance of\n"
@@ -21,24 +21,26 @@ static char Interface0DIterator___doc__[] =
" Copy constructor.\n" " Copy constructor.\n"
"\n" "\n"
" :arg it: An Interface0DIterator object.\n" " :arg it: An Interface0DIterator object.\n"
" :type it: :class:`Interface0DIterator`\n"; " :type it: :class:`Interface0DIterator`");
static int Interface0DIterator___init__(BPy_Interface0DIterator *self, PyObject *args ) static int Interface0DIterator_init(BPy_Interface0DIterator *self, PyObject *args)
{ {
PyObject *obj = 0; PyObject *obj = 0;
if (!( PyArg_ParseTuple(args, "O!", &Interface0DIterator_Type, &obj) )) if (!PyArg_ParseTuple(args, "O!", &Interface0DIterator_Type, &obj))
return -1; return -1;
self->if0D_it = new Interface0DIterator(*( ((BPy_Interface0DIterator *) obj)->if0D_it )); self->if0D_it = new Interface0DIterator(*(((BPy_Interface0DIterator *)obj)->if0D_it));
self->py_it.it = self->if0D_it; self->py_it.it = self->if0D_it;
self->reversed = 0; self->reversed = 0;
return 0; return 0;
} }
static PyObject * Interface0DIterator_iternext( BPy_Interface0DIterator *self ) { static PyObject * Interface0DIterator_iternext(BPy_Interface0DIterator *self)
{
Interface0D *if0D; Interface0D *if0D;
if (self->reversed) { if (self->reversed) {
if (self->if0D_it->isBegin()) { if (self->if0D_it->isBegin()) {
PyErr_SetNone(PyExc_StopIteration); PyErr_SetNone(PyExc_StopIteration);
@@ -54,53 +56,52 @@ static PyObject * Interface0DIterator_iternext( BPy_Interface0DIterator *self )
if0D = self->if0D_it->operator->(); if0D = self->if0D_it->operator->();
self->if0D_it->increment(); self->if0D_it->increment();
} }
return Any_BPy_Interface0D_from_Interface0D( *if0D ); return Any_BPy_Interface0D_from_Interface0D(*if0D);
} }
static char Interface0DIterator_t___doc__[] =
".. method:: t()\n"
"\n"
" Returns the curvilinear abscissa.\n"
"\n"
" :return: The curvilinear abscissa.\n"
" :rtype: float\n";
static PyObject * Interface0DIterator_t( BPy_Interface0DIterator *self ) {
return PyFloat_FromDouble( self->if0D_it->t() );
}
static char Interface0DIterator_u___doc__[] =
".. method:: u()\n"
"\n"
" Returns the point parameter in the curve 0<=u<=1.\n"
"\n"
" :return: The point parameter.\n"
" :rtype: float\n";
static PyObject * Interface0DIterator_u( BPy_Interface0DIterator *self ) {
return PyFloat_FromDouble( self->if0D_it->u() );
}
static char Interface0DIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed Interface0D.\n"
"\n"
" :return: The pointed Interface0D.\n"
" :rtype: :class:`Interface0D`\n";
static PyObject * Interface0DIterator_getObject(BPy_Interface0DIterator *self) {
return Any_BPy_Interface0D_from_Interface0D( self->if0D_it->operator*() );
}
/*----------------------Interface0DIterator instance definitions ----------------------------*/
static PyMethodDef BPy_Interface0DIterator_methods[] = { static PyMethodDef BPy_Interface0DIterator_methods[] = {
{"t", ( PyCFunction ) Interface0DIterator_t, METH_NOARGS, Interface0DIterator_t___doc__},
{"u", ( PyCFunction ) Interface0DIterator_u, METH_NOARGS, Interface0DIterator_u___doc__},
{"getObject", ( PyCFunction ) Interface0DIterator_getObject, METH_NOARGS, Interface0DIterator_getObject___doc__},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
/*----------------------Interface0DIterator get/setters ----------------------------*/
PyDoc_STRVAR(Interface0DIterator_object_doc,
"The Interface0D object currently pointed by this iterator.\n"
"\n"
":type: :class:`Interface0D`");
static PyObject *Interface0DIterator_object_get(BPy_Interface0DIterator *self, void *UNUSED(closure))
{
return Any_BPy_Interface0D_from_Interface0D(self->if0D_it->operator*());
}
PyDoc_STRVAR(Interface0DIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *Interface0DIterator_t_get(BPy_Interface0DIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->if0D_it->t());
}
PyDoc_STRVAR(Interface0DIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *Interface0DIterator_u_get(BPy_Interface0DIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->if0D_it->u());
}
static PyGetSetDef BPy_Interface0DIterator_getseters[] = {
{(char *)"object", (getter)Interface0DIterator_object_get, (setter)NULL, (char *)Interface0DIterator_object_doc, NULL},
{(char *)"t", (getter)Interface0DIterator_t_get, (setter)NULL, (char *)Interface0DIterator_t_doc, NULL},
{(char *)"u", (getter)Interface0DIterator_u_get, (setter)NULL, (char *)Interface0DIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_Interface0DIterator type definition ------------------------------*/ /*-----------------------BPy_Interface0DIterator type definition ------------------------------*/
PyTypeObject Interface0DIterator_Type = { PyTypeObject Interface0DIterator_Type = {
@@ -124,7 +125,7 @@ PyTypeObject Interface0DIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
Interface0DIterator___doc__, /* tp_doc */ Interface0DIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -133,13 +134,13 @@ PyTypeObject Interface0DIterator_Type = {
(iternextfunc)Interface0DIterator_iternext, /* tp_iternext */ (iternextfunc)Interface0DIterator_iternext, /* tp_iternext */
BPy_Interface0DIterator_methods, /* tp_methods */ BPy_Interface0DIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_Interface0DIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */ &Iterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)Interface0DIterator___init__, /* tp_init */ (initproc)Interface0DIterator_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
0, /* tp_new */ 0, /* tp_new */
}; };

107
source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp
View File

@@ -12,7 +12,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char SVertexIterator___doc__[] = PyDoc_STRVAR(SVertexIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`SVertexIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`SVertexIterator`\n"
"\n" "\n"
"Class representing an iterator over :class:`SVertex` of a\n" "Class representing an iterator over :class:`SVertex` of a\n"
@@ -44,33 +44,33 @@ static char SVertexIterator___doc__[] =
" :arg next: The next FEdge going out from v.\n" " :arg next: The next FEdge going out from v.\n"
" :type next: :class:`FEdge`\n" " :type next: :class:`FEdge`\n"
" :arg t: The curvilinear abscissa at v.\n" " :arg t: The curvilinear abscissa at v.\n"
" :type t: float\n"; " :type t: float");
static int SVertexIterator___init__(BPy_SVertexIterator *self, PyObject *args ) static int SVertexIterator_init(BPy_SVertexIterator *self, PyObject *args)
{ {
PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0; PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0;
float f = 0; float f = 0;
if (! PyArg_ParseTuple(args, "|OOOOf", &obj1, &obj2, &obj3, &obj4, f) ) if (!PyArg_ParseTuple(args, "|OOOOf", &obj1, &obj2, &obj3, &obj4, f))
return -1; return -1;
if( !obj1 ){ if (!obj1) {
self->sv_it = new ViewEdgeInternal::SVertexIterator(); self->sv_it = new ViewEdgeInternal::SVertexIterator();
} else if( BPy_SVertexIterator_Check(obj1) ) { } else if (BPy_SVertexIterator_Check(obj1)) {
self->sv_it = new ViewEdgeInternal::SVertexIterator(*( ((BPy_SVertexIterator *) obj1)->sv_it )); self->sv_it = new ViewEdgeInternal::SVertexIterator(*(((BPy_SVertexIterator *)obj1)->sv_it));
} else if( obj1 && BPy_SVertex_Check(obj1) && } else if (obj1 && BPy_SVertex_Check(obj1) &&
obj2 && BPy_SVertex_Check(obj2) && obj2 && BPy_SVertex_Check(obj2) &&
obj3 && BPy_FEdge_Check(obj3) && obj3 && BPy_FEdge_Check(obj3) &&
obj4 && BPy_FEdge_Check(obj4) ) { obj4 && BPy_FEdge_Check(obj4)) {
self->sv_it = new ViewEdgeInternal::SVertexIterator( self->sv_it = new ViewEdgeInternal::SVertexIterator(
((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *)obj1)->sv,
((BPy_SVertex *) obj2)->sv, ((BPy_SVertex *)obj2)->sv,
((BPy_FEdge *) obj3)->fe, ((BPy_FEdge *)obj3)->fe,
((BPy_FEdge *) obj4)->fe, ((BPy_FEdge *)obj4)->fe,
f ); f);
} else { } else {
PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
@@ -82,53 +82,52 @@ static int SVertexIterator___init__(BPy_SVertexIterator *self, PyObject *args )
return 0; return 0;
} }
static char SVertexIterator_t___doc__[] = static PyMethodDef BPy_SVertexIterator_methods[] = {
".. method:: t()\n" {NULL, NULL, 0, NULL}
"\n" };
" Returns the curvilinear abscissa.\n"
"\n"
" :return: The curvilinear abscissa.\n"
" :rtype: float\n";
static PyObject * SVertexIterator_t( BPy_SVertexIterator *self ) { /*----------------------SVertexIterator get/setters ----------------------------*/
return PyFloat_FromDouble( self->sv_it->t() );
}
static char SVertexIterator_u___doc__[] = PyDoc_STRVAR(SVertexIterator_object_doc,
".. method:: u()\n" "The SVertex object currently pointed by this iterator.\n"
"\n" "\n"
" Returns the point parameter (0<=u<=1).\n" ":type: :class:`SVertex`");
"\n"
" :return: The point parameter.\n"
" :rtype: float\n";
static PyObject * SVertexIterator_u( BPy_SVertexIterator *self ) { static PyObject *SVertexIterator_object_get(BPy_SVertexIterator *self, void *UNUSED(closure))
return PyFloat_FromDouble( self->sv_it->u() ); {
}
static char SVertexIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed SVertex.\n"
"\n"
" :return: the pointed SVertex.\n"
" :rtype: :class:`SVertex`\n";
static PyObject * SVertexIterator_getObject( BPy_SVertexIterator *self) {
SVertex *sv = self->sv_it->operator->(); SVertex *sv = self->sv_it->operator->();
if( sv ) if (sv)
return BPy_SVertex_from_SVertex( *sv ); return BPy_SVertex_from_SVertex(*sv);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/*----------------------SVertexIterator instance definitions ----------------------------*/ PyDoc_STRVAR(SVertexIterator_t_doc,
static PyMethodDef BPy_SVertexIterator_methods[] = { "The curvilinear abscissa of the current point.\n"
{"t", ( PyCFunction ) SVertexIterator_t, METH_NOARGS, SVertexIterator_t___doc__}, "\n"
{"u", ( PyCFunction ) SVertexIterator_u, METH_NOARGS, SVertexIterator_u___doc__}, ":type: float");
{"getObject", ( PyCFunction ) SVertexIterator_getObject, METH_NOARGS, SVertexIterator_getObject___doc__},
{NULL, NULL, 0, NULL} static PyObject *SVertexIterator_t_get(BPy_SVertexIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->sv_it->t());
}
PyDoc_STRVAR(SVertexIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *SVertexIterator_u_get(BPy_SVertexIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->sv_it->u());
}
static PyGetSetDef BPy_SVertexIterator_getseters[] = {
{(char *)"object", (getter)SVertexIterator_object_get, (setter)NULL, (char *)SVertexIterator_object_doc, NULL},
{(char *)"t", (getter)SVertexIterator_t_get, (setter)NULL, (char *)SVertexIterator_t_doc, NULL},
{(char *)"u", (getter)SVertexIterator_u_get, (setter)NULL, (char *)SVertexIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
}; };
/*-----------------------BPy_SVertexIterator type definition ------------------------------*/ /*-----------------------BPy_SVertexIterator type definition ------------------------------*/
@@ -154,7 +153,7 @@ PyTypeObject SVertexIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
SVertexIterator___doc__, /* tp_doc */ SVertexIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -163,13 +162,13 @@ PyTypeObject SVertexIterator_Type = {
0, /* tp_iternext */ 0, /* tp_iternext */
BPy_SVertexIterator_methods, /* tp_methods */ BPy_SVertexIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_SVertexIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */ &Iterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)SVertexIterator___init__, /* tp_init */ (initproc)SVertexIterator_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
0, /* tp_new */ 0, /* tp_new */
}; };

121
source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp
View File

@@ -11,7 +11,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char StrokeVertexIterator___doc__[] = PyDoc_STRVAR(StrokeVertexIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`StrokeVertexIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`StrokeVertexIterator`\n"
"\n" "\n"
"Class defining an iterator designed to iterate over the\n" "Class defining an iterator designed to iterate over the\n"
@@ -35,20 +35,20 @@ static char StrokeVertexIterator___doc__[] =
" Copy constructor.\n" " Copy constructor.\n"
"\n" "\n"
" :arg it: A StrokeVertexIterator object.\n" " :arg it: A StrokeVertexIterator object.\n"
" :type it: :class:`StrokeVertexIterator`\n"; " :type it: :class:`StrokeVertexIterator`");
static int StrokeVertexIterator___init__(BPy_StrokeVertexIterator *self, PyObject *args ) static int StrokeVertexIterator_init(BPy_StrokeVertexIterator *self, PyObject *args)
{ {
PyObject *obj = 0; PyObject *obj = 0;
if (! PyArg_ParseTuple(args, "|O", &obj) ) if (!PyArg_ParseTuple(args, "|O", &obj))
return -1; return -1;
if( !obj ){ if (!obj) {
self->sv_it = new StrokeInternal::StrokeVertexIterator(); self->sv_it = new StrokeInternal::StrokeVertexIterator();
} else if( BPy_StrokeVertexIterator_Check(obj) ) { } else if (BPy_StrokeVertexIterator_Check(obj)) {
self->sv_it = new StrokeInternal::StrokeVertexIterator(*( ((BPy_StrokeVertexIterator *) obj)->sv_it )); self->sv_it = new StrokeInternal::StrokeVertexIterator(*(((BPy_StrokeVertexIterator *)obj)->sv_it));
} else { } else {
PyErr_SetString(PyExc_TypeError, "invalid argument"); PyErr_SetString(PyExc_TypeError, "invalid argument");
@@ -61,8 +61,10 @@ static int StrokeVertexIterator___init__(BPy_StrokeVertexIterator *self, PyObjec
return 0; return 0;
} }
static PyObject * StrokeVertexIterator_iternext( BPy_StrokeVertexIterator *self ) { static PyObject * StrokeVertexIterator_iternext(BPy_StrokeVertexIterator *self)
{
StrokeVertex *sv; StrokeVertex *sv;
if (self->reversed) { if (self->reversed) {
if (self->sv_it->isBegin()) { if (self->sv_it->isBegin()) {
PyErr_SetNone(PyExc_StopIteration); PyErr_SetNone(PyExc_StopIteration);
@@ -78,73 +80,74 @@ static PyObject * StrokeVertexIterator_iternext( BPy_StrokeVertexIterator *self
sv = self->sv_it->operator->(); sv = self->sv_it->operator->();
self->sv_it->increment(); self->sv_it->increment();
} }
return BPy_StrokeVertex_from_StrokeVertex( *sv ); return BPy_StrokeVertex_from_StrokeVertex(*sv);
} }
static char StrokeVertexIterator_t___doc__[] = PyDoc_STRVAR(StrokeVertexIterator_cast_to_interface0diterator_doc,
".. method:: t()\n" ".. method:: cast_to_interface0diterator()\n"
"\n"
" Returns the curvilinear abscissa of the current point.\n"
"\n"
" :return: The curvilinear abscissa of the current point.\n"
" :rtype: float\n";
static PyObject * StrokeVertexIterator_t( BPy_StrokeVertexIterator *self ) {
return PyFloat_FromDouble( self->sv_it->t() );
}
static char StrokeVertexIterator_u___doc__[] =
".. method:: u()\n"
"\n"
" Returns the point parameter in the stroke (0<=u<=1).\n"
"\n"
" :return: The point parameter in the stroke\n"
" :rtype: float\n";
static PyObject * StrokeVertexIterator_u( BPy_StrokeVertexIterator *self ) {
return PyFloat_FromDouble( self->sv_it->u() );
}
static char StrokeVertexIterator_castToInterface0DIterator___doc__[] =
".. method:: castToInterface0DIterator()\n"
"\n" "\n"
" Returns an Interface0DIterator converted from this\n" " Returns an Interface0DIterator converted from this\n"
" StrokeVertexIterator. Useful for any call to a function of the\n" " StrokeVertexIterator. Useful for any call to a function of the\n"
" UnaryFunction0D type.\n" " UnaryFunction0D type.\n"
"\n" "\n"
" :return: An Interface0DIterator converted from the StrokeVertexIterator.\n" " :return: An Interface0DIterator converted from the StrokeVertexIterator.\n"
" :rtype: :class:`Interface0DIterator`\n"; " :rtype: :class:`Interface0DIterator`");
static PyObject * StrokeVertexIterator_castToInterface0DIterator( BPy_StrokeVertexIterator *self ) { static PyObject * StrokeVertexIterator_cast_to_interface0diterator(BPy_StrokeVertexIterator *self)
Interface0DIterator it( self->sv_it->castToInterface0DIterator() ); {
return BPy_Interface0DIterator_from_Interface0DIterator( it, 0 ); Interface0DIterator it(self->sv_it->castToInterface0DIterator());
return BPy_Interface0DIterator_from_Interface0DIterator(it, 0);
} }
static char StrokeVertexIterator_getObject___doc__[] = static PyMethodDef BPy_StrokeVertexIterator_methods[] = {
".. method:: getObject()\n" {"cast_to_interface0diterator", (PyCFunction) StrokeVertexIterator_cast_to_interface0diterator, METH_NOARGS, StrokeVertexIterator_cast_to_interface0diterator_doc},
"\n" {NULL, NULL, 0, NULL}
" Returns the pointed StrokeVertex.\n" };
"\n"
" :return: The pointed StrokeVertex.\n"
" :rtype: :class:`StrokeVertex`\n";
static PyObject * StrokeVertexIterator_getObject( BPy_StrokeVertexIterator *self) { /*----------------------StrokeVertexIterator get/setters ----------------------------*/
PyDoc_STRVAR(StrokeVertexIterator_object_doc,
"The StrokeVertex object currently pointed by this iterator.\n"
"\n"
":type: :class:`StrokeVertex`");
static PyObject *StrokeVertexIterator_object_get(BPy_StrokeVertexIterator *self, void *UNUSED(closure))
{
if (!self->reversed && self->sv_it->isEnd()) if (!self->reversed && self->sv_it->isEnd())
Py_RETURN_NONE; Py_RETURN_NONE;
StrokeVertex *sv = self->sv_it->operator->(); StrokeVertex *sv = self->sv_it->operator->();
if( sv ) if (sv)
return BPy_StrokeVertex_from_StrokeVertex( *sv ); return BPy_StrokeVertex_from_StrokeVertex(*sv);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/*----------------------StrokeVertexIterator instance definitions ----------------------------*/ PyDoc_STRVAR(StrokeVertexIterator_t_doc,
static PyMethodDef BPy_StrokeVertexIterator_methods[] = { "The curvilinear abscissa of the current point.\n"
{"t", ( PyCFunction ) StrokeVertexIterator_t, METH_NOARGS, StrokeVertexIterator_t___doc__}, "\n"
{"u", ( PyCFunction ) StrokeVertexIterator_u, METH_NOARGS, StrokeVertexIterator_u___doc__}, ":type: float");
{"castToInterface0DIterator", ( PyCFunction ) StrokeVertexIterator_castToInterface0DIterator, METH_NOARGS, StrokeVertexIterator_castToInterface0DIterator___doc__},
{"getObject", ( PyCFunction ) StrokeVertexIterator_getObject, METH_NOARGS, StrokeVertexIterator_getObject___doc__}, static PyObject *StrokeVertexIterator_t_get(BPy_StrokeVertexIterator *self, void *UNUSED(closure))
{NULL, NULL, 0, NULL} {
return PyFloat_FromDouble(self->sv_it->t());
}
PyDoc_STRVAR(StrokeVertexIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *StrokeVertexIterator_u_get(BPy_StrokeVertexIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->sv_it->u());
}
static PyGetSetDef BPy_StrokeVertexIterator_getseters[] = {
{(char *)"object", (getter)StrokeVertexIterator_object_get, (setter)NULL, (char *)StrokeVertexIterator_object_doc, NULL},
{(char *)"t", (getter)StrokeVertexIterator_t_get, (setter)NULL, (char *)StrokeVertexIterator_t_doc, NULL},
{(char *)"u", (getter)StrokeVertexIterator_u_get, (setter)NULL, (char *)StrokeVertexIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
}; };
/*-----------------------BPy_StrokeVertexIterator type definition ------------------------------*/ /*-----------------------BPy_StrokeVertexIterator type definition ------------------------------*/
@@ -170,7 +173,7 @@ PyTypeObject StrokeVertexIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
StrokeVertexIterator___doc__, /* tp_doc */ StrokeVertexIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -179,13 +182,13 @@ PyTypeObject StrokeVertexIterator_Type = {
(iternextfunc)StrokeVertexIterator_iternext, /* tp_iternext */ (iternextfunc)StrokeVertexIterator_iternext, /* tp_iternext */
BPy_StrokeVertexIterator_methods, /* tp_methods */ BPy_StrokeVertexIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_StrokeVertexIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */ &Iterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)StrokeVertexIterator___init__, /* tp_init */ (initproc)StrokeVertexIterator_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
0, /* tp_new */ 0, /* tp_new */
}; };

254
source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp
View File

@@ -12,7 +12,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char ViewEdgeIterator___doc__[] = PyDoc_STRVAR(ViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator`\n"
"\n" "\n"
"Base class for iterators over ViewEdges of the :class:`ViewMap` Graph.\n" "Base class for iterators over ViewEdges of the :class:`ViewMap` Graph.\n"
@@ -38,32 +38,31 @@ static char ViewEdgeIterator___doc__[] =
" Copy constructor.\n" " Copy constructor.\n"
"\n" "\n"
" :arg it: A ViewEdgeIterator object.\n" " :arg it: A ViewEdgeIterator object.\n"
" :type it: :class:`ViewEdgeIterator`\n"; " :type it: :class:`ViewEdgeIterator`");
static int ViewEdgeIterator___init__(BPy_ViewEdgeIterator *self, PyObject *args ) static int ViewEdgeIterator_init(BPy_ViewEdgeIterator *self, PyObject *args)
{ {
PyObject *obj1 = 0, *obj2 = 0; PyObject *obj1 = 0, *obj2 = 0;
if (!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) )) if (!PyArg_ParseTuple(args, "O|O", &obj1, &obj2))
return -1; return -1;
if( obj1 && BPy_ViewEdgeIterator_Check(obj1) ) { if (BPy_ViewEdgeIterator_Check(obj1)) {
self->ve_it = new ViewEdgeInternal::ViewEdgeIterator(*( ((BPy_ViewEdgeIterator *) obj1)->ve_it )); self->ve_it = new ViewEdgeInternal::ViewEdgeIterator(*(((BPy_ViewEdgeIterator *)obj1)->ve_it));
} else { } else {
ViewEdge *begin; ViewEdge *begin;
if ( !obj1 || obj1 == Py_None ) if (obj1 == Py_None)
begin = NULL; begin = NULL;
else if ( BPy_ViewEdge_Check(obj1) ) else if (BPy_ViewEdge_Check(obj1))
begin = ((BPy_ViewEdge *) obj1)->ve; begin = ((BPy_ViewEdge *)obj1)->ve;
else { else {
PyErr_SetString(PyExc_TypeError, "1st argument must be either a ViewEdge object or None"); PyErr_SetString(PyExc_TypeError, "1st argument must be either a ViewEdge object or None");
return -1; return -1;
} }
bool orientation = ( obj2 ) ? bool_from_PyBool(obj2) : true; bool orientation = (obj2) ? bool_from_PyBool(obj2) : true;
self->ve_it = new ViewEdgeInternal::ViewEdgeIterator( begin, orientation);
self->ve_it = new ViewEdgeInternal::ViewEdgeIterator(begin, orientation);
} }
self->py_it.it = self->ve_it; self->py_it.it = self->ve_it;
@@ -71,149 +70,116 @@ static int ViewEdgeIterator___init__(BPy_ViewEdgeIterator *self, PyObject *args
return 0; return 0;
} }
static char ViewEdgeIterator_getCurrentEdge___doc__[] = PyDoc_STRVAR(ViewEdgeIterator_change_orientation_doc,
".. method:: getCurrentEdge()\n" ".. method:: change_orientation()\n"
"\n" "\n"
" Returns the current pointed ViewEdge.\n" " Changes the current orientation.");
"\n"
" :return: The current pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
static PyObject *ViewEdgeIterator_getCurrentEdge( BPy_ViewEdgeIterator *self ) { static PyObject *ViewEdgeIterator_change_orientation(BPy_ViewEdgeIterator *self)
ViewEdge *ve = self->ve_it->getCurrentEdge(); {
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_setCurrentEdge___doc__[] =
".. method:: setCurrentEdge(edge)\n"
"\n"
" Sets the current pointed ViewEdge.\n"
"\n"
" :arg edge: The current pointed ViewEdge.\n"
" :type edge: :class:`ViewEdge`\n";
static PyObject *ViewEdgeIterator_setCurrentEdge( BPy_ViewEdgeIterator *self, PyObject *args ) {
PyObject *py_ve;
if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
return NULL;
self->ve_it->setCurrentEdge( ((BPy_ViewEdge *) py_ve)->ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_getBegin___doc__[] =
".. method:: getBegin()\n"
"\n"
" Returns the first ViewEdge used for the iteration.\n"
"\n"
" :return: The first ViewEdge used for the iteration.\n"
" :rtype: :class:`ViewEdge`\n";
static PyObject *ViewEdgeIterator_getBegin( BPy_ViewEdgeIterator *self ) {
ViewEdge *ve = self->ve_it->getBegin();
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_setBegin___doc__[] =
".. method:: setBegin(begin)\n"
"\n"
" Sets the first ViewEdge used for the iteration.\n"
"\n"
" :arg begin: The first ViewEdge used for the iteration.\n"
" :type begin: :class:`ViewEdge`\n";
static PyObject *ViewEdgeIterator_setBegin( BPy_ViewEdgeIterator *self, PyObject *args ) {
PyObject *py_ve;
if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
return NULL;
self->ve_it->setBegin( ((BPy_ViewEdge *) py_ve)->ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_getOrientation___doc__[] =
".. method:: getOrientation()\n"
"\n"
" Returns the orientation of the pointed ViewEdge in the iteration.\n"
"\n"
" :return: The orientation of the pointed ViewEdge in the iteration.\n"
" :rtype: bool\n";
static PyObject *ViewEdgeIterator_getOrientation( BPy_ViewEdgeIterator *self ) {
return PyBool_from_bool( self->ve_it->getOrientation() );
}
static char ViewEdgeIterator_setOrientation___doc__[] =
".. method:: setOrientation(orientation)\n"
"\n"
" Sets the orientation of the pointed ViewEdge in the iteration.\n"
"\n"
" :arg orientation: If true, we'll look for the next ViewEdge among\n"
" the ViewEdges that surround the ending ViewVertex of begin. If\n"
" false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n"
" :type orientation: bool\n";
static PyObject *ViewEdgeIterator_setOrientation( BPy_ViewEdgeIterator *self, PyObject *args ) {
PyObject *py_b;
if(!( PyArg_ParseTuple(args, "O", &py_b) ))
return NULL;
self->ve_it->setOrientation( bool_from_PyBool(py_b) );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_changeOrientation___doc__[] =
".. method:: changeOrientation()\n"
"\n"
" Changes the current orientation.\n";
static PyObject *ViewEdgeIterator_changeOrientation( BPy_ViewEdgeIterator *self ) {
self->ve_it->changeOrientation(); self->ve_it->changeOrientation();
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static char ViewEdgeIterator_getObject___doc__[] = static PyMethodDef BPy_ViewEdgeIterator_methods[] = {
".. method:: getObject()\n" {"change_orientation", (PyCFunction) ViewEdgeIterator_change_orientation, METH_NOARGS, ViewEdgeIterator_change_orientation_doc},
"\n" {NULL, NULL, 0, NULL}
" Returns the pointed ViewEdge.\n" };
"\n"
" :return: The pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
static PyObject * ViewEdgeIterator_getObject( BPy_ViewEdgeIterator *self) { /*----------------------ViewEdgeIterator get/setters ----------------------------*/
PyDoc_STRVAR(ViewEdgeIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_object_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->ve_it->operator*(); ViewEdge *ve = self->ve_it->operator*();
if( ve ) if (ve)
return BPy_ViewEdge_from_ViewEdge( *ve ); return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/*----------------------ViewEdgeIterator instance definitions ----------------------------*/ PyDoc_STRVAR(ViewEdgeIterator_current_edge_doc,
static PyMethodDef BPy_ViewEdgeIterator_methods[] = { "The ViewEdge object currently pointed by this iterator.\n"
{"getCurrentEdge", ( PyCFunction ) ViewEdgeIterator_getCurrentEdge, METH_NOARGS, ViewEdgeIterator_getCurrentEdge___doc__}, "\n"
{"setCurrentEdge", ( PyCFunction ) ViewEdgeIterator_setCurrentEdge, METH_VARARGS, ViewEdgeIterator_setCurrentEdge___doc__}, ":type: :class:`ViewEdge`");
{"getBegin", ( PyCFunction ) ViewEdgeIterator_getBegin, METH_NOARGS, ViewEdgeIterator_getBegin___doc__},
{"setBegin", ( PyCFunction ) ViewEdgeIterator_setBegin, METH_VARARGS, ViewEdgeIterator_setBegin___doc__}, static PyObject *ViewEdgeIterator_current_edge_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{"getOrientation", ( PyCFunction ) ViewEdgeIterator_getOrientation, METH_NOARGS, ViewEdgeIterator_getOrientation___doc__}, {
{"setOrientation", ( PyCFunction ) ViewEdgeIterator_setOrientation, METH_VARARGS, ViewEdgeIterator_setOrientation___doc__}, ViewEdge *ve = self->ve_it->getCurrentEdge();
{"changeOrientation", ( PyCFunction ) ViewEdgeIterator_changeOrientation, METH_NOARGS, ViewEdgeIterator_changeOrientation___doc__}, if (ve)
{"getObject", ( PyCFunction ) ViewEdgeIterator_getObject, METH_NOARGS, ViewEdgeIterator_getObject___doc__}, return BPy_ViewEdge_from_ViewEdge(*ve);
{NULL, NULL, 0, NULL}
Py_RETURN_NONE;}
static int ViewEdgeIterator_current_edge_set(BPy_ViewEdgeIterator *self, PyObject *value, void *UNUSED(closure))
{
if (!BPy_ViewEdge_Check(value)) {
PyErr_SetString(PyExc_TypeError, "value must be a ViewEdge");
return -1;
}
self->ve_it->setCurrentEdge(((BPy_ViewEdge *)value)->ve);
return 0;
}
PyDoc_STRVAR(ViewEdgeIterator_orientation_doc,
"The orientation of the pointed ViewEdge in the iteration.\n"
"If true, the iterator looks for the next ViewEdge among those ViewEdges\n"
"that surround the ending ViewVertex of the \"begin\" ViewEdge. If false,\n"
"the iterator searches over the ViewEdges surrounding the ending ViewVertex\n"
"of the \"begin\" ViewEdge.\n"
"\n"
":type: bool");
static PyObject *ViewEdgeIterator_orientation_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->ve_it->getOrientation());
}
static int ViewEdgeIterator_orientation_set(BPy_ViewEdgeIterator *self, PyObject *value, void *UNUSED(closure))
{
if (!PyBool_Check(value)) {
PyErr_SetString(PyExc_TypeError, "value must be a boolean");
return -1;
}
self->ve_it->setOrientation(bool_from_PyBool(value));
return 0;
}
PyDoc_STRVAR(ViewEdgeIterator_begin_doc,
"The first ViewEdge used for the iteration.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_begin_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->ve_it->getBegin();
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;
}
static int ViewEdgeIterator_begin_set(BPy_ViewEdgeIterator *self, PyObject *value, void *UNUSED(closure))
{
if(!BPy_ViewEdge_Check(value)) {
PyErr_SetString(PyExc_TypeError, "value must be a ViewEdge");
return -1;
}
self->ve_it->setBegin(((BPy_ViewEdge *)value)->ve);
return 0;
}
static PyGetSetDef BPy_ViewEdgeIterator_getseters[] = {
{(char *)"object", (getter)ViewEdgeIterator_object_get, (setter)NULL, (char *)ViewEdgeIterator_object_doc, NULL},
{(char *)"current_edge", (getter)ViewEdgeIterator_current_edge_get, (setter)ViewEdgeIterator_current_edge_set, (char *)ViewEdgeIterator_current_edge_doc, NULL},
{(char *)"orientation", (getter)ViewEdgeIterator_orientation_get, (setter)ViewEdgeIterator_orientation_set, (char *)ViewEdgeIterator_orientation_doc, NULL},
{(char *)"begin", (getter)ViewEdgeIterator_begin_get, (setter)ViewEdgeIterator_begin_set, (char *)ViewEdgeIterator_begin_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
}; };
/*-----------------------BPy_ViewEdgeIterator type definition ------------------------------*/ /*-----------------------BPy_ViewEdgeIterator type definition ------------------------------*/
@@ -239,7 +205,7 @@ PyTypeObject ViewEdgeIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
ViewEdgeIterator___doc__, /* tp_doc */ ViewEdgeIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -248,13 +214,13 @@ PyTypeObject ViewEdgeIterator_Type = {
0, /* tp_iternext */ 0, /* tp_iternext */
BPy_ViewEdgeIterator_methods, /* tp_methods */ BPy_ViewEdgeIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_ViewEdgeIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */ &Iterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)ViewEdgeIterator___init__, /* tp_init */ (initproc)ViewEdgeIterator_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
0, /* tp_new */ 0, /* tp_new */
}; };

61
source/blender/freestyle/intern/python/Iterator/BPy_orientedViewEdgeIterator.cpp
View File

@@ -10,7 +10,7 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
static char orientedViewEdgeIterator___doc__[] = PyDoc_STRVAR(orientedViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`orientedViewEdgeIterator`\n" "Class hierarchy: :class:`Iterator` > :class:`orientedViewEdgeIterator`\n"
"\n" "\n"
"Class representing an iterator over oriented ViewEdges around a\n" "Class representing an iterator over oriented ViewEdges around a\n"
@@ -27,19 +27,19 @@ static char orientedViewEdgeIterator___doc__[] =
" Copy constructor.\n" " Copy constructor.\n"
"\n" "\n"
" :arg iBrother: An orientedViewEdgeIterator object.\n" " :arg iBrother: An orientedViewEdgeIterator object.\n"
" :type iBrother: :class:`orientedViewEdgeIterator`\n"; " :type iBrother: :class:`orientedViewEdgeIterator`");
static int orientedViewEdgeIterator___init__(BPy_orientedViewEdgeIterator *self, PyObject *args ) static int orientedViewEdgeIterator_init(BPy_orientedViewEdgeIterator *self, PyObject *args)
{ {
PyObject *obj = 0; PyObject *obj = 0;
if (!( PyArg_ParseTuple(args, "|O", &obj) )) if (!PyArg_ParseTuple(args, "|O", &obj))
return -1; return -1;
if( !obj ) if (!obj)
self->ove_it = new ViewVertexInternal::orientedViewEdgeIterator(); self->ove_it = new ViewVertexInternal::orientedViewEdgeIterator();
else if( BPy_orientedViewEdgeIterator_Check(obj) ) else if (BPy_orientedViewEdgeIterator_Check(obj))
self->ove_it = new ViewVertexInternal::orientedViewEdgeIterator(*( ((BPy_orientedViewEdgeIterator *) obj)->ove_it )); self->ove_it = new ViewVertexInternal::orientedViewEdgeIterator(*(((BPy_orientedViewEdgeIterator *)obj)->ove_it));
else { else {
PyErr_SetString(PyExc_TypeError, "invalid argument"); PyErr_SetString(PyExc_TypeError, "invalid argument");
return -1; return -1;
@@ -51,8 +51,10 @@ static int orientedViewEdgeIterator___init__(BPy_orientedViewEdgeIterator *self,
return 0; return 0;
} }
static PyObject * orientedViewEdgeIterator_iternext( BPy_orientedViewEdgeIterator *self ) { static PyObject * orientedViewEdgeIterator_iternext(BPy_orientedViewEdgeIterator *self)
{
ViewVertex::directedViewEdge *dve; ViewVertex::directedViewEdge *dve;
if (self->reversed) { if (self->reversed) {
if (self->ove_it->isBegin()) { if (self->ove_it->isBegin()) {
PyErr_SetNone(PyExc_StopIteration); PyErr_SetNone(PyExc_StopIteration);
@@ -68,28 +70,33 @@ static PyObject * orientedViewEdgeIterator_iternext( BPy_orientedViewEdgeIterato
dve = self->ove_it->operator->(); dve = self->ove_it->operator->();
self->ove_it->increment(); self->ove_it->increment();
} }
return BPy_directedViewEdge_from_directedViewEdge( *dve ); return BPy_directedViewEdge_from_directedViewEdge(*dve);
} }
static char orientedViewEdgeIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed oriented ViewEdge.\n"
"\n"
" :return: A tuple of the pointed ViewEdge and a boolean value. If\n"
" the boolean value is true, the ViewEdge is incoming.\n"
" :rtype: (:class:`directedViewEdge`, bool)\n";
static PyObject * orientedViewEdgeIterator_getObject( BPy_orientedViewEdgeIterator *self) {
return BPy_directedViewEdge_from_directedViewEdge( self->ove_it->operator*() );
}
/*----------------------orientedViewEdgeIterator instance definitions ----------------------------*/
static PyMethodDef BPy_orientedViewEdgeIterator_methods[] = { static PyMethodDef BPy_orientedViewEdgeIterator_methods[] = {
{"getObject", ( PyCFunction ) orientedViewEdgeIterator_getObject, METH_NOARGS, orientedViewEdgeIterator_getObject___doc__},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
/*----------------------orientedViewEdgeIterator get/setters ----------------------------*/
PyDoc_STRVAR(orientedViewEdgeIterator_object_doc,
"The oriented ViewEdge (i.e., a tuple of the pointed ViewEdge and a boolean\n"
"value) currently pointed by this iterator. If the boolean value is true,\n"
"the ViewEdge is incoming.\n"
"\n"
":type: (:class:`directedViewEdge`, bool)");
static PyObject *orientedViewEdgeIterator_object_get(BPy_orientedViewEdgeIterator *self, void *UNUSED(closure))
{
return BPy_directedViewEdge_from_directedViewEdge(self->ove_it->operator*());
}
static PyGetSetDef BPy_orientedViewEdgeIterator_getseters[] = {
{(char *)"object", (getter)orientedViewEdgeIterator_object_get, (setter)NULL, (char *)orientedViewEdgeIterator_object_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_orientedViewEdgeIterator type definition ------------------------------*/ /*-----------------------BPy_orientedViewEdgeIterator type definition ------------------------------*/
PyTypeObject orientedViewEdgeIterator_Type = { PyTypeObject orientedViewEdgeIterator_Type = {
@@ -113,7 +120,7 @@ PyTypeObject orientedViewEdgeIterator_Type = {
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
orientedViewEdgeIterator___doc__, /* tp_doc */ orientedViewEdgeIterator_doc, /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
@@ -122,13 +129,13 @@ PyTypeObject orientedViewEdgeIterator_Type = {
(iternextfunc)orientedViewEdgeIterator_iternext, /* tp_iternext */ (iternextfunc)orientedViewEdgeIterator_iternext, /* tp_iternext */
BPy_orientedViewEdgeIterator_methods, /* tp_methods */ BPy_orientedViewEdgeIterator_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ BPy_orientedViewEdgeIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */ &Iterator_Type, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)orientedViewEdgeIterator___init__, /* tp_init */ (initproc)orientedViewEdgeIterator_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
0, /* tp_new */ 0, /* tp_new */
}; };