Defines | Functions | Variables
sift.c File Reference
#include "sift.h"
#include "imopv.h"
#include "mathop.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
Include dependency graph for vl/sift.c:

Go to the source code of this file.

Defines

#define Aat(i, j)   (A[(i)+(j)*3])
#define at(dx, dy, ds)   (*( pt + (dx)*xo + (dy)*yo + (ds)*so))
#define at(dx, dy)   (*(pt + xo * (dx) + yo * (dy)))
#define atd(dbinx, dbiny, dbint)   *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
#define atd(dbinx, dbiny, dbint)   *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
#define CHECK_NEIGHBORS(CMP, SGN)
#define EXPN_MAX   25.0
#define EXPN_SZ   256
#define log2(x)   (log(x)/VL_LOG_OF_2)
#define NBO   8
#define NBP   4
#define SAVE_BACK
#define VL_SIFT_BILINEAR_ORIENTATIONS   1

Functions

static void _vl_sift_smooth (VlSiftFilt *self, vl_sift_pix *outputImage, vl_sift_pix *tempImage, vl_sift_pix const *inputImage, vl_size width, vl_size height, double sigma)
static void copy_and_downsample (vl_sift_pix *dst, vl_sift_pix const *src, int width, int height, int d)
static void copy_and_upsample_rows (vl_sift_pix *dst, vl_sift_pix const *src, int width, int height)
VL_INLINE double fast_expn (double x)
VL_INLINE void fast_expn_init ()
VL_INLINE vl_sift_pix normalize_histogram (vl_sift_pix *begin, vl_sift_pix *end)
static void update_gradient (VlSiftFilt *f)
VL_EXPORT void vl_sift_calc_keypoint_descriptor (VlSiftFilt *f, vl_sift_pix *descr, VlSiftKeypoint const *k, double angle0)
 Compute the descriptor of a keypoint.
VL_EXPORT int vl_sift_calc_keypoint_orientations (VlSiftFilt *f, double angles[4], VlSiftKeypoint const *k)
 Calculate the keypoint orientation(s)
VL_EXPORT void vl_sift_calc_raw_descriptor (VlSiftFilt const *f, vl_sift_pix const *grad, vl_sift_pix *descr, int width, int height, double x, double y, double sigma, double angle0)
 Run the SIFT descriptor on raw data.
VL_EXPORT void vl_sift_delete (VlSiftFilt *f)
 Delete SIFT filter.
VL_EXPORT void vl_sift_detect (VlSiftFilt *f)
 Detect keypoints.
VL_EXPORT void vl_sift_keypoint_init (VlSiftFilt const *f, VlSiftKeypoint *k, double x, double y, double sigma)
 Initialize a keypoint from its position and scale.
VL_EXPORT VlSiftFilt * vl_sift_new (int width, int height, int noctaves, int nlevels, int o_min)
 Create a new SIFT filter.
VL_EXPORT int vl_sift_process_first_octave (VlSiftFilt *f, vl_sift_pix const *im)
 Start processing a new image.
VL_EXPORT int vl_sift_process_next_octave (VlSiftFilt *f)
 Process next octave.

Variables

double expn_tab [EXPN_SZ+1]

Define Documentation

#define Aat (   i,
  j 
)    (A[(i)+(j)*3])
#define at (   dx,
  dy,
  ds 
)    (*( pt + (dx)*xo + (dy)*yo + (ds)*so))
#define at (   dx,
  dy 
)    (*(pt + xo * (dx) + yo * (dy)))
#define atd (   dbinx,
  dbiny,
  dbint 
)    *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
#define atd (   dbinx,
  dbiny,
  dbint 
)    *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
#define CHECK_NEIGHBORS (   CMP,
  SGN 
)
Value:
( v CMP ## = SGN 0.8 * tp &&                \
          v CMP *(pt + xo) &&                       \
          v CMP *(pt - xo) &&                       \
          v CMP *(pt + so) &&                       \
          v CMP *(pt - so) &&                       \
          v CMP *(pt + yo) &&                       \
          v CMP *(pt - yo) &&                       \
                                                    \
          v CMP *(pt + yo + xo) &&                  \
          v CMP *(pt + yo - xo) &&                  \
          v CMP *(pt - yo + xo) &&                  \
          v CMP *(pt - yo - xo) &&                  \
                                                    \
          v CMP *(pt + xo      + so) &&             \
          v CMP *(pt - xo      + so) &&             \
          v CMP *(pt + yo      + so) &&             \
          v CMP *(pt - yo      + so) &&             \
          v CMP *(pt + yo + xo + so) &&             \
          v CMP *(pt + yo - xo + so) &&             \
          v CMP *(pt - yo + xo + so) &&             \
          v CMP *(pt - yo - xo + so) &&             \
                                                    \
          v CMP *(pt + xo      - so) &&             \
          v CMP *(pt - xo      - so) &&             \
          v CMP *(pt + yo      - so) &&             \
          v CMP *(pt - yo      - so) &&             \
          v CMP *(pt + yo + xo - so) &&             \
          v CMP *(pt + yo - xo - so) &&             \
          v CMP *(pt - yo + xo - so) &&             \
          v CMP *(pt - yo - xo - so) )
