forked from bartvdbraak/blender
382 lines
10 KiB
Python
382 lines
10 KiB
Python
from freestyle_init import *
|
|
from Functions1D import *
|
|
|
|
count = 0
|
|
class pyNFirstUP1D(UnaryPredicate1D):
|
|
def __init__(self, n):
|
|
UnaryPredicate1D.__init__(self)
|
|
self.__n = n
|
|
def __call__(self, inter):
|
|
global count
|
|
count = count + 1
|
|
if count <= self.__n:
|
|
return 1
|
|
return 0
|
|
|
|
class pyHigherLengthUP1D(UnaryPredicate1D):
|
|
def __init__(self,l):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._l = l
|
|
|
|
def getName(self):
|
|
return "HigherLengthUP1D"
|
|
|
|
def __call__(self, inter):
|
|
return (inter.getLength2D() > self._l)
|
|
|
|
class pyNatureUP1D(UnaryPredicate1D):
|
|
def __init__(self,nature):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._nature = nature
|
|
self._getNature = CurveNatureF1D()
|
|
|
|
def getName(self):
|
|
return "pyNatureUP1D"
|
|
|
|
def __call__(self, inter):
|
|
if(self._getNature(inter) & self._nature):
|
|
return 1
|
|
return 0
|
|
|
|
class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
|
|
def __init__(self,n,a):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._n = n
|
|
self._a = a
|
|
|
|
def getName(self):
|
|
return "HigherNumberOfTurnsUP1D"
|
|
|
|
def __call__(self, inter):
|
|
count = 0
|
|
func = Curvature2DAngleF0D()
|
|
it = inter.verticesBegin()
|
|
while(it.isEnd() == 0):
|
|
if(func(it) > self._a):
|
|
count = count+1
|
|
if(count > self._n):
|
|
return 1
|
|
it.increment()
|
|
return 0
|
|
|
|
class pyDensityUP1D(UnaryPredicate1D):
|
|
def __init__(self,wsize,threshold, integration = IntegrationType.MEAN, sampling=2.0):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._wsize = wsize
|
|
self._threshold = threshold
|
|
self._integration = integration
|
|
self._func = DensityF1D(self._wsize, self._integration, sampling)
|
|
|
|
def getName(self):
|
|
return "pyDensityUP1D"
|
|
|
|
def __call__(self, inter):
|
|
if(self._func(inter) < self._threshold):
|
|
return 1
|
|
return 0
|
|
|
|
class pyLowSteerableViewMapDensityUP1D(UnaryPredicate1D):
|
|
def __init__(self,threshold, level,integration = IntegrationType.MEAN):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._threshold = threshold
|
|
self._level = level
|
|
self._integration = integration
|
|
|
|
def getName(self):
|
|
return "pyLowSteerableViewMapDensityUP1D"
|
|
|
|
def __call__(self, inter):
|
|
func = GetSteerableViewMapDensityF1D(self._level, self._integration)
|
|
v = func(inter)
|
|
print(v)
|
|
if(v < self._threshold):
|
|
return 1
|
|
return 0
|
|
|
|
class pyLowDirectionalViewMapDensityUP1D(UnaryPredicate1D):
|
|
def __init__(self,threshold, orientation, level,integration = IntegrationType.MEAN):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._threshold = threshold
|
|
self._orientation = orientation
|
|
self._level = level
|
|
self._integration = integration
|
|
|
|
def getName(self):
|
|
return "pyLowDirectionalViewMapDensityUP1D"
|
|
|
|
def __call__(self, inter):
|
|
func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration)
|
|
v = func(inter)
|
|
#print(v)
|
|
if(v < self._threshold):
|
|
return 1
|
|
return 0
|
|
|
|
class pyHighSteerableViewMapDensityUP1D(UnaryPredicate1D):
|
|
def __init__(self,threshold, level,integration = IntegrationType.MEAN):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._threshold = threshold
|
|
self._level = level
|
|
self._integration = integration
|
|
self._func = GetSteerableViewMapDensityF1D(self._level, self._integration)
|
|
def getName(self):
|
|
return "pyHighSteerableViewMapDensityUP1D"
|
|
|
|
def __call__(self, inter):
|
|
|
|
v = self._func(inter)
|
|
if(v > self._threshold):
|
|
return 1
|
|
return 0
|
|
|
|
class pyHighDirectionalViewMapDensityUP1D(UnaryPredicate1D):
|
|
def __init__(self,threshold, orientation, level,integration = IntegrationType.MEAN, sampling=2.0):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._threshold = threshold
|
|
self._orientation = orientation
|
|
self._level = level
|
|
self._integration = integration
|
|
self._sampling = sampling
|
|
def getName(self):
|
|
return "pyLowDirectionalViewMapDensityUP1D"
|
|
|
|
def __call__(self, inter):
|
|
func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration, self._sampling)
|
|
v = func(inter)
|
|
if(v > self._threshold):
|
|
return 1
|
|
return 0
|
|
|
|
class pyHighViewMapDensityUP1D(UnaryPredicate1D):
|
|
def __init__(self,threshold, level,integration = IntegrationType.MEAN, sampling=2.0):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._threshold = threshold
|
|
self._level = level
|
|
self._integration = integration
|
|
self._sampling = sampling
|
|
self._func = GetCompleteViewMapDensityF1D(self._level, self._integration, self._sampling) # 2.0 is the smpling
|
|
|
|
def getName(self):
|
|
return "pyHighViewMapDensityUP1D"
|
|
|
|
def __call__(self, inter):
|
|
#print("toto")
|
|
#print(func.getName())
|
|
#print(inter.getExactTypeName())
|
|
v= self._func(inter)
|
|
if(v > self._threshold):
|
|
return 1
|
|
return 0
|
|
|
|
class pyDensityFunctorUP1D(UnaryPredicate1D):
|
|
def __init__(self,wsize,threshold, functor, funcmin=0.0, funcmax=1.0, integration = IntegrationType.MEAN):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._wsize = wsize
|
|
self._threshold = float(threshold)
|
|
self._functor = functor
|
|
self._funcmin = float(funcmin)
|
|
self._funcmax = float(funcmax)
|
|
self._integration = integration
|
|
|
|
def getName(self):
|
|
return "pyDensityFunctorUP1D"
|
|
|
|
def __call__(self, inter):
|
|
func = DensityF1D(self._wsize, self._integration)
|
|
res = self._functor(inter)
|
|
k = (res-self._funcmin)/(self._funcmax-self._funcmin)
|
|
if(func(inter) < self._threshold*k):
|
|
return 1
|
|
return 0
|
|
|
|
class pyZSmallerUP1D(UnaryPredicate1D):
|
|
def __init__(self,z, integration=IntegrationType.MEAN):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._z = z
|
|
self._integration = integration
|
|
def getName(self):
|
|
return "pyZSmallerUP1D"
|
|
|
|
def __call__(self, inter):
|
|
func = GetProjectedZF1D(self._integration)
|
|
if(func(inter) < self._z):
|
|
return 1
|
|
return 0
|
|
|
|
class pyIsOccludedByUP1D(UnaryPredicate1D):
|
|
def __init__(self,id):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._id = id
|
|
def getName(self):
|
|
return "pyIsOccludedByUP1D"
|
|
def __call__(self, inter):
|
|
func = GetShapeF1D()
|
|
shapes = func(inter)
|
|
for s in shapes:
|
|
if(s.getId() == self._id):
|
|
return 0
|
|
it = inter.verticesBegin()
|
|
itlast = inter.verticesEnd()
|
|
itlast.decrement()
|
|
v = it.getObject()
|
|
vlast = itlast.getObject()
|
|
tvertex = v.viewvertex()
|
|
if type(tvertex) is TVertex:
|
|
print("TVertex: [ ", tvertex.getId().getFirst(), ",", tvertex.getId().getSecond()," ]")
|
|
eit = tvertex.edgesBegin()
|
|
while(eit.isEnd() == 0):
|
|
ve, incoming = eit.getObject()
|
|
if(ve.getId() == self._id):
|
|
return 1
|
|
print("-------", ve.getId().getFirst(), "-", ve.getId().getSecond())
|
|
eit.increment()
|
|
tvertex = vlast.viewvertex()
|
|
if type(tvertex) is TVertex:
|
|
print("TVertex: [ ", tvertex.getId().getFirst(), ",", tvertex.getId().getSecond()," ]")
|
|
eit = tvertex.edgesBegin()
|
|
while(eit.isEnd() == 0):
|
|
ve, incoming = eit.getObject()
|
|
if(ve.getId() == self._id):
|
|
return 1
|
|
print("-------", ve.getId().getFirst(), "-", ve.getId().getSecond())
|
|
eit.increment()
|
|
return 0
|
|
|
|
class pyIsInOccludersListUP1D(UnaryPredicate1D):
|
|
def __init__(self,id):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._id = id
|
|
def getName(self):
|
|
return "pyIsInOccludersListUP1D"
|
|
def __call__(self, inter):
|
|
func = GetOccludersF1D()
|
|
occluders = func(inter)
|
|
for a in occluders:
|
|
if(a.getId() == self._id):
|
|
return 1
|
|
return 0
|
|
|
|
class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
|
|
def __init__(self):
|
|
UnaryPredicate1D.__init__(self)
|
|
self.__func1 = GetOccludersF1D()
|
|
self.__func2 = GetShapeF1D()
|
|
def getName(self):
|
|
return "pyIsOccludedByItselfUP1D"
|
|
def __call__(self, inter):
|
|
lst1 = self.__func1(inter)
|
|
lst2 = self.__func2(inter)
|
|
for vs1 in lst1:
|
|
for vs2 in lst2:
|
|
if vs1.getId() == vs2.getId():
|
|
return 1
|
|
return 0
|
|
|
|
class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
|
|
def __init__(self, idlist):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._idlist = idlist
|
|
self.__func1 = GetOccludersF1D()
|
|
def getName(self):
|
|
return "pyIsOccludedByIdListUP1D"
|
|
def __call__(self, inter):
|
|
lst1 = self.__func1(inter)
|
|
for vs1 in lst1:
|
|
for id in self._idlist:
|
|
if vs1.getId() == id:
|
|
return 1
|
|
return 0
|
|
|
|
class pyShapeIdListUP1D(UnaryPredicate1D):
|
|
def __init__(self,idlist):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._idlist = idlist
|
|
self._funcs = []
|
|
for id in idlist :
|
|
self._funcs.append(ShapeUP1D(id.getFirst(), id.getSecond()))
|
|
|
|
def getName(self):
|
|
return "pyShapeIdUP1D"
|
|
def __call__(self, inter):
|
|
for func in self._funcs :
|
|
if(func(inter) == 1) :
|
|
return 1
|
|
return 0
|
|
|
|
## deprecated
|
|
class pyShapeIdUP1D(UnaryPredicate1D):
|
|
def __init__(self,id):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._id = id
|
|
def getName(self):
|
|
return "pyShapeIdUP1D"
|
|
def __call__(self, inter):
|
|
func = GetShapeF1D()
|
|
shapes = func(inter)
|
|
for a in shapes:
|
|
if(a.getId() == self._id):
|
|
return 1
|
|
return 0
|
|
|
|
class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):
|
|
def __init__(self,threshold, level, sampling=2.0):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._l = threshold
|
|
self.func = pyDensityAnisotropyF1D(level, IntegrationType.MEAN, sampling)
|
|
def getName(self):
|
|
return "pyHighDensityAnisotropyUP1D"
|
|
def __call__(self, inter):
|
|
return (self.func(inter) > self._l)
|
|
|
|
class pyHighViewMapGradientNormUP1D(UnaryPredicate1D):
|
|
def __init__(self,threshold, l, sampling=2.0):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._threshold = threshold
|
|
self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
|
|
def getName(self):
|
|
return "pyHighViewMapGradientNormUP1D"
|
|
def __call__(self, inter):
|
|
gn = self._GetGradient(inter)
|
|
#print(gn)
|
|
return (gn > self._threshold)
|
|
|
|
class pyDensityVariableSigmaUP1D(UnaryPredicate1D):
|
|
def __init__(self,functor, sigmaMin,sigmaMax, lmin, lmax, tmin, tmax, integration = IntegrationType.MEAN, sampling=2.0):
|
|
UnaryPredicate1D.__init__(self)
|
|
self._functor = functor
|
|
self._sigmaMin = float(sigmaMin)
|
|
self._sigmaMax = float(sigmaMax)
|
|
self._lmin = float(lmin)
|
|
self._lmax = float(lmax)
|
|
self._tmin = tmin
|
|
self._tmax = tmax
|
|
self._integration = integration
|
|
self._sampling = sampling
|
|
|
|
def getName(self):
|
|
return "pyDensityUP1D"
|
|
|
|
def __call__(self, inter):
|
|
sigma = (self._sigmaMax-self._sigmaMin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._sigmaMin
|
|
t = (self._tmax-self._tmin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._tmin
|
|
if(sigma<self._sigmaMin):
|
|
sigma = self._sigmaMin
|
|
self._func = DensityF1D(sigma, self._integration, self._sampling)
|
|
d = self._func(inter)
|
|
if(d<t):
|
|
return 1
|
|
return 0
|
|
|
|
class pyClosedCurveUP1D(UnaryPredicate1D):
|
|
def __call__(self, inter):
|
|
it = inter.verticesBegin()
|
|
itlast = inter.verticesEnd()
|
|
itlast.decrement()
|
|
vlast = itlast.getObject()
|
|
v = it.getObject()
|
|
print(v.getId().getFirst(), v.getId().getSecond())
|
|
print(vlast.getId().getFirst(), vlast.getId().getSecond())
|
|
if(v.getId() == vlast.getId()):
|
|
return 1
|
|
return 0
|