added SL2 (squared L2 distance) and implemented the descriptors matching in L2 using SL2

modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst

@@ -301,6 +301,20 @@ For efficiency, ``BruteForceMatcher`` is used as a template parameterized with t
         ResultType operator()( const T* a, const T* b, int size ) const;
     };
     
+    /*
+     * Squared Euclidean distance functor
+     */
+    template<class T>
+    struct SL2
+    {
+        typedef T ValueType;
+        typedef typename Accumulator<T>::Type ResultType;
+
+        ResultType operator()( const T* a, const T* b, int size ) const;
+    };
+    // Note: in case of SL2 distance a parameter maxDistance in the method DescriptorMatcher::radiusMatch 
+    // is a squared maximum distance in L2.
+
     /*
      * Manhattan distance (city block distance) functor
      */
@@ -311,7 +325,6 @@ For efficiency, ``BruteForceMatcher`` is used as a template parameterized with t
         typedef typename Accumulator<T>::Type ResultType;
 
         ResultType operator()( const T* a, const T* b, int size ) const;
-        ...
     };
 
     /*
@@ -334,7 +347,6 @@ For efficiency, ``BruteForceMatcher`` is used as a template parameterized with t
 
         ResultType operator()( const unsigned char* a, const unsigned char* b,
                                int size ) const;
-        ...
     };
 
 

modules/features2d/include/opencv2/features2d/features2d.hpp

@@ -2083,6 +2083,27 @@ template<> struct Accumulator<unsigned short> { typedef float Type; };
 template<> struct Accumulator<char>   { typedef float Type; };
 template<> struct Accumulator<short>  { typedef float Type; };
 
+/*
+ * Squeared Euclidean distance functor
+ */
+template<class T>
+struct CV_EXPORTS SL2
+{
+    typedef T ValueType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    ResultType operator()( const T* a, const T* b, int size ) const
+    {
+        ResultType result = ResultType();
+        for( int i = 0; i < size; i++ )
+        {
+            ResultType diff = (ResultType)(a[i] - b[i]);
+            result += diff*diff;
+        }
+        return result;
+    }
+};
+
 /*
  * Euclidean distance functor
  */
@@ -2395,7 +2416,7 @@ template<class Distance>
 inline void BruteForceMatcher<Distance>::commonKnnMatchImpl( BruteForceMatcher<Distance>& matcher,
                           const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
                           const vector<Mat>& masks, bool compactResult )
- {
+{
     typedef typename Distance::ValueType ValueType;
     typedef typename Distance::ResultType DistanceType;
     CV_DbgAssert( !queryDescriptors.empty() );

modules/features2d/src/matchers.cpp

@@ -328,6 +328,10 @@ Ptr<DescriptorMatcher> DescriptorMatcher::create( const string& descriptorMatche
     {
         dm = new BruteForceMatcher<L2<float> >();
     }
+    else if( !descriptorMatcherType.compare( "BruteForce-SL2" ) ) // Squared L2
+    {
+        dm = new BruteForceMatcher<SL2<float> >();
+    }
     else if( !descriptorMatcherType.compare( "BruteForce-L1" ) )
     {
         dm = new BruteForceMatcher<L1<float> >();
@@ -345,10 +349,10 @@ Ptr<DescriptorMatcher> DescriptorMatcher::create( const string& descriptorMatche
 }
 
 /*
- * BruteForce L2 specialization
+ * BruteForce SL2 and L2 specialization
  */
 template<>
-void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
+void BruteForceMatcher<SL2<float> >::knnMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
                                               const vector<Mat>& masks, bool compactResult )
 {
 #ifndef HAVE_EIGEN
@@ -427,7 +431,7 @@ void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, v
                     break;
 
                 e_allDists[bestImgIdx](bestTrainIdx) = -std::numeric_limits<float>::max();
-                curMatches->push_back( DMatch(qIdx, bestTrainIdx, bestImgIdx, sqrt((-2)*totalMaxCoeff + queryNorm2)) );
+                curMatches->push_back( DMatch(qIdx, bestTrainIdx, bestImgIdx, (-2)*totalMaxCoeff + queryNorm2) );
             }
             std::sort( curMatches->begin(), curMatches->end() );
         }
@@ -436,7 +440,7 @@ void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, v
 }
 
 template<>
-void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, float maxDistance,
+void BruteForceMatcher<SL2<float> >::radiusMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, float maxDistance,
                                                      const vector<Mat>& masks, bool compactResult )
 {
 #ifndef HAVE_EIGEN
@@ -492,7 +496,7 @@ void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors
                 {
                     if( masks.empty() || isPossibleMatch(masks[iIdx], qIdx, tIdx) )
                     {
-                        float d =  sqrt((-2)*e_allDists[iIdx](tIdx) + queryNorm2);
+                        float d =  (-2)*e_allDists[iIdx](tIdx) + queryNorm2;
                         if( d < maxDistance )
                             curMatches->push_back( DMatch( qIdx, tIdx, iIdx, d ) );
                     }
@@ -504,6 +508,40 @@ void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors
 #endif
 }
 
+inline void sqrtDistance( vector<vector<DMatch> >& matches )
+{
+    for( size_t imgIdx = 0; imgIdx < matches.size(); imgIdx++ )
+    {
+        for( size_t matchIdx = 0; matchIdx < matches[imgIdx].size(); matchIdx++ )
+        {
+            matches[imgIdx][matchIdx].distance = std::sqrt( matches[imgIdx][matchIdx].distance );
+        }
+    }
+}
+
+template<>
+void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
+                                              const vector<Mat>& masks, bool compactResult )
+{
+    BruteForceMatcher<SL2<float> > matcherSL2;
+    matcherSL2.add( getTrainDescriptors() );
+    matcherSL2.knnMatch( queryDescriptors, matches, knn, masks, compactResult );
+
+    sqrtDistance( matches );
+}
+
+template<>
+void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, float maxDistance,
+                                                     const vector<Mat>& masks, bool compactResult )
+{
+    const float maxDistance2 = maxDistance * maxDistance;
+    BruteForceMatcher<SL2<float> > matcherSL2;
+    matcherSL2.add( getTrainDescriptors() );
+    matcherSL2.radiusMatch( queryDescriptors, matches, maxDistance2, masks, compactResult );
+
+    sqrtDistance( matches );
+}
+
 /*
  * Flann based matcher
  */