#define EXPN_MAX   25.0

fast_expn table max

Definition at line 672 of file vl/sift.c.

#define EXPN_SZ   256

fast_expn table size

Definition at line 671 of file vl/sift.c.

#define log2 (   x)    (log(x)/VL_LOG_OF_2)

Definition at line 678 of file vl/sift.c.

#define NBO   8

Definition at line 675 of file vl/sift.c.

#define NBP   4

Definition at line 676 of file vl/sift.c.

#define SAVE_BACK
Value:
*grad++ = vl_fast_sqrt_f (gx*gx + gy*gy) ;                          \
    *grad++ = vl_mod_2pi_f   (vl_fast_atan2_f (gy, gx) + 2*VL_PI) ;     \
    ++src ;                                                             \
#define VL_SIFT_BILINEAR_ORIENTATIONS   1

Definition at line 669 of file vl/sift.c.

Function Documentation

static void _vl_sift_smooth ( VlSiftFilt *  self,
vl_sift_pix *  outputImage,
vl_sift_pix *  tempImage,
vl_sift_pix const *  inputImage,
vl_size  width,
vl_size  height,
double  sigma 
) [static]

------------------------------------------------------------------

Definition at line 773 of file vl/sift.c.

static void copy_and_downsample ( vl_sift_pix *  dst,
vl_sift_pix const *  src,
int  width,
int  height,
int  d 
) [static]

------------------------------------------------------------------

Definition at line 837 of file vl/sift.c.

static void copy_and_upsample_rows ( vl_sift_pix *  dst,
vl_sift_pix const *  src,
int  width,
int  height 
) [static]

------------------------------------------------------------------

Definition at line 740 of file vl/sift.c.

VL_INLINE double fast_expn ( double  x)

------------------------------------------------------------------

Definition at line 692 of file vl/sift.c.

VL_INLINE void fast_expn_init ( )

------------------------------------------------------------------

Definition at line 714 of file vl/sift.c.

VL_INLINE vl_sift_pix normalize_histogram ( vl_sift_pix *  begin,
vl_sift_pix *  end 
)

------------------------------------------------------------------

Definition at line 1704 of file vl/sift.c.

static void update_gradient ( VlSiftFilt *  f) [static]

------------------------------------------------------------------

Definition at line 1447 of file vl/sift.c.

VL_EXPORT void vl_sift_calc_keypoint_descriptor ( VlSiftFilt *  f,
vl_sift_pix *  descr,
VlSiftKeypoint const *  k,
double  angle0 
)

Compute the descriptor of a keypoint.

------------------------------------------------------------------

Parameters:
fSIFT filter.
descrSIFT descriptor (output)
kkeypoint.
angle0keypoint direction.

The function computes the SIFT descriptor of the keypoint k of orientation angle0. The function fills the buffer descr which must be large enough to hold the descriptor.

The function assumes that the keypoint is on the current octave. If not, it does not do anything.

Definition at line 1923 of file vl/sift.c.

VL_EXPORT int vl_sift_calc_keypoint_orientations ( VlSiftFilt *  f,
double  angles[4],
VlSiftKeypoint const *  k 
)

Calculate the keypoint orientation(s)

------------------------------------------------------------------

Parameters:
fSIFT filter.
anglesorientations (output).
kkeypoint.

The function computes the orientation(s) of the keypoint k. The function returns the number of orientations found (up to four). The orientations themselves are written to the vector angles.

Remarks:
The function requires the keypoint octave k->o to be equal to the filter current octave vl_sift_get_octave. If this is not the case, the function returns zero orientations.
The function requires the keypoint scale level k->s to be in the range s_min+1 and s_max-2 (where usually s_min=0 and s_max=S+2). If this is not the case, the function returns zero orientations.
Returns:
number of orientations found.

Definition at line 1559 of file vl/sift.c.

VL_EXPORT void vl_sift_calc_raw_descriptor ( VlSiftFilt const *  f,
vl_sift_pix const *  grad,
vl_sift_pix *  descr,
int  width,
int  height,
double  x,
double  y,
double  sigma,
double  angle0 
)

Run the SIFT descriptor on raw data.

------------------------------------------------------------------

Parameters:
fSIFT filter.
gradimage gradients.
descrSIFT descriptor (output).
widthimage width.
heightimage height.
xkeypoint x coordinate.
ykeypoint y coordinate.
sigmakeypoint scale.
angle0keypoint orientation.

The function runs the SIFT descriptor on raw data. Here image is a 2 x width x height array (by convention, the memory layout is a s such the first index is the fastest varying one). The first width x height layer of the array contains the gradient magnitude and the second the gradient angle (in radians, between 0 and $ 2\pi $). x, y and sigma give the keypoint center and scale respectively.

In order to be equivalent to a standard SIFT descriptor the image gradient must be computed at a smoothing level equal to the scale of the keypoint. In practice, the actual SIFT algorithm makes the following additional approximation, which influence the result:

  • Scale is discretized in S levels.
  • The image is downsampled once for each octave (if you do this, the parameters x, y and sigma must be scaled too).

