self.with_label="default"
if (self.negative_data):
neg,negaddr=self.negative_data.next()
nld=eval("self.negative_data.labeling_"+self.with_label)()
ld=eval("self.model_node.get_curdb().labeling_"+self.with_label)()
#print ld
#print self.model_node
#print self.model_node.get_curaddr
#print self.model_node.get_curaddr()
#print ld[self.model_node.get_curaddr()]
label=self.label_op(
ld[self.model_node.get_curaddr()]
)
if (x.ndim==1):
pycvf_warning("Your data is one dimensional only\n")
pycvf_warning("Learning gonna be slow !\n")
x=x.reshape(-1,1)
label=[label]
elif (x.ndim>2):
pycvf_error("Your data is too high dimensional for learning\n")
self.statmodel.train(x,
label ,
online=True,
*self.args,
**self.kwargs
)
Model=pycvf_model_class(None,None)(ModelTrainer)
__call__=Model
# -*- coding: utf-8 -*- ######################################################################################################################################### # # MyModel By Bertrand NOUVEL # 2009 CNRS Postdoctorate JFLI # # (c) All rights reserved # ############################################### # ################################################################################################################################################################################ # Includes ################################################################################################################################################################################ import numpy from pycvf.core import genericmodel from pycvf.datatypes import image from pycvf.lib.graphics import rescale Model=genericmodel.pycvf_model_class(image.Datatype,image.Datatype)(rescale.Rescaler2d) __call__=Model
self.negative_data=negative_data
if (self.negative_data!=None):
self.negative_data=iter(self.negative_data)
def set_model_node(self,model):
self.model_node=model
def on_model_destroy(self,model):
self.model_node=None
def process(self,x):
#neg=numpy.array(map(lambda x:x[0],self.negative_data.next()))
neg=self.negative_data.next()[0]
if (x.ndim==1):
pycvf_warning("Your data is one dimensional only\n")
pycvf_warning("Learning gonna be slow !\n")
x=x.reshape(-1,1)
elif (x.ndim>2):
pycvf_error("Your data is too high dimensional for learning\n")
if (neg.ndim==1):
pycvf_warning("Your data is one dimensional only\n")
pycvf_warning("Learning gonna be slow !\n")
neg=neg.reshape(-1,1)
elif (neg.ndim>2):
pycvf_error("Your data is too high dimensional for learning\n")
self.statmodel.train(x,neg,online=False,*self.args,**self.kwargs)
adata=numpy.vstack([x,neg])
aclass=self.statmodel.test(adata)
rclass=[0]*x.shape[0]+[1]*neg.shape[0]
return multiplicity(zip(numpy.sign(aclass),rclass))
Model=pycvf_model_class(basics.NumericArray.Datatype,basics.Label.Datatype)(ModelTrainer)
__call__=Model
from pycvf.datatypes import basics
class ModelIdxQuery(object):
"""
This model does query for nearest neighbors in an already build databases for queries
The input is a set of query vectors / query elements and the output are there nearest neighbors
in our database.
"""
def __init__(self,idxclass,k=10,*args, **kwargs):
self.idx=(pycvf_builder(idxclass) if type(idxclass) in [str, unicode] else idxclass)
self.args=args
self.kwargs=kwargs
self.k=k
self.model_node=None
def set_model_node(self,model):
self.model_node=model
def on_model_destroy(self,model):
self.model_node=None
def process(self,x):
if (x.ndim==1):
x=x.reshape(-1,1)
label=[label]
elif (x.ndim>2):
pycvf_error("Your data is too high dimensional for querying\n")
return self.idx.getitem(x,self.k)
Model=pycvf_model_class(basics.NumericArray.Datatype,basics.NumericArray.Datatype)(ModelIdxQuery)
__call__=Model
#########################################################################################################################################
#
# MyModel By Bertrand NOUVEL
# 2009 CNRS Postdoctorate JFLI
#
# (c) All rights reserved
# ###############################################
#
################################################################################################################################################################################
# Includes
################################################################################################################################################################################
###
###
import sys
from pycvf.core import genericmodel
from pycvf.core.errors import *
class Writer:
def __init__(self,stream=sys.stderr,sep="\n"):
self.stream=stream
self.sep=sep
def process(self,x):
self.stream.write(repr(x)+self.sep)
return x
Model=genericmodel.pycvf_model_class(None,None)(Writer)
__call__=Model
class ImageSaver(object):
def __init__(self, filename="img-$n.png", label_op=None, *args, **kwargs):
self.c = 0
self.filename = filename
self.args = args
self.kwargs = kwargs
self.mdl = None
if label_op == None:
label_op = lambda x: x
self.label_op = label_op
self.model_node = None
def set_model_node(self, model):
self.model_node = model
def on_model_destroy(self, model):
self.model_node = None
def process(self, x):
filename = self.filename.replace("$n", "%08d" % (self.c,))
filename = filename.replace("$address", "%r" % (self.label_op(self.model_node.get_curaddr()),))
NumPy2PIL(x).save(filename, *self.args, **self.kwargs)
self.c += 1
return x
Model = pycvf_model_class(image.Datatype, image.Datatype)(ImageSaver)
__call__ = Model
from pycvf.datatypes import basics
from pycvf.datatypes import image
import zopencv
class Contour:
def __init__(self, *args, **kwargs):
self.model_node = None
def set_model_node(self, model):
self.model_node = model
while self.model_node.parent != None:
self.model_node = self.model_node.parent
def on_model_destroy(self, model):
self.model_node = None
def process(self, points):
srcb = self.model_node.context["thesrc"]["src"].copy("C")
length = len(points)
for x in range(length - 1):
src_point = zopencv.cvPoint(points[x, 0], points[x, 1])
dst_point = zopencv.cvPoint(points[x + 1, 0], points[x + 1, 1])
color = zopencv.cvScalar(255, 0, 0, 0)
zopencv.cvLine(srcb, src_point, dst_point, color, 1, 8, 0)
return srcb
Model = genericmodel.pycvf_model_class(basics.Label.Datatype, image.Datatype)(Contour)
__call__ = Model
def init(self):
self.filename=self.directory+"/randomprojection.npy"
try:
if (self.reset):
raise Exception
self.rpmat=numpy.load(self.filename)
if (self.rpmat==None):
raise Exception
self.model_node.status=genericmodel.STATUS_READY
pycvf_debug(10, "loaded"+ self.filename+"...")
except:
self.rpmat=None
def set_model_node(self,model):
self.model_node=model
self.directory=model.get_directory()
self.init()
def on_model_destroy(self,model):
self.model_node=None
def process(self,v):
if (self.rpmat==None):
self.rpmat=(numpy.random.random((self.odim,(v.shape[1] if v.ndim==2 else v.shape[0])))-.5)*2
numpy.save(self.filename,self.rpmat)
self.model_node.status=genericmodel.STATUS_READY
x=numpy.dot(self.rpmat,numpy.asmatrix(v).T).T
#print x.shape
return x
Model=genericmodel.pycvf_model_class(None,basics.NumericVector.Datatype)(RandomProjection)
__call__=Model
#########################################################################################################################################
#
# MyModel By Bertrand NOUVEL
# 2009 CNRS Postdoctorate JFLI
#
# (c) All rights reserved
# ###############################################
import numpy, sys
from pycvf.core import genericmodel
from pycvf.datatypes import basics
class Reference:
""" This is use to make reference to other elements in the pipeline"""
def __init__(self,node='src'):
self.node=node
self.model_node=None
def set_model_node(self,model):
self.model_node=model
while (self.model_node.parent!=None):
self.model_node=self.model_node.parent
def on_model_destroy(self,model):
self.model_node=None
def process(self,points):
return self.model_node.context['thesrc'][self.node]
Model=genericmodel.pycvf_model_class(None,None)(Reference)
__call__=Model
def is_prefix(a,b):
return (b[:len(a)]==a)
class Summarizer:
""" This agglomerates all the outputs of a node"""
def __init__(self):
self.model_node=None
self.model_node_info=None
def set_model_node(self,model):
self.model_node=model
self.model_root_node=model
while self.model_root_node.parent!=None:
self.model_root_node=self.model_root_node.parent
def on_model_destroy(self,model):
self.model_node=None
self.model_root_node=None
def process(self,points):
if self.model_node_info==None:
self.metas=self.model_node.parent.get_features_meta()
d=[ [mm[0]] for mm in self.metas.items() ]
names=reduce(lambda b,n:b+[n[0]],d,[])
nd=filter(lambda x: (("/"+self.model_node.name+"/") not in x[0][0]) and (len(filter(lambda t:is_prefix(x[0][0], t),names ))==1) ,zip(d,range(len(d))))
self.model_node_info=nd
print nd
return map( lambda x: self.model_root_node.context['thesrc'][self.metas[x[0][0]]['processline']],self.model_node_info )
Model=genericmodel.pycvf_model_class(None,None)(Summarizer)
__call__=Model
#return x
#def init_model(self,mdl,id="",*args,**kwargs):
#mdl.init('/',self.datatype_in)
#def xmap(l):
#return map(lambda e:emdl.process(e),l)
#self.processline='src|map'+id
#self.context['map'+id]=xmap
class ModelMap:
def __init__(self,mdl,modelelementpath=-1,*args, **kwargs):
self.mdl=mdl
self.modelelementpath=modelelementpath
self.modelelementpathno=0
def set_model_node(self,model):
self.model_node=model
self.mdl.init('/',self.model_node.datatype_in, self.model_node)
#self.model.metainf_curdb=None
def on_model_destroy(self,model):
self.mdl=None
self.model_node=None
metak= self.mdl.get_features_meta().keys()
try:
self.modelelementpathno=metak.index(modelelementpath)
except:
self.modelelementpathno=modelelementpath
def process(self,l):
return map(lambda e:self.mdl.process(e)[self.modelelementpathno],l)
Model=genericmodel.pycvf_model_class(None,None)(ModelMap)
__call__=Model
# (c) All rights reserved
# ###############################################
#
################################################################################################################################################################################
# Includes
################################################################################################################################################################################
import numpy, sys
import pywt
from pycvf.core import genericmodel
from pycvf.datatypes import image
from pycvf.datatypes import list as ldt
def idwt_one_layer(x,wav):
return pywt.idwt2(x,wav)
class Imgidwt:
def __init__(self,wavelet='db5'):
if (not wavelet in pywt.wavelist()):
print pywt.wavelist()
self.wavelet=wavelet
def process(self,x):
r=map(lambda y:idwt_one_layer(y,self.wavelet),x)
return numpy.dstack(r)
Model=genericmodel.pycvf_model_class( ldt.Datatype(ldt.Datatype(image.Datatype)),image.Datatype)(Imgidwt)
__call__=Model
class Ngrams:
def __init__(self,size=2):
self.size=size
self.lst=[]
def process(self,origiter):
class XIter:
def __init__(silf):
pass
def __iter__(silf):
if (not hasattr(origiter,"next")) and (hasattr(origiter,"__iter__")):
it=iter(origiter)
else:
it=origiter
cont=True
try:
r=[]
for x in range(self.size) :
r.append( it.next())
yield r
while True:
r.pop(0)
r.append( it.next())
yield r
except StopIteration:
pass
return iter(XIter())
Model=pycvf_model_class(None,lambda x:generated.Datatype(x) )(Ngrams)
__call__=Model
self.lm=None
self.expr=expr
self.centralized=centralized
def process(self,x):
if ((self.lm==None) or (self.lm.shape[0])!=x.shape[0]*x.shape[1]):
if (not self.centralized):
lm=numpy.mgrid[0:1:(1./x.shape[0]),0:1:(1./x.shape[1])]
else:
lm=numpy.mgrid[-.5:.5:(1./x.shape[0]),-.5:.5:(1./x.shape[1])]
cmap=eval(self.expr,{'x':(lm[0]*1J+lm[1]),'numpy':numpy,'scipy':scipy})
if (not self.centralized):
re=numpy.real(cmap)%1
im=numpy.imag(cmap)%1
else:
re=(numpy.real(cmap)+.5)%1
im=(numpy.imag(cmap)+.5)%1
re*=x.shape[1]
im*=x.shape[0]
self.lm=numpy.dstack([im, re]).swapaxes(0,2).swapaxes(1,2)
if (x.ndim==3):
r=all_layer(lambda y :scipy.ndimage.map_coordinates(y,self.lm) ,x)
else:
r=scipy.ndimage.map_coordinates(x,self.lm)
return r
Model=genericmodel.pycvf_model_class(image.Datatype,image.Datatype)(map_coordinates)
__call__=Model
import numpy, sys
from pycvf.core import genericmodel
from pycvf.datatypes import image
from pycvf.datatypes import list as ldt
from pycvf.nodes.image.pyramidalize import pyramidalize
def focus_part(x,focuspoint=(0.5,0.5),szpart=(32,32)):
h,w=x.shape[:2]
by=int(h*focuspoint[1])-(szpart[1]//2)
ey=by+szpart[1]
bx=(w*focuspoint[0])-(szpart[0]//2)
ex=bx+szpart[0]
return x[by:ey,bx:ex]
class Foveaizer:
def __init__(self,*args, **kwargs):
self.args=args
self.kwargs=kwargs
self.focus_point=(.5,.5)
def process(self,x):
r=map(lambda xi:focus_part(xi,self.focus_point), pyramidalize(x,*self.args,**self.kwargs))
return r
Model=genericmodel.pycvf_model_class(image.Datatype,ldt.Datatype(image.Datatype))(Foveaizer)
__call__=Model
*self.args,
**self.kwargs
)
my,mx=x.min(axis=0)
MY,MX=x.max(axis=0)
dy=MY-my+eps
dx=MX-mx+eps
mg=numpy.mgrid[:resy,:resx].swapaxes(0,2).swapaxes(0,1)
#print mg
mg=mg.reshape(-1,2)
#print resy,resx
mg*=numpy.array([[dx,dy]])
mg/=numpy.array([[resx,resy]])
mg+=numpy.array([[mx,my]])
testset=mg
res=self.statmodel.test(testset)
if (self.normalizemap):
res-=res.min()
res/=res.max()
res*=255
#print res.shape
res=res.reshape(resy,resx)
res=res.T
res=numpy.flipud(res)
print "RESHAPE=",res.shape,res.dtype
return res
Model=pycvf_model_class(basics.NumericArray.Datatype, image.Datatype)(ModelTrainer)
__call__=Model
from pycvf.datatypes import audio
from pycvf.datatypes import histogram
class Spectromemory():
def __init__(self,blocksize=60):
self.blocksize=blocksize
self.packetlist=[]
def process(self,origiter):
class XIter:
def __init__(silf):
pass
def __iter__(silf):
cont=True
blk=0
try:
r=[]
for x in range(self.blocksize) :
r.append( origiter.next())
yield r
while True:
r.pop(0)
r.append( origiter.next())
yield r
except StopIteration:
pass
return iter(XIter())
Model=pycvf_model_class(None,None)(Spectromemory)
__call__=Model
import scipy
#import hashlib
from pycvf.core.errors import *
from pycvf.core import genericmodel
from pycvf.core import builders
from pycvf.datatypes import basics
from pycvf.lib.info.cacheable import NotReady
#########################################################################################################################################
# Define our model
#########################################################################################################################################
class DEModelProcessor(object):
"""
Here we reduce the dimension of set of points by using a density estimation model
and by returning the parameters of this density estimation model.
"""
def __init__(self, modelmodule="pycvf.stat.DE.pyem_gmm", *args, ** kwargs):
self.model=__import__(modelmodule,fromlist=modelmodule.split(".")[:-1])
self.args=args
self.kwargs=kwargs
self.modelpath=None
def process(self,v):
m=self.model.Model(*self.args, **self.kwargs)
print v.shape
m.train(v)
return m.get_as_vector()
Model=genericmodel.pycvf_model_class(None,basics.NumericVector.Datatype)(DEModelProcessor)
__call__=Model
if (self.totrain):
q=min(v.shape[0],self.totrain)
self.totrain-=q
self.ipca.add_train(v[:q])
if (self.totrain==0):
self.ipca.recompute()
self.save()
if (v.shape[0]==q):
self.model_node.status=genericmodel.STATUS_NOT_READY
raise NotReady
else:
v=v[q:]
try:
assert(v.ndim==2)
r=self.ipca.dimred(v)
except KeyboardInterrupt:
raise
except Exception,e:
print e
self.model_node.status=genericmodel.STATUS_NOT_READY
raise NotReady
self.model_node.status=genericmodel.STATUS_READY
return r
def save(self):
if (self.ipca) and (self.totrain==0):
self.ipca.save(file(self.pcafilename,"w"))
Model=genericmodel.pycvf_model_class(basics.NumericArray.Datatype,basics.NumericArray.Datatype)(IPCAProcessor)
__call__=Model
from pycvf.nodes.image.pyramidalize import pyramidalize
def focus_part_put(img,x,focuspoint=(0.5,0.5),szpart=(32,32)):
h,w=img.shape[:2]
by=max(0,int(h*focuspoint[1])-(szpart[1]//2))
ey=by+min(szpart[1],x.shape[1])
bx=max(0,(w*focuspoint[0])-(szpart[0]//2))
ex=bx+min(szpart[0],x.shape[0])
try:
img[by:ey,bx:ex]=x
except:
pass
return img
def upscale(img):
return img.repeat(2,axis=0).repeat(2,axis=1)
class Unfoveaizer:
def __init__(self,*args, **kwargs):
self.args=args
self.kwargs=kwargs
self.focus_point=(.5,.5)
def process(self,x):
return reduce(lambda b,y:focus_part_put(upscale(b),y), x[1:] , x[0])
Model=genericmodel.pycvf_model_class(ldt.Datatype(image.Datatype),image.Datatype)(Unfoveaizer)
__call__=Model
