[feature] config for descriptor normalization mode changed

Author: Carsten Griwodz

src/application/main.cpp

@@ -98,9 +98,11 @@ static void parseargs(int argc, char** argv, popsift::Config& config, string& in
         "Computed filter width are lower than VLFeat/PopSift")
         ("direct-scaling", bool_switch()->notifier([&](bool b) { if(b) config.setScalingMode(popsift::Config::ScaleDirect); }),
          "Direct each octave from upscaled orig instead of blurred level.")
-        ("root-sift", bool_switch()->notifier([&](bool b) { if(b) config.setUseRootSift(true); }),
-        "Use the L1-based norm for OpenMVG rather than L2-based as in OpenCV")
         ("norm-multi", value<int>()->notifier([&](int i) {config.setNormalizationMultiplier(i); }), "Multiply the descriptor by pow(2,<int>).")
+        ( "norm-mode", value<std::string>()->notifier([&](const std::string& s) { config.setNormMode(s); }),
+          popsift::Config::getNormModeUsage() )
+        ( "root-sift", bool_switch()->notifier([&](bool b) { if(b) config.setNormMode(popsift::Config::RootSift); }),
+          popsift::Config::getNormModeUsage() )
         ("filter-max-extrema", value<int>()->notifier([&](int f) {config.setFilterMaxExtrema(f); }), "Approximate max number of extrema.")
         ("filter-grid", value<int>()->notifier([&](int f) {config.setFilterGridSize(f); }), "Grid edge length for extrema filtering (ie. value 4 leads to a 4x4 grid)")
         ("filter-sort", value<std::string>()->notifier([&](const std::string& s) {config.setFilterSorting(s); }), "Sort extrema in each cell by scale, either random (default), up or down");

src/application/match.cpp

@@ -97,9 +97,11 @@ static void parseargs(int argc, char** argv, popsift::Config& config, string& lF
         "Computed filter width are lower than VLFeat/PopSift")
         ("direct-scaling", bool_switch()->notifier([&](bool b) { if(b) config.setScalingMode(popsift::Config::ScaleDirect); }),
          "Direct each octave from upscaled orig instead of blurred level.")
-        ("root-sift", bool_switch()->notifier([&](bool b) { if(b) config.setUseRootSift(true); }),
-        "Use the L1-based norm for OpenMVG rather than L2-based as in OpenCV")
         ("norm-multi", value<int>()->notifier([&](int i) {config.setNormalizationMultiplier(i); }), "Multiply the descriptor by pow(2,<int>).")
+        ( "norm-mode", value<std::string>()->notifier([&](const std::string& s) { config.setNormMode(s); }),
+          popsift::Config::getNormModeUsage() )
+        ( "root-sift", bool_switch()->notifier([&](bool b) { if(b) config.setNormMode(popsift::Config::RootSift); }),
+          popsift::Config::getNormModeUsage() )
         ("filter-max-extrema", value<int>()->notifier([&](int f) {config.setFilterMaxExtrema(f); }), "Approximate max number of extrema.")
         ("filter-grid", value<int>()->notifier([&](int f) {config.setFilterGridSize(f); }), "Grid edge length for extrema filtering (ie. value 4 leads to a 4x4 grid)")
         ("filter-sort", value<std::string>()->notifier([&](const std::string& s) {config.setFilterSorting(s); }), "Sort extrema in each cell by scale, either random (default), up or down");

src/popsift/sift_conf.cu

@@ -34,7 +34,7 @@ Config::Config( )
     , _filter_grid_size( 2 )
     , _assume_initial_blur( true )
     , _initial_blur( 0.5f )
-    , _use_root_sift( true )
+    , _normalization_mode( getNormModeDefault() )
     , _normalization_multiplier( 0 )
     , _print_gauss_tables( false )
 {
@@ -97,7 +97,7 @@ void Config::setGaussMode( const std::string& m )
     else if( m == "fixed15" )
         setGaussMode( Config::Fixed15 );
     else
-        POP_FATAL( string("Bad Gauss mode.") + getGaussModeUsage() );
+        POP_FATAL( string("Bad Gauss mode.\n") + getGaussModeUsage() );
 }
 
 Config::GaussMode Config::getGaussModeDefault( )
@@ -165,15 +165,79 @@ void Config::setScalingMode( ScalingMode mode )
     _scaling_mode = mode;
 }
 
