dsift.h

Go to the documentation of this file.

/*
Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
All rights reserved.

This file is part of the VLFeat library and is made available under
the terms of the BSD license (see the COPYING file).
*/

#ifndef VL_DSIFT_H
#define VL_DSIFT_H

//#include "generic.h"
#include <emmintrin.h>
#include <assert.h>

// various defines
#define VL_INLINE static __inline__
#define VL_EXPORT extern "C"
#define VL_EPSILON_F 1.19209290E-07F

typedef int vl_bool ;    
#define VL_TRUE 1   
#define VL_FALSE 0  
#define VL_TRANSPOSE         (0x1 << 2) 
#define VL_PAD_BY_CONTINUITY (0x1 << 0) 
#define VL_PAD_BY_ZERO       (0x0 << 0) 
#define VL_PAD_MASK          (0x3)      
#define VSIZE  4
#define VSFX   s
#define VTYPE  __m128
#define VALIGNED(x) (! (((vl_uintptr)(x)) & 0xF))

#define VL_PI 3.141592653589793
#define VL_MAX(x,y) (((x)>(y))?(x):(y))
#define VL_MIN(x,y) (((x)<(y))?(x):(y))

#define VSTZ  _mm_setzero_ps
#define VADD  _mm_add_ps
#define VLD1 _mm_load1_ps
#define VMUL  _mm_mul_ps

// jic
/* #define VMAX  VL_XCAT(_mm_max_p,     VSFX) */
/* #define VDIV  VL_XCAT(_mm_div_p,     VSFX) */
/* #define VSUB  VL_XCAT(_mm_sub_p,     VSFX) */
/* #define VLDU  VL_XCAT(_mm_loadu_p,   VSFX) */
/* #define VST1  VL_XCAT(_mm_store_s,   VSFX) */
/* #define VSET1 VL_XCAT(_mm_set_s,     VSFX) */
/* #define VSHU  VL_XCAT(_mm_shuffle_p, VSFX) */
/* #define VNEQ  VL_XCAT(_mm_cmpneq_p,  VSFX) */
/* #define VAND  VL_XCAT(_mm_and_p,     VSFX) */
/* #define VANDN VL_XCAT(_mm_andnot_p,  VSFX) */

typedef long long           vl_int64 ;   
typedef long long unsigned  vl_uint64 ;  
typedef vl_uint64           vl_uintptr ; 
typedef vl_uint64           vl_size ;    
typedef int                 vl_int32 ;   
typedef vl_int64            vl_index ;   
// Imported functions from other modules
void vl_imconvcol_vf (float* dst, int dst_stride,
                      float const* src,
                      int src_width, int src_height, int src_stride,
                      float const* filt, int filt_begin, int filt_end,
                      int step, unsigned int flags) ;

void vl_imconvcoltri_f(float * dest, vl_size destStride,
                       float const * image,
                       vl_size imageWidth, vl_size imageHeight, vl_size imageStride,
                       vl_size filterSize,
                       vl_size step, unsigned int flags) ;


VL_INLINE float
vl_abs_f (float x)
{
// deactivated for precaution...
//#ifdef VL_COMPILER_GNUC
  return __builtin_fabsf (x) ;
//#else
//  return fabsf(x) ;
//#endif
}

VL_INLINE float
vl_mod_2pi_f (float x)
{
  while (x > (float)(2 * VL_PI)) x -= (float) (2 * VL_PI) ;
  while (x < 0.0F) x += (float) (2 * VL_PI);
  return x ;
}

VL_INLINE long int
vl_floor_f (float x)
{
  long int xi = (long int) x ;
  if (x >= 0 || (float) xi == x) return xi ;
  else return xi - 1 ;
}

