mpicbg.imagefeatures
Class FloatArray2DMOPS

java.lang.Object
  extended by mpicbg.imagefeatures.FloatArray2DFeatureTransform<FloatArray2DMOPS.Param>
      extended by mpicbg.imagefeatures.FloatArray2DMOPS

public class FloatArray2DMOPS
extends FloatArray2DFeatureTransform<FloatArray2DMOPS.Param>

This implementation actually uses the DoG-detector as described by \cite{Lowe04} and extracts local intensity patches from coarser scales similar to what was described by \cite{BrownAl05} as Multi-Scale Oriented Patches. The intensities of the patches are enhanced such that each patch uses the full [0.0--1.0] range. BibTeX:

 @inproceedings{BrownAl05,
   author    = {Matthew Brown and Richard Szeliski and Simon Winder},
   title     = {Multi-Image Matching Using Multi-Scale Oriented Patches},
   booktitle = {CVPR '05: Proceedings of the 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'05) - Volume 1},
   year      = {2005},
   isbn      = {0-7695-2372-2},
   pages     = {510--517},
   publisher = {IEEE Computer Society},
   address   = {Washington, DC, USA},
   doi       = {http://dx.doi.org/10.1109/CVPR.2005.235},
   url       = {http://www.cs.ubc.ca/~mbrown/papers/cvpr05.pdf},
 }
 @article{Lowe04,
   author  = {David G. Lowe},
   title   = {Distinctive Image Features from Scale-Invariant Keypoints},
   journal = {International Journal of Computer Vision},
   year    = {2004},
   volume  = {60},
   number  = {2},
   pages   = {91--110},
 }
 

Author:
Stephan Saalfeld

Nested Class Summary
static class FloatArray2DMOPS.Param
           
 
Field Summary
 FloatArray2D pattern
           
 
Fields inherited from class mpicbg.imagefeatures.FloatArray2DFeatureTransform
p
 
Constructor Summary
FloatArray2DMOPS(FloatArray2DMOPS.Param p)
          Constructor
 
Method Summary
static List<PointMatch> createMatches(List<Feature> fs1, List<Feature> fs2, double max_sd, AbstractModel<?> model, double max_id, double rod)
          identify corresponding features using spatial constraints
static List<PointMatch> createMatches(List<Feature> fs1, List<Feature> fs2, double rod, HashMap<Point,Feature> m1, HashMap<Point,Feature> m2)
          Identify corresponding features.
static List<PointMatch> createMatches(List<Feature> fs1, List<Feature> fs2, float rod)
          Identify corresponding features
 void extractFeatures(Collection<Feature> features)
          Detect features.
static double[] featureSizeHistogram(List<Feature> features, double min, double max, int bins)
          get a histogram of feature sizes
 long getFeatureObjectSize()
          Returns the size in bytes of a Feature object.
static long getFeatureObjectSize(int fdsize)
           
 float getInitialSigma()
           
 int getMaxOctaveSize()
           
 FloatArray2DScaleOctave getOctave(int i)
           
 FloatArray2DScaleOctave[] getOctaves()
           
 void init(FloatArray2D src)
          initialize the scale space as a scale pyramid having octave stubs only
 List<Feature> run()
          Detect features in all scale octaves.
 List<Feature> run(int max_size)
          Detect features in all scale octaves.
 List<Feature> runOctave(int o)
          detect features in the specified scale octave
 void setInitialSigma(float initialSigma)
           
 
Methods inherited from class mpicbg.imagefeatures.FloatArray2DFeatureTransform
extractFeatures
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

pattern

public FloatArray2D pattern
Constructor Detail

FloatArray2DMOPS

public FloatArray2DMOPS(FloatArray2DMOPS.Param p)
Constructor

Parameters:
feature_descriptor_size -
feature_descriptor_size -
Method Detail

getFeatureObjectSize

public long getFeatureObjectSize()
Returns the size in bytes of a Feature object.


getFeatureObjectSize

public static long getFeatureObjectSize(int fdsize)

getOctaves

public FloatArray2DScaleOctave[] getOctaves()

getOctave

public FloatArray2DScaleOctave getOctave(int i)

init

public void init(FloatArray2D src)
initialize the scale space as a scale pyramid having octave stubs only

Specified by:
init in class FloatArray2DFeatureTransform<FloatArray2DMOPS.Param>
Parameters:
src - image having a generating gaussian kernel of initial_sigma img must be a 2d-array of float values in range [0.0f, ..., 1.0f]

runOctave

public List<Feature> runOctave(int o)
detect features in the specified scale octave

Parameters:
o - octave index
Returns:
detected features

run

public List<Feature> run()
Detect features in all scale octaves. Note that there are O_SCALE_LD2 more octaves needed for descriptor extraction.

Returns:
detected features

run

public List<Feature> run(int max_size)
Detect features in all scale octaves. Note that there are O_SCALE_LD2 more octaves needed for descriptor extraction.

Returns:
detected features

createMatches

public static List<PointMatch> createMatches(List<Feature> fs1,
                                             List<Feature> fs2,
                                             float rod)
Identify corresponding features

Parameters:
fs1 - feature collection from set 1
fs2 - feature collection from set 2
rod - Ratio of distances (closest/next closest match)
Returns:
matches

createMatches

public static List<PointMatch> createMatches(List<Feature> fs1,
                                             List<Feature> fs2,
                                             double rod,
                                             HashMap<Point,Feature> m1,
                                             HashMap<Point,Feature> m2)
Identify corresponding features. Fill a HashMap that stores the Features for each positive PointMatch.

Parameters:
fs1 - feature collection from set 1
fs2 - feature collection from set 2
rod - Ratio of distances (closest/next closest match)
Returns:
matches

createMatches

public static List<PointMatch> createMatches(List<Feature> fs1,
                                             List<Feature> fs2,
                                             double max_sd,
                                             AbstractModel<?> model,
                                             double max_id,
                                             double rod)
identify corresponding features using spatial constraints

Parameters:
fs1 - feature collection from set 1 sorted by decreasing size
fs2 - feature collection from set 2 sorted by decreasing size
max_sd - maximal difference in size (ratio max/min)
model - transformation model to be applied to fs2
max_id - maximal distance in image space ($\sqrt{x^2+y^2}$)
rod - Ratio of distances (closest/next closest match)
Returns:
matches TODO implement the spatial constraints

extractFeatures

public final void extractFeatures(Collection<Feature> features)
Description copied from class: FloatArray2DFeatureTransform
Detect features.

Specified by:
extractFeatures in class FloatArray2DFeatureTransform<FloatArray2DMOPS.Param>
Parameters:
features - the Collection to be filled

featureSizeHistogram

public static double[] featureSizeHistogram(List<Feature> features,
                                            double min,
                                            double max,
                                            int bins)
get a histogram of feature sizes

Parameters:
rs -

getInitialSigma

public final float getInitialSigma()

setInitialSigma

public final void setInitialSigma(float initialSigma)

getMaxOctaveSize

public final int getMaxOctaveSize()


Copyright © 2007-2016 Fiji. All Rights Reserved.