+/**
+ * Normalization mode
+ * Should the descriptor normalization use L2-like classic normalization
+ * of the typically better L1-like RootSift normalization?
+ */
+void Config::setUseRootSift( bool on )
+{
+    if( on )
+        _normalization_mode = RootSift;
+    else
+        _normalization_mode = Classic;
+}
+
+bool Config::getUseRootSift( ) const
+{
+    return ( _normalization_mode == RootSift );
+}
+
+Config::NormMode Config::getNormMode( NormMode m ) const 
+{
+    return _normalization_mode;
+}
+
+void Config::setNormMode( Config::NormMode m )
+{
+    _normalization_mode = m;
+}
+
+void Config::setNormMode( const std::string& m )
+{
+    if( m == "RootSift" ) setNormMode( Config::RootSift );
+    else if( m == "classic" ) setNormMode( Config::Classic );
+    else
+        POP_FATAL( string("Bad Normalization mode.\n") + getGaussModeUsage() );
+}
+
+Config::NormMode Config::getNormModeDefault( )
+{
+    return Config::RootSift;
+}
+
+const char* Config::getNormModeUsage( )
+{
+    return
+        "Choice of descriptor normalization modes. "
+        "Options are: "
+        "RootSift (L1-like, default), "
+        "Classic (L2-like)";
+}
+
+/**
+ * Normalization multiplier
+ * A power of 2 multiplied with the normalized descriptor. Required
+ * for the construction of 1-byte integer desciptors.
+ * Usual choice is 2^8 or 2^9.
+ */
+void Config::setNormalizationMultiplier( int mul )
+{
+    _normalization_multiplier = mul;
+}
+
+int Config::getNormalizationMultiplier( ) const
+{
+    return _normalization_multiplier;
+}
+
 void Config::setDownsampling( float v ) { _upscale_factor = -v; }
 void Config::setOctaves( int v ) { octaves = v; }
 void Config::setLevels( int v ) { levels = v; }
 void Config::setSigma( float v ) { sigma = v; }
 void Config::setEdgeLimit( float v ) { _edge_limit = v; }
 void Config::setThreshold( float v ) { _threshold = v; }
 void Config::setPrintGaussTables() { _print_gauss_tables = true; }
-void Config::setUseRootSift( bool on ) { _use_root_sift = on; }
-void Config::setNormalizationMultiplier( int mul ) { _normalization_multiplier = mul; }
 void Config::setFilterMaxExtrema( int ext ) { _filter_max_extrema = ext; }
 void Config::setFilterGridSize( int sz ) { _filter_grid_size = sz; }
 
@@ -233,7 +297,7 @@ bool Config::equal( const Config& other ) const
         COMPARE( _sift_mode ) ||
         COMPARE( _assume_initial_blur ) ||
         COMPARE( _initial_blur ) ||
-        COMPARE( _use_root_sift ) ||
+        COMPARE( _normalization_mode ) ||
         COMPARE( _normalization_multiplier ) ) return false;
     return true;
 }

src/popsift/sift_conf.h

@@ -57,6 +57,11 @@ struct Config
         NoTile       // variant of IGrid, no duplicate gradiant fetching
     };
 
+    enum NormMode {
+        RootSift,   // The L1-inspired norm, gives better matching results
+        Classic     // The L2-inspired norm, all descriptors on a hypersphere
+    };
+
     /* To reduce time used in descriptor extraction, some extrema can be filtered
      * immediately after finding them. It is possible to keep those with the largest
      * scale (LargestScaleFirst), smallest scale (SmallestScaleFirst), or a random
@@ -96,11 +101,9 @@ struct Config
     void setEdgeLimit( float v );
     void setThreshold( float v );
     void setInitialBlur( float blur );
-    void setUseRootSift( bool on );
     void setMaxExtreme( int m );
     void setPrintGaussTables( );
     void setDPOrientation( bool on );
-    void setNormalizationMultiplier( int mul );
     void setMaxExtrema( int extrema );
     void setFilterMaxExtrema( int extrema );
     void setFilterGridSize( int sz );
@@ -151,9 +154,21 @@ struct Config
     // default edge_limit 10.0f from Bemap
     float    _edge_limit;
 
-    inline bool getUseRootSift( ) const {
-        return _use_root_sift;
-    }
+    /** Functions related to descriptor normalization: L2-like or RootSift
+     */
+    void               setNormMode( NormMode m );
+    void               setNormMode( const std::string& m );
+    void               setNormNode( const std::string& m );
+    void               setUseRootSift( bool on ) __attribute__ ((deprecated));
+    bool               getUseRootSift( ) const;
+    NormMode           getNormMode( NormMode m ) const;
+    static NormMode    getNormModeDefault( ); // Call this from the constructor.
+    static const char* getNormModeUsage( );  // Helper functions for the main program's usage string.
+
+    /** Functions related to descriptor normalization: multiply with a power of 2
+     */
+    int  getNormalizationMultiplier( ) const;
+    void setNormalizationMultiplier( int mul );
 
     /* The input image is stretched by 2^upscale_factor
      * before processing. The factor 1 is default.
@@ -162,10 +177,6 @@ struct Config
         return _upscale_factor;
     }
 
-    int getNormalizationMultiplier( ) const {
-        return _normalization_multiplier;
-    }
-
     int getMaxExtrema( ) const {
         return _max_extrema;
     }
@@ -275,17 +286,17 @@ struct Config
     bool  _assume_initial_blur;
     float _initial_blur;
 
-    /* OpenMVG requires a normalization named rootSift.
-     * Default is the OpenCV method.
+    /* OpenMVG requires a normalization named rootSift, the
+     * classical L2-inspired mode is also supported.
      */
-    bool _use_root_sift;
+    NormMode _normalization_mode;
 
     /* SIFT descriptors are normalized in a final step.
      * The values of the descriptor can also be multiplied
      * by a power of 2 if required.
      * Specify the exponent.
      */
-    int      _normalization_multiplier;
+    int _normalization_multiplier;
 
     /* Call the debug functions in gauss_filter.cu to print Gauss
      * filter width and Gauss tables in use.