VL_INLINE float
vl_fast_resqrt_f (float x)
{
  /* 32-bit version */
  union {
    float x ;
    vl_int32  i ;
  } u ;

  float xhalf = (float) 0.5 * x ;

  /* convert floating point value in RAW integer */
  u.x = x ;

  /* gives initial guess y0 */
  u.i = 0x5f3759df - (u.i >> 1);
  /*u.i = 0xdf59375f - (u.i>>1);*/

  /* two Newton steps */
  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
  return u.x ;
}

VL_INLINE float
vl_fast_sqrt_f (float x)
{
  return (x < 1e-8) ? 0 : x * vl_fast_resqrt_f (x) ;
}

VL_INLINE float
vl_fast_atan2_f (float y, float x)
{
  float angle, r ;
  float const c3 = 0.1821F ;
  float const c1 = 0.9675F ;
  float abs_y    = vl_abs_f (y) + VL_EPSILON_F ;

  if (x >= 0) {
    r = (x - abs_y) / (x + abs_y) ;
    angle = (float) (VL_PI / 4) ;
  } else {
    r = (x + abs_y) / (abs_y - x) ;
    angle = (float) (3 * VL_PI / 4) ;
  }
  angle += (c3*r*r - c1) * r ;
  return (y < 0) ? - angle : angle ;
}







typedef struct VlDsiftKeypoint_
{
  double x ; 
  double y ; 
  double s ; 
  double norm ; 
} VlDsiftKeypoint ;

typedef struct VlDsiftDescriptorGeometry_
{
  int numBinT ;  
  int numBinX ;  
  int numBinY ;  
  int binSizeX ; 
  int binSizeY ; 
} VlDsiftDescriptorGeometry ;

typedef struct VlDsiftFilter_
{
  int imWidth ;            
  int imHeight ;           
  int stepX ;              
  int stepY ;              
  int boundMinX ;          
  int boundMinY ;          
  int boundMaxX ;          
  int boundMaxY ;          
  VlDsiftDescriptorGeometry geom ;

  int useFlatWindow ;      
  double windowSize ;      
  int numFrames ;          
  int descrSize ;          
  VlDsiftKeypoint *frames ; 
  float *descrs ;          
  int numBinAlloc ;        
  int numFrameAlloc ;      
  int numGradAlloc ;       
  float **grads ;          
  float *convTmp1 ;        
  float *convTmp2 ;        
}  VlDsiftFilter ;

VlDsiftFilter *vl_dsift_new (int width, int height) ;
VlDsiftFilter *vl_dsift_new_basic (int width, int height, int step, int binSize) ;
void vl_dsift_delete (VlDsiftFilter *self) ;
void vl_dsift_process (VlDsiftFilter *self, float const* im) ;
VL_INLINE void vl_dsift_transpose_descriptor (float* dst,
                                             float const* src,
                                             int numBinT,
                                             int numBinX,
                                             int numBinY) ;

VL_INLINE void vl_dsift_set_steps (VlDsiftFilter *self,
                                  int stepX,
                                  int stepY) ;
VL_INLINE void vl_dsift_set_bounds (VlDsiftFilter *self,
                                   int minX,
                                   int minY,
                                   int maxX,
                                   int maxY) ;
VL_INLINE void vl_dsift_set_geometry (VlDsiftFilter *self,
                                      VlDsiftDescriptorGeometry const* geom) ;
VL_INLINE void vl_dsift_set_flat_window (VlDsiftFilter *self, vl_bool useFlatWindow) ;
VL_INLINE void vl_dsift_set_window_size (VlDsiftFilter *self, double windowSize) ;
VL_INLINE float const    *vl_dsift_get_descriptors     (VlDsiftFilter const *self) ;
VL_INLINE int             vl_dsift_get_descriptor_size (VlDsiftFilter const *self) ;
VL_INLINE int             vl_dsift_get_keypoint_num    (VlDsiftFilter const *self) ;
VL_INLINE VlDsiftKeypoint const *vl_dsift_get_keypoints (VlDsiftFilter const *self) ;
VL_INLINE void            vl_dsift_get_bounds          (VlDsiftFilter const *self,
                                                       int* minX,
                                                       int* minY,
                                                       int* maxX,
                                                       int* maxY) ;