Definition at line 1754 of file vl/sift.c.

VL_EXPORT void vl_sift_delete ( VlSiftFilt *  f)

Delete SIFT filter.

-------------------------------------------------------------------

Parameters:
fSIFT filter to delete.

The function frees the resources allocated by vl_sift_new().

Definition at line 946 of file vl/sift.c.

VL_EXPORT void vl_sift_detect ( VlSiftFilt *  f)

Detect keypoints.

------------------------------------------------------------------ The function detect keypoints in the current octave filling the internal keypoint buffer. Keypoints can be retrieved by vl_sift_get_keypoints().

Parameters:
fSIFT filter.

Index GSS

Index matrix A

Definition at line 1153 of file vl/sift.c.

VL_EXPORT void vl_sift_keypoint_init ( VlSiftFilt const *  f,
VlSiftKeypoint *  k,
double  x,
double  y,
double  sigma 
)

Initialize a keypoint from its position and scale.

------------------------------------------------------------------

Parameters:
fSIFT filter.
kSIFT keypoint (output).
xx coordinate of the keypoint center.
yy coordinate of the keypoint center.
sigmakeypoint scale.

The function initializes a keypoint structure k from the location x and y and the scale sigma of the keypoint. The keypoint structure maps the keypoint to an octave and scale level of the discretized Gaussian scale space, which is required for instance to compute the keypoint SIFT descriptor.

Algorithm

The formula linking the keypoint scale sigma to the octave and scale indexes is

\[ \sigma(o,s) = \sigma_0 2^{o+s/S} \]

In addition to the scale index s (which can be fractional due to scale interpolation) a keypoint has an integer scale index is too (which is the index of the scale level where it was detected in the DoG scale space). We have the constraints (Detector see also the "SIFT detector"):

  • o is integer in the range $ [o_\mathrm{min}, o_{\mathrm{min}}+O-1] $.
  • is is integer in the range $ [s_\mathrm{min}+1, s_\mathrm{max}-2] $. This depends on how the scale is determined during detection, and must be so here because gradients are computed only for this range of scale levels and are required for the calculation of the SIFT descriptor.
  • $ |s - is| < 0.5 $ for detected keypoints in most cases due to the interpolation technique used during detection. However this is not necessary.

Thus octave o represents scales $ \{ \sigma(o, s) : s \in [s_\mathrm{min}+1-.5, s_\mathrm{max}-2+.5] \} $. Note that some scales may be represented more than once. For each scale, we select the largest possible octave that contains it, i.e.

\[ o(\sigma) = \max \{ o \in \mathbb{Z} : \sigma_0 2^{\frac{s_\mathrm{min}+1-.5}{S}} \leq \sigma \} = \mathrm{floor}\,\left[ \log_2(\sigma / \sigma_0) - \frac{s_\mathrm{min}+1-.5}{S}\right] \]

and then

\[ s(\sigma) = S \left[\log_2(\sigma / \sigma_0) - o(\sigma)\right], \quad is(\sigma) = \mathrm{round}\,(s(\sigma)) \]

In practice, both $ o(\sigma) $ and $ is(\sigma) $ are clamped to their feasible range as determined by the SIFT filter parameters.

Definition at line 2163 of file vl/sift.c.

VL_EXPORT VlSiftFilt* vl_sift_new ( int  width,
int  height,
int  noctaves,
int  nlevels,
int  o_min 
)

Create a new SIFT filter.

------------------------------------------------------------------

Parameters:
widthimage width.
heightimage height.
noctavesnumber of octaves.
nlevelsnumber of levels per octave.
o_minfirst octave index.

The function allocates and returns a new SIFT filter for the specified image and scale space geometry.

Setting O to a negative value sets the number of octaves to the maximum possible value depending on the size of the image.

Returns:
the new SIFT filter.
See also:
vl_sift_delete().

Definition at line 874 of file vl/sift.c.

VL_EXPORT int vl_sift_process_first_octave ( VlSiftFilt *  f,
vl_sift_pix const *  im 
)

Start processing a new image.

------------------------------------------------------------------

Parameters:
fSIFT filter.
imimage data.

The function starts processing a new image by computing its Gaussian scale space at the lower octave. It also empties the internal keypoint buffer.

Returns:
error code. The function returns VL_ERR_EOF if there are no more octaves to process.
See also:
vl_sift_process_next_octave().

Definition at line 977 of file vl/sift.c.

VL_EXPORT int vl_sift_process_next_octave ( VlSiftFilt *  f)

Process next octave.

------------------------------------------------------------------

Parameters:
fSIFT filter.

The function computes the next octave of the Gaussian scale space. Notice that this clears the record of any feature detected in the previous octave.

Returns:
error code. The function returns the error VL_ERR_EOF when there are no more octaves to process.
See also:
vl_sift_process_first_octave().

Definition at line 1083 of file vl/sift.c.

Variable Documentation

double expn_tab[EXPN_SZ+1]

fast_expn table

Definition at line 673 of file vl/sift.c.


libvlfeat
Author(s): Andrea Vedaldi
autogenerated on Thu Jun 6 2019 20:25:52