~bertrand-nouvel/pycvf-keypoints/trunk

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

 

from compute_channels_oe_nms import compute_channels_oe_nms

from get_descriptors import get_descriptors

import numpy

 

class GeometricBlurComputer:

   def __init__(self, usePBEdges=False,  

                      numFeats=300,

                      repulsionRadius=5,

                      blurRate=0.5,

                      blurBase=1,

                      sampleRadii=[0, 4, 8, 16, 32, 50],

                      numSamplePerRadius= [1, 8, 8, 10, 12, 12]):

        self.usePBEdges=usePBEdges

        self.numFeats=numFeats

        self.repulsionRadius=repulsionRadius

        self.blurRate=blurRate

        self.blurBase=blurBase

        self.sampleRadii=sampleRadii

        self.numSamplePerRadius=numSamplePerRadius

   def process(self,I):

     if I.ndim==3:

       if (I.shape[2]>1):

         I = I.mean(axis=2)

       else:

         I=I.reshape(I.shape[:2])

    

     if not self.usePBEdges:

       fbr = compute_channels_oe_nms(I)

     else:

       assert False,"Not yet implemented"

       #feat = pbEdges(conf, I) 

       #th  = 4 * mod(feat.theta, numpy.pi) / numpy.pi

       #i = floor(th)

       #wi = 1 - (th - i) 

       #j = i + 1 

       #wj = 1 - wi 

       #i = mod(i,4) + 1 

       #j = mod(j,4) + 1 

 

       #fbr = numpy.zeros(I.shape[0],I.shape[1],4) 

 

       #fbr=vl_binsum(fbr,wi * feat.pb,i,3) 

       #fbr=vl_binsum(fbr,wj * feat.pb,j,3)

 

 

     #print len(fbr)

     descrs, frames=get_descriptors(numpy.dstack(fbr), self.numFeats, self.repulsionRadius, self.blurRate, self.blurBase, numpy.array(self.sampleRadii), numpy.array(self.numSamplePerRadius))

 

     frames = numpy.flipud(frames.T) 

     descrs = numpy.dstack(descrs).swapaxes(1,2)

     #descrs = numpy.array([ descrs[:,:,0],descrs[:,:,1],descrs[:,:,2],descrs[:,:,4]]).T 

     #print descrs.shape

 

     #feat.frames = frames ; 

     #feat.descrs = descrs ;

     return frames, descrs

 

from pycvf.core import genericnode

from pycvfext.image.datatypes import image

from pycvf.datatypes import numericvectors

from pycvf.datatypes import list as ldt

 

   

Node=genericnode.pycvf_node_class(image.Datatype(),ldt.Datatype(numericvectors.Datatype))(GeometricBlurComputer)

__call__=Node

 

 

def gb_distance(desc1,desc2):

  return  numpy.dot(desc1.ravel(),desc2.ravel())

 

 

if __name__=="__main__":

  import scipy

  I=scipy.lena()[::2,::2]

  r=GeometricBlurComputer().process(I)

  print r[1].shape

 

  #for i in range(len(r)):

    #scipy.misc.pilutil.imshow(r[i]/r[i].max()*255)

    #print len(r),r[i].mean()