VL_INLINE void            vl_dsift_get_steps           (VlDsiftFilter const* self,
                                                       int* stepX,
                                                       int* stepY) ;
VL_INLINE VlDsiftDescriptorGeometry const* vl_dsift_get_geometry (VlDsiftFilter const *self) ;
VL_INLINE vl_bool         vl_dsift_get_flat_window     (VlDsiftFilter const *self) ;
VL_INLINE double          vl_dsift_get_window_size     (VlDsiftFilter const *self) ;
void _vl_dsift_update_buffers (VlDsiftFilter *self) ;

int
vl_dsift_get_descriptor_size (VlDsiftFilter const *self)
{
  return self->descrSize ;
}

float const *
vl_dsift_get_descriptors (VlDsiftFilter const *self)
{
  return self->descrs ;
}

VlDsiftKeypoint const *
vl_dsift_get_keypoints (VlDsiftFilter const *self)
{
  return self->frames ;
}

int
vl_dsift_get_keypoint_num (VlDsiftFilter const *self)
{
  return self->numFrames ;
}

VlDsiftDescriptorGeometry const* vl_dsift_get_geometry (VlDsiftFilter const *self)
{
  return &self->geom ;
}

void
vl_dsift_get_bounds (VlDsiftFilter const* self,
                    int *minX, int *minY, int *maxX, int *maxY)
{
  *minX = self->boundMinX ;
  *minY = self->boundMinY ;
  *maxX = self->boundMaxX ;
  *maxY = self->boundMaxY ;
}

int
vl_dsift_get_flat_window (VlDsiftFilter const* self)
{
  return self->useFlatWindow ;
}

void
vl_dsift_get_steps (VlDsiftFilter const* self,
                   int* stepX,
                   int* stepY)
{
  *stepX = self->stepX ;
  *stepY = self->stepY ;
}

void
vl_dsift_set_steps (VlDsiftFilter* self,
                   int stepX,
                   int stepY)
{
  self->stepX = stepX ;
  self->stepY = stepY ;
  _vl_dsift_update_buffers(self) ;
}

void
vl_dsift_set_bounds (VlDsiftFilter* self,
                    int minX, int minY, int maxX, int maxY)
{
  self->boundMinX = minX ;
  self->boundMinY = minY ;
  self->boundMaxX = maxX ;
  self->boundMaxY = maxY ;
  _vl_dsift_update_buffers(self) ;
}

void
vl_dsift_set_geometry (VlDsiftFilter *self,
                       VlDsiftDescriptorGeometry const *geom)
{
  self->geom = *geom ;
  _vl_dsift_update_buffers(self) ;
}

void
vl_dsift_set_flat_window (VlDsiftFilter* self,
                         vl_bool useFlatWindow)
{
  self->useFlatWindow = useFlatWindow ;
}

VL_INLINE void
vl_dsift_transpose_descriptor (float* dst,
                              float const* src,
                              int numBinT,
                              int numBinX,
                              int numBinY)
{
  int t, x, y ;

  for (y = 0 ; y < numBinY ; ++y) {
    for (x = 0 ; x < numBinX ; ++x) {
      int offset  = numBinT * (x + y * numBinX) ;
      int offsetT = numBinT * (y + x * numBinY) ;

      for (t = 0 ; t < numBinT ; ++t) {
        int tT = numBinT / 4 - t ;
        dst [offsetT + (tT + numBinT) % numBinT] = src [offset + t] ;
      }
    }
  }
}

void
vl_dsift_set_window_size(VlDsiftFilter * self, double windowSize)
{
  assert(windowSize >= 0.0) ;
  self->windowSize = windowSize ;
}

VL_INLINE double
vl_dsift_get_window_size(VlDsiftFilter const * self)
{
  return self->windowSize ;
}

/*  VL_DSIFT_H */
#endif