forked from bartvdbraak/blender
9f79d8ae67
This allows users to test the types of those objects that are returned
by API functions, by means of usual Python idioms such as "type(I) is T"
and "isinstance(I, T)".
* Removed all occurrences of ViewVertex::castToTVertex() in the following
modules and rewrote the code segments using it by means of the "type(I)
is T" idiom mentioned above:
ChainingIterators.py
PredicatesU1D.py
* Replaced all occurrences of vector.Vec2, vector.Vec3, Vec2f and Vec3f
by Blender.Mathutils.Vector in the following modules:
anisotropic_diffusion.py
Functions0D.py
shaders.py
sketchy_topology_broken.py
* shaders.py: Fixed NameError's concerning math.pow().
* shaders.py: Added a Python equivalent of getFEdge function, defined
in source\blender\freestyle\intern\view_map\Functions0D.cpp as follows:
FEdge* Functions0D::getFEdge(Interface0D& it1, Interface0D& it2) {
return it1.getFEdge(it2);
}
* shaders.py: Replaced fe.qi() by fe.viewedge().qi().
* contour.py: Fixed the import statement for freestyle_init.py.
732 lines
24 KiB
Python
Executable File
732 lines
24 KiB
Python
Executable File
#
|
|
# Filename : ChainingIterators.py
|
|
# Author : Stephane Grabli
|
|
# Date : 04/08/2005
|
|
# Purpose : Chaining Iterators to be used with chaining operators
|
|
#
|
|
#############################################################################
|
|
#
|
|
# Copyright (C) : Please refer to the COPYRIGHT file distributed
|
|
# with this source distribution.
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
#
|
|
#############################################################################
|
|
|
|
from freestyle_init import *
|
|
|
|
## the natural chaining iterator
|
|
## It follows the edges of same nature following the topology of
|
|
## objects with preseance on silhouettes, then borders,
|
|
## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
|
|
## You can specify whether to stay in the selection or not.
|
|
class pyChainSilhouetteIterator(ChainingIterator):
|
|
def __init__(self, stayInSelection=1):
|
|
ChainingIterator.__init__(self, stayInSelection, 1,None,1)
|
|
def getExactTypeName(self):
|
|
return "pyChainSilhouetteIterator"
|
|
def init(self):
|
|
pass
|
|
def traverse(self, iter):
|
|
winner = None
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == mateVE.getId() ):
|
|
winner = ve
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for i in range(len(natures)):
|
|
currentNature = self.getCurrentEdge().getNature()
|
|
if(natures[i] & currentNature):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
visitNext = 0
|
|
oNature = it.getObject().getNature()
|
|
if(oNature & natures[i] != 0):
|
|
if(natures[i] != oNature):
|
|
for j in range(i):
|
|
if(natures[j] & oNature != 0):
|
|
visitNext = 1
|
|
break
|
|
if(visitNext != 0):
|
|
break
|
|
count = count+1
|
|
winner = it.getObject()
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
return winner
|
|
|
|
## the natural chaining iterator
|
|
## It follows the edges of same nature on the same
|
|
## objects with preseance on silhouettes, then borders,
|
|
## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
|
|
## You can specify whether to stay in the selection or not.
|
|
## You can specify whether to chain iterate over edges that were
|
|
## already visited or not.
|
|
class pyChainSilhouetteGenericIterator(ChainingIterator):
|
|
def __init__(self, stayInSelection=1, stayInUnvisited=1):
|
|
ChainingIterator.__init__(self, stayInSelection, stayInUnvisited,None,1)
|
|
def getExactTypeName(self):
|
|
return "pyChainSilhouetteGenericIterator"
|
|
def init(self):
|
|
pass
|
|
def traverse(self, iter):
|
|
winner = None
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == mateVE.getId() ):
|
|
winner = ve
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for i in range(len(natures)):
|
|
currentNature = self.getCurrentEdge().getNature()
|
|
if(natures[i] & currentNature):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
visitNext = 0
|
|
oNature = it.getObject().getNature()
|
|
ve = it.getObject()
|
|
if(ve.getId() == self.getCurrentEdge().getId()):
|
|
it.increment()
|
|
continue
|
|
if(oNature & natures[i] != 0):
|
|
if(natures[i] != oNature):
|
|
for j in range(i):
|
|
if(natures[j] & oNature != 0):
|
|
visitNext = 1
|
|
break
|
|
if(visitNext != 0):
|
|
break
|
|
count = count+1
|
|
winner = ve
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
return winner
|
|
|
|
class pyExternalContourChainingIterator(ChainingIterator):
|
|
def __init__(self):
|
|
ChainingIterator.__init__(self, 0, 1,None,1)
|
|
self._isExternalContour = ExternalContourUP1D()
|
|
|
|
def getExactTypeName(self):
|
|
return "pyExternalContourIterator"
|
|
|
|
def init(self):
|
|
self._nEdges = 0
|
|
self._isInSelection = 1
|
|
|
|
def checkViewEdge(self, ve, orientation):
|
|
if(orientation != 0):
|
|
vertex = ve.B()
|
|
else:
|
|
vertex = ve.A()
|
|
it = AdjacencyIterator(vertex,1,1)
|
|
while(it.isEnd() == 0):
|
|
ave = it.getObject()
|
|
if(self._isExternalContour(ave)):
|
|
return 1
|
|
it.increment()
|
|
print "pyExternlContourChainingIterator : didn't find next edge"
|
|
return 0
|
|
def traverse(self, iter):
|
|
winner = None
|
|
it = AdjacencyIterator(iter)
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(self._isExternalContour(ve)):
|
|
if (ve.getTimeStamp() == GetTimeStampCF()):
|
|
winner = ve
|
|
it.increment()
|
|
|
|
self._nEdges = self._nEdges+1
|
|
if(winner == None):
|
|
orient = 1
|
|
it = AdjacencyIterator(iter)
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(it.isIncoming() != 0):
|
|
orient = 0
|
|
good = self.checkViewEdge(ve,orient)
|
|
if(good != 0):
|
|
winner = ve
|
|
it.increment()
|
|
return winner
|
|
|
|
## the natural chaining iterator
|
|
## with a sketchy multiple touch
|
|
class pySketchyChainSilhouetteIterator(ChainingIterator):
|
|
def __init__(self, nRounds=3,stayInSelection=1):
|
|
ChainingIterator.__init__(self, stayInSelection, 0,None,1)
|
|
self._timeStamp = GetTimeStampCF()+nRounds
|
|
self._nRounds = nRounds
|
|
def getExactTypeName(self):
|
|
return "pySketchyChainSilhouetteIterator"
|
|
def init(self):
|
|
self._timeStamp = GetTimeStampCF()+self._nRounds
|
|
def traverse(self, iter):
|
|
winner = None
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == mateVE.getId() ):
|
|
winner = ve
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for i in range(len(natures)):
|
|
currentNature = self.getCurrentEdge().getNature()
|
|
if(natures[i] & currentNature):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
visitNext = 0
|
|
oNature = it.getObject().getNature()
|
|
ve = it.getObject()
|
|
if(ve.getId() == self.getCurrentEdge().getId()):
|
|
it.increment()
|
|
continue
|
|
if(oNature & natures[i] != 0):
|
|
if(natures[i] != oNature):
|
|
for j in range(i):
|
|
if(natures[j] & oNature != 0):
|
|
visitNext = 1
|
|
break
|
|
if(visitNext != 0):
|
|
break
|
|
count = count+1
|
|
winner = ve
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
if(winner == None):
|
|
winner = self.getCurrentEdge()
|
|
if(winner.getChainingTimeStamp() == self._timeStamp):
|
|
winner = None
|
|
return winner
|
|
|
|
|
|
# Chaining iterator designed for sketchy style.
|
|
# can chain several times the same ViewEdge
|
|
# in order to produce multiple strokes per ViewEdge.
|
|
class pySketchyChainingIterator(ChainingIterator):
|
|
def __init__(self, nRounds=3, stayInSelection=1):
|
|
ChainingIterator.__init__(self, stayInSelection, 0,None,1)
|
|
self._timeStamp = GetTimeStampCF()+nRounds
|
|
self._nRounds = nRounds
|
|
def getExactTypeName(self):
|
|
return "pySketchyChainingIterator"
|
|
|
|
def init(self):
|
|
self._timeStamp = GetTimeStampCF()+self._nRounds
|
|
|
|
def traverse(self, iter):
|
|
winner = None
|
|
it = AdjacencyIterator(iter)
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == self.getCurrentEdge().getId()):
|
|
it.increment()
|
|
continue
|
|
winner = ve
|
|
it.increment()
|
|
if(winner == None):
|
|
winner = self.getCurrentEdge()
|
|
if(winner.getChainingTimeStamp() == self._timeStamp):
|
|
return None
|
|
return winner
|
|
|
|
|
|
## Chaining iterator that fills small occlusions
|
|
## percent
|
|
## The max length of the occluded part
|
|
## expressed in % of the total chain length
|
|
class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
|
|
def __init__(self, percent):
|
|
ChainingIterator.__init__(self, 0, 1,None,1)
|
|
self._length = 0
|
|
self._percent = float(percent)
|
|
def getExactTypeName(self):
|
|
return "pyFillOcclusionsChainingIterator"
|
|
def init(self):
|
|
# each time we're evaluating a chain length
|
|
# we try to do it once. Thus we reinit
|
|
# the chain length here:
|
|
self._length = 0
|
|
def traverse(self, iter):
|
|
winner = None
|
|
winnerOrientation = 0
|
|
print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == mateVE.getId() ):
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for nat in natures:
|
|
if(self.getCurrentEdge().getNature() & nat != 0):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getNature() & nat != 0):
|
|
count = count+1
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
if(winner != None):
|
|
# check whether this edge was part of the selection
|
|
if(winner.getTimeStamp() != GetTimeStampCF()):
|
|
#print "---", winner.getId().getFirst(), winner.getId().getSecond()
|
|
# if not, let's check whether it's short enough with
|
|
# respect to the chain made without staying in the selection
|
|
#------------------------------------------------------------
|
|
# Did we compute the prospective chain length already ?
|
|
if(self._length == 0):
|
|
#if not, let's do it
|
|
_it = pyChainSilhouetteGenericIterator(0,0)
|
|
_it.setBegin(winner)
|
|
_it.setCurrentEdge(winner)
|
|
_it.setOrientation(winnerOrientation)
|
|
_it.init()
|
|
while(_it.isEnd() == 0):
|
|
ve = _it.getObject()
|
|
#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
self._length = self._length + ve.getLength2D()
|
|
_it.increment()
|
|
if(_it.isBegin() != 0):
|
|
break;
|
|
_it.setBegin(winner)
|
|
_it.setCurrentEdge(winner)
|
|
_it.setOrientation(winnerOrientation)
|
|
if(_it.isBegin() == 0):
|
|
_it.decrement()
|
|
while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
|
|
ve = _it.getObject()
|
|
#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
self._length = self._length + ve.getLength2D()
|
|
_it.decrement()
|
|
|
|
# let's do the comparison:
|
|
# nw let's compute the length of this connex non selected part:
|
|
connexl = 0
|
|
_cit = pyChainSilhouetteGenericIterator(0,0)
|
|
_cit.setBegin(winner)
|
|
_cit.setCurrentEdge(winner)
|
|
_cit.setOrientation(winnerOrientation)
|
|
_cit.init()
|
|
while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
|
|
ve = _cit.getObject()
|
|
#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
connexl = connexl + ve.getLength2D()
|
|
_cit.increment()
|
|
if(connexl > self._percent * self._length):
|
|
winner = None
|
|
return winner
|
|
|
|
## Chaining iterator that fills small occlusions
|
|
## size
|
|
## The max length of the occluded part
|
|
## expressed in pixels
|
|
class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
|
|
def __init__(self, length):
|
|
ChainingIterator.__init__(self, 0, 1,None,1)
|
|
self._length = float(length)
|
|
def getExactTypeName(self):
|
|
return "pySmallFillOcclusionsChainingIterator"
|
|
def init(self):
|
|
pass
|
|
def traverse(self, iter):
|
|
winner = None
|
|
winnerOrientation = 0
|
|
#print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == mateVE.getId() ):
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for nat in natures:
|
|
if(self.getCurrentEdge().getNature() & nat != 0):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getNature() & nat != 0):
|
|
count = count+1
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
if(winner != None):
|
|
# check whether this edge was part of the selection
|
|
if(winner.getTimeStamp() != GetTimeStampCF()):
|
|
#print "---", winner.getId().getFirst(), winner.getId().getSecond()
|
|
# nw let's compute the length of this connex non selected part:
|
|
connexl = 0
|
|
_cit = pyChainSilhouetteGenericIterator(0,0)
|
|
_cit.setBegin(winner)
|
|
_cit.setCurrentEdge(winner)
|
|
_cit.setOrientation(winnerOrientation)
|
|
_cit.init()
|
|
while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
|
|
ve = _cit.getObject()
|
|
#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
connexl = connexl + ve.getLength2D()
|
|
_cit.increment()
|
|
if(connexl > self._length):
|
|
winner = None
|
|
return winner
|
|
|
|
|
|
## Chaining iterator that fills small occlusions
|
|
## percent
|
|
## The max length of the occluded part
|
|
## expressed in % of the total chain length
|
|
class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
|
|
def __init__(self, percent, l):
|
|
ChainingIterator.__init__(self, 0, 1,None,1)
|
|
self._length = 0
|
|
self._absLength = l
|
|
self._percent = float(percent)
|
|
def getExactTypeName(self):
|
|
return "pyFillOcclusionsChainingIterator"
|
|
def init(self):
|
|
# each time we're evaluating a chain length
|
|
# we try to do it once. Thus we reinit
|
|
# the chain length here:
|
|
self._length = 0
|
|
def traverse(self, iter):
|
|
winner = None
|
|
winnerOrientation = 0
|
|
print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == mateVE.getId() ):
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for nat in natures:
|
|
if(self.getCurrentEdge().getNature() & nat != 0):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getNature() & nat != 0):
|
|
count = count+1
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
if(winner != None):
|
|
# check whether this edge was part of the selection
|
|
if(winner.getTimeStamp() != GetTimeStampCF()):
|
|
#print "---", winner.getId().getFirst(), winner.getId().getSecond()
|
|
# if not, let's check whether it's short enough with
|
|
# respect to the chain made without staying in the selection
|
|
#------------------------------------------------------------
|
|
# Did we compute the prospective chain length already ?
|
|
if(self._length == 0):
|
|
#if not, let's do it
|
|
_it = pyChainSilhouetteGenericIterator(0,0)
|
|
_it.setBegin(winner)
|
|
_it.setCurrentEdge(winner)
|
|
_it.setOrientation(winnerOrientation)
|
|
_it.init()
|
|
while(_it.isEnd() == 0):
|
|
ve = _it.getObject()
|
|
#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
self._length = self._length + ve.getLength2D()
|
|
_it.increment()
|
|
if(_it.isBegin() != 0):
|
|
break;
|
|
_it.setBegin(winner)
|
|
_it.setCurrentEdge(winner)
|
|
_it.setOrientation(winnerOrientation)
|
|
if(_it.isBegin() == 0):
|
|
_it.decrement()
|
|
while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
|
|
ve = _it.getObject()
|
|
#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
self._length = self._length + ve.getLength2D()
|
|
_it.decrement()
|
|
|
|
# let's do the comparison:
|
|
# nw let's compute the length of this connex non selected part:
|
|
connexl = 0
|
|
_cit = pyChainSilhouetteGenericIterator(0,0)
|
|
_cit.setBegin(winner)
|
|
_cit.setCurrentEdge(winner)
|
|
_cit.setOrientation(winnerOrientation)
|
|
_cit.init()
|
|
while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
|
|
ve = _cit.getObject()
|
|
#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
connexl = connexl + ve.getLength2D()
|
|
_cit.increment()
|
|
if((connexl > self._percent * self._length) or (connexl > self._absLength)):
|
|
winner = None
|
|
return winner
|
|
|
|
## Chaining iterator that fills small occlusions without caring about the
|
|
## actual selection
|
|
## percent
|
|
## The max length of the occluded part
|
|
## expressed in % of the total chain length
|
|
class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
|
|
def __init__(self, percent, l):
|
|
ChainingIterator.__init__(self, 0, 1,None,1)
|
|
self._length = 0
|
|
self._absLength = l
|
|
self._percent = float(percent)
|
|
def getExactTypeName(self):
|
|
return "pyFillOcclusionsChainingIterator"
|
|
def init(self):
|
|
# each time we're evaluating a chain length
|
|
# we try to do it once. Thus we reinit
|
|
# the chain length here:
|
|
self._length = 0
|
|
def traverse(self, iter):
|
|
winner = None
|
|
winnerOrientation = 0
|
|
print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getId() == mateVE.getId() ):
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for nat in natures:
|
|
if(self.getCurrentEdge().getNature() & nat != 0):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
if(ve.getNature() & nat != 0):
|
|
count = count+1
|
|
winner = ve
|
|
if(it.isIncoming() == 0):
|
|
winnerOrientation = 1
|
|
else:
|
|
winnerOrientation = 0
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
if(winner != None):
|
|
# check whether this edge was part of the selection
|
|
if(winner.qi() != 0):
|
|
#print "---", winner.getId().getFirst(), winner.getId().getSecond()
|
|
# if not, let's check whether it's short enough with
|
|
# respect to the chain made without staying in the selection
|
|
#------------------------------------------------------------
|
|
# Did we compute the prospective chain length already ?
|
|
if(self._length == 0):
|
|
#if not, let's do it
|
|
_it = pyChainSilhouetteGenericIterator(0,0)
|
|
_it.setBegin(winner)
|
|
_it.setCurrentEdge(winner)
|
|
_it.setOrientation(winnerOrientation)
|
|
_it.init()
|
|
while(_it.isEnd() == 0):
|
|
ve = _it.getObject()
|
|
#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
self._length = self._length + ve.getLength2D()
|
|
_it.increment()
|
|
if(_it.isBegin() != 0):
|
|
break;
|
|
_it.setBegin(winner)
|
|
_it.setCurrentEdge(winner)
|
|
_it.setOrientation(winnerOrientation)
|
|
if(_it.isBegin() == 0):
|
|
_it.decrement()
|
|
while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
|
|
ve = _it.getObject()
|
|
#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
self._length = self._length + ve.getLength2D()
|
|
_it.decrement()
|
|
|
|
# let's do the comparison:
|
|
# nw let's compute the length of this connex non selected part:
|
|
connexl = 0
|
|
_cit = pyChainSilhouetteGenericIterator(0,0)
|
|
_cit.setBegin(winner)
|
|
_cit.setCurrentEdge(winner)
|
|
_cit.setOrientation(winnerOrientation)
|
|
_cit.init()
|
|
while((_cit.isEnd() == 0) and (_cit.getObject().qi() != 0)):
|
|
ve = _cit.getObject()
|
|
#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
|
|
connexl = connexl + ve.getLength2D()
|
|
_cit.increment()
|
|
if((connexl > self._percent * self._length) or (connexl > self._absLength)):
|
|
winner = None
|
|
return winner
|
|
|
|
|
|
## the natural chaining iterator
|
|
## It follows the edges of same nature on the same
|
|
## objects with preseance on silhouettes, then borders,
|
|
## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
|
|
## You can specify whether to stay in the selection or not.
|
|
class pyNoIdChainSilhouetteIterator(ChainingIterator):
|
|
def __init__(self, stayInSelection=1):
|
|
ChainingIterator.__init__(self, stayInSelection, 1,None,1)
|
|
def getExactTypeName(self):
|
|
return "pyChainSilhouetteIterator"
|
|
def init(self):
|
|
pass
|
|
def traverse(self, iter):
|
|
winner = None
|
|
it = AdjacencyIterator(iter)
|
|
tvertex = self.getVertex()
|
|
if type(tvertex) is TVertex:
|
|
mateVE = tvertex.mate(self.getCurrentEdge())
|
|
while(it.isEnd() == 0):
|
|
ve = it.getObject()
|
|
feB = self.getCurrentEdge().fedgeB()
|
|
feA = ve.fedgeA()
|
|
vB = feB.vertexB()
|
|
vA = feA.vertexA()
|
|
if vA.getId().getFirst() == vB.getId().getFirst():
|
|
winner = ve
|
|
break
|
|
feA = self.getCurrentEdge().fedgeA()
|
|
feB = ve.fedgeB()
|
|
vB = feB.vertexB()
|
|
vA = feA.vertexA()
|
|
if vA.getId().getFirst() == vB.getId().getFirst():
|
|
winner = ve
|
|
break
|
|
feA = self.getCurrentEdge().fedgeB()
|
|
feB = ve.fedgeB()
|
|
vB = feB.vertexB()
|
|
vA = feA.vertexB()
|
|
if vA.getId().getFirst() == vB.getId().getFirst():
|
|
winner = ve
|
|
break
|
|
feA = self.getCurrentEdge().fedgeA()
|
|
feB = ve.fedgeA()
|
|
vB = feB.vertexA()
|
|
vA = feA.vertexA()
|
|
if vA.getId().getFirst() == vB.getId().getFirst():
|
|
winner = ve
|
|
break
|
|
it.increment()
|
|
else:
|
|
## case of NonTVertex
|
|
natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
|
|
for i in range(len(natures)):
|
|
currentNature = self.getCurrentEdge().getNature()
|
|
if(natures[i] & currentNature):
|
|
count=0
|
|
while(it.isEnd() == 0):
|
|
visitNext = 0
|
|
oNature = it.getObject().getNature()
|
|
if(oNature & natures[i] != 0):
|
|
if(natures[i] != oNature):
|
|
for j in range(i):
|
|
if(natures[j] & oNature != 0):
|
|
visitNext = 1
|
|
break
|
|
if(visitNext != 0):
|
|
break
|
|
count = count+1
|
|
winner = it.getObject()
|
|
it.increment()
|
|
if(count != 1):
|
|
winner = None
|
|
break
|
|
return winner
|
|
|