~bertrand-nouvel/pycvf-keypoints/trunk

# -*- coding: utf-8 -*-

 

import numpy, scipy

from pycvf.core import genericnode

 

def getpatch(I,x):

  L=16

  r=I[max(int(x[1]-L),0):int(x[1]+L),

      max(int(x[0]-L),0):int(x[0]+L),:]

  #print r.shape,x

  return r

 

class SpecificKeypoint(object):

  """

   This class allows you to combine a keypoint extractor 

   with a keypoint descriptor.

 

   Of course exploded may have been used that for, but sometimes things need to be made easier and simpler

   

   Two modes are supported : 

     The mode "c" will pass a couple made out of the image and of the coordinates of the keypoints.

     The mode "b" where a block will be cropped at the keypoint position and this block will be passed to the model

       in mode"b" the half-size of the block is defined by keypointhalfsize

       

   

   

   TODO : this maybe improved so that the element of the dataflow actually enters the dataflow

  """

  def __init__(self,keypointmodel, descriptormodel,mode="c",as_couple=True,keypointhalfsize=(10,10)):

     self.keypointmodel=keypointmodel

     self.descriptormodel=descriptormodel

     self.mode=mode

     self.as_couple=True

     self.keypointhalfsize=keypointhalfsize

  def set_model_node(self,model):

     self.model_node=model

     self.db=self.model_node.get_curdb()

     

     self.keypointmodel=(pycvf_builder(self.keypointmodel) if type(self.keypointmodel) in [str,unicode] else self.keypointmodel)

     self.keypointmodel.init("/",self.db,self)

     keypointmodelpath=self.keypointmodel.resolve_modelpath(0)

     metak= self.keypointmodel.get_features_meta().keys()

     self.keypointmodel.metainfo_curdb=self.db

     self.keypointmodelpathno=metak.index(keypointmodelpath)

     

     self.descriptormodel=(pycvf_builder(self.descriptormodel) if type(self.descriptormodel) in [str,unicode] else self.descriptormodel)

     self.descriptormodel.init("/",self.db,self)

     descriptormodelpath=self.descriptormodel.resolve_modelpath(0)

     metak= self.descriptormodel.get_features_meta().keys()

     self.descriptormodel.metainfo_curdb=self.db

     self.descriptormodelpathno=metak.index(descriptormodelpath)

 

  def on_model_destroy(self,model):

     self.model_node=None        

  def process(self,x):

     kp=self.keypointmodel.process(x,addr=self.model_node.get_curaddr())[self.keypointmodelpathno]

     #print kp

     if self.mode=='b':

       kp=filter(lambda k:(k[0]>=self.keypointhalfsize[0]) and (k[0]<(x.shape[1]-self.keypointhalfsize[0])) and (k[1]>self.keypointhalfsize[1]) and (k[1]<(x.shape[0]-self.keypointhalfsize[1])),kp)

       desc=[self.descriptormodel.process(getpatch(x,p))[self.descriptormodelpathno] for p in kp]

     elif self.mode=='c':

       desc=self.descriptormodel.process((x,kp))[self.descriptormodelpathno]   

     else:

       raise ValueError, "Invalid Mode"

     if (self.as_couple):

       return kp,desc

     else:

       return numpy.hstack([kp,desc])

 

Node=genericnode.pycvf_node_class(None,None)(SpecificKeypoint)

__call__=Node