opencv
diff --git a/‎modules/xfeatures2d/doc/xfeatures2d.bib
Copy file name to clipboard
+9Lines changed: 9 additions & 0 deletions b/‎modules/xfeatures2d/doc/xfeatures2d.bib
Copy file name to clipboard
+9Lines changed: 9 additions & 0 deletions
diff --git a/‎modules/xfeatures2d/include/opencv2/xfeatures2d.hpp
Copy file name to clipboard
+21-5Lines changed: 21 additions & 5 deletions b/‎modules/xfeatures2d/include/opencv2/xfeatures2d.hpp
Copy file name to clipboard
+21-5Lines changed: 21 additions & 5 deletions
diff --git a/‎modules/xfeatures2d/src/logos.cpp
Copy file name to clipboard
+69Lines changed: 69 additions & 0 deletions b/‎modules/xfeatures2d/src/logos.cpp
Copy file name to clipboard
+69Lines changed: 69 additions & 0 deletions
diff --git a/‎modules/xfeatures2d/src/logos/Logos.cpp
Copy file name to clipboard
+189Lines changed: 189 additions & 0 deletions b/‎modules/xfeatures2d/src/logos/Logos.cpp
Copy file name to clipboard
+189Lines changed: 189 additions & 0 deletions
@@ -71,6 +71,15 @@ @article{Lowe04
   publisher = {Kluwer Academic Publishers}
 }
 
+@article{Lowry2018LOGOSLG,
+  title = {LOGOS: Local Geometric Support for High-Outlier Spatial Verification},
+  author = {Stephanie Lowry and Henrik Andreasson},
+  journal = {2018 IEEE International Conference on Robotics and Automation (ICRA)},
+  year = {2018},
+  pages = {7262-7269},
+  doi = {10.1109/ICRA.2018.8460988},
+}
+
 @article{Mikolajczyk2004,
   title = {Scale \& affine invariant interest point detectors},
   author = {Mikolajczyk, Krystian and Schmid, Cordelia},
 
@@ -55,7 +55,9 @@ known to be patented. You need to set the OPENCV_ENABLE_NONFREE option in cmake
 
     @defgroup xfeatures2d_match Experimental 2D Features Matching Algorithm
 
-This section describes the GMS (Grid-based Motion Statistics) matching strategy.
+This section describes the following matching strategies:
+    - GMS: Grid-based Motion Statistics, @cite Bian2017gms
+    - LOGOS: Local geometric support for high-outlier spatial verification, @cite Lowry2018LOGOSLG
 
 @}
 */
@@ -969,7 +971,7 @@ CV_EXPORTS void FASTForPointSet( InputArray image, CV_IN_OUT std::vector<KeyPoin
 //! @addtogroup xfeatures2d_match
 //! @{
 
-/** @brief GMS  (Grid-based Motion Statistics) feature matching strategy by @cite Bian2017gms .
+/** @brief GMS (Grid-based Motion Statistics) feature matching strategy described in @cite Bian2017gms .
     @param size1 Input size of image1.
     @param size2 Input size of image2.
     @param keypoints1 Input keypoints of image1.
@@ -984,10 +986,24 @@ CV_EXPORTS void FASTForPointSet( InputArray image, CV_IN_OUT std::vector<KeyPoin
         If matching results are not satisfying, please add more features. (We use 10000 for images with 640 X 480).
         If your images have big rotation and scale changes, please set withRotation or withScale to true.
  */
+CV_EXPORTS_W void matchGMS(const Size& size1, const Size& size2, const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
+                           const std::vector<DMatch>& matches1to2, CV_OUT std::vector<DMatch>& matchesGMS, const bool withRotation = false,
+                           const bool withScale = false, const double thresholdFactor = 6.0);
 
-CV_EXPORTS_W void matchGMS( const Size& size1, const Size& size2, const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
-                          const std::vector<DMatch>& matches1to2, CV_OUT std::vector<DMatch>& matchesGMS, const bool withRotation = false,
-                          const bool withScale = false, const double thresholdFactor = 6.0 );
+/** @brief LOGOS (Local geometric support for high-outlier spatial verification) feature matching strategy described in @cite Lowry2018LOGOSLG .
+    @param keypoints1 Input keypoints of image1.
+    @param keypoints2 Input keypoints of image2.
+    @param nn1 Index to the closest BoW centroid for each descriptors of image1.
+    @param nn2 Index to the closest BoW centroid for each descriptors of image2.
+    @param matches1to2 Matches returned by the LOGOS matching strategy.
+    @note
+        This matching strategy is suitable for features matching against large scale database.
+        First step consists in constructing the bag-of-words (BoW) from a representative image database.
+        Image descriptors are then represented by their closest codevector (nearest BoW centroid).
+ */
+CV_EXPORTS_W void matchLOGOS(const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
+                             const std::vector<int>& nn1, const std::vector<int>& nn2,
+                             std::vector<DMatch>& matches1to2);
 
 //! @}
 
 
@@ -0,0 +1,69 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html
+#include "precomp.hpp"
+#include "logos/Logos.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+void matchLOGOS(const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
+                const std::vector<int>& nn1, const std::vector<int>& nn2, std::vector<DMatch>& matches1to2)
+{
+    CV_CheckEQ(keypoints1.size(), nn1.size(), "Number of keypoints1 must be equal to the number of nn1.");
+    CV_CheckEQ(keypoints2.size(), nn2.size(), "Number of keypoints2 must be equal to the number of nn2.");
+    if (keypoints1.empty() || keypoints2.empty())
+    {
+        return;
+    }
+
+    std::vector<logos::Point*> vP1, vP2;
+    vP1.reserve(keypoints1.size());
+    vP2.reserve(keypoints2.size());
+
+    for (size_t i = 0; i < keypoints1.size(); i++)
+    {
+        logos::Point* pt1 = new logos::Point(keypoints1[i].pt.x, keypoints1[i].pt.y,
+                                             static_cast<float>(keypoints1[i].angle*CV_PI/180),
+                                             keypoints1[i].size, nn1[i]);
+        vP1.push_back(pt1);
+    }
+
+    for (size_t i = 0; i < keypoints2.size(); i++)
+    {
+        logos::Point* pt2 = new logos::Point(keypoints2[i].pt.x, keypoints2[i].pt.y,
+                                             static_cast<float>(keypoints2[i].angle*CV_PI/180),
+                                             keypoints2[i].size, nn2[i]);
+        vP2.push_back(pt2);
+    }
+
+    logos::Logos logos;
+    std::vector<logos::PointPair*> globalMatches;
+    logos.estimateMatches(vP1, vP2, globalMatches);
+
+    matches1to2.clear();
+    matches1to2.reserve(globalMatches.size());
+    for (size_t i = 0; i < globalMatches.size(); i++)
+    {
+        logos::PointPair* pp = globalMatches[i];
+        matches1to2.push_back(DMatch(pp->getPos1(), pp->getPos2(), 0));
+    }
+
+    for (size_t i = 0; i < globalMatches.size(); i++)
+    {
+        delete globalMatches[i];
+    }
+
+    for (size_t i = 0; i < vP1.size(); i++)
+    {
+        delete vP1[i];
+    }
+
+    for (size_t i = 0; i < vP2.size(); i++)
+    {
+        delete vP2[i];
+    }
+}
+} //namespace xfeatures2d
+} //namespace cv
@@ -0,0 +1,189 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <cmath>
+#include "Logos.hpp"
+#include <opencv2/core.hpp>
+
+namespace logos
+{
+Logos::Logos()
+{
+    LogosParameters defaultParams;
+    init(defaultParams);
+}
+
+Logos::Logos(const LogosParameters& p)
+{
+    init(p);
+}
+
+void Logos::init(const LogosParameters& p)
+{
+    setParams(p);
+    LB = static_cast<float>(-CV_PI);
+    BINSIZE = logosParams.GLOBALORILIMIT/3;
+    BINNUMBER = static_cast<unsigned int>(ceil(2*CV_PI/BINSIZE));
+    bins.resize(BINNUMBER);
+    std::fill(bins.begin(), bins.end(), 0);
+}
+
+int Logos::estimateMatches(std::vector<Point*> vP1, std::vector<Point*> vP2, std::vector<PointPair*>& globalmatches)
+{
+    matches.clear();
+
+    // for each point
+    int count1 = 0;
+
+    for (std::vector<Point*>::iterator pit1 = vP1.begin(); pit1 != vP1.end(); ++pit1, count1++)
+    {
+        (*pit1)->nearestNeighbours(vP1, count1, getNum1());
+        int count2 = 0;
+
+        // find possible matches
+        for (std::vector<Point*>::iterator pit2 = vP2.begin(); pit2 != vP2.end(); ++pit2, count2++)
+        {
+            if ((*pit1)->getLabel() != (*pit2)->getLabel())
+            {
+                continue;
+            }
+            // this is a possible match in Image 2
+            // get nearest neighbours
+            (*pit2)->nearestNeighbours(vP2, count2, getNum2());
+
+            PointPair* ptpr = new PointPair(*pit1, *pit2);
+            ptpr->addPositions(count1, count2);
+            ptpr->computeLocalSupport(pp, getNum2());
+
+            // calc matches
+            int support = 0;
+            for (std::vector<PointPair*>::const_iterator it = pp.begin(); it < pp.end(); ++it)
+            {
+                Match m(ptpr, *it);
+                if (evaluateMatch(m))
+                {
+                    support++;
+                }
+            }
+            for (size_t i = 0; i < pp.size(); i++)
+            {
+                delete pp[i];
+            }
+            pp.clear();
+            if (support > 0)
+            {
+                ptpr->setSupport(support);
+                matches.push_back(ptpr);
+                updateBin(ptpr->getRelOri());
+            }
+            else
+            {
+                delete ptpr;
+                ptpr = NULL;
+            }
+        }
+    }
+
+    // do global orientation
+    double maxang = calcGlobalOrientation();
+
+    // find which matches are within global orientation limit
+    int numinliers = 0;
+    globalmatches.clear();
+    for (std::vector<PointPair*>::iterator it = matches.begin(); it != matches.end(); ++it)
+    {
+        if (std::fabs((*it)->getRelOri() - maxang) < logosParams.GLOBALORILIMIT)
+        {
+            numinliers++;
+            globalmatches.push_back(*it);
+        }
+        else
+        {
+            delete *it;
+            *it = NULL;
+        }
+    }
+
+    return numinliers;
+}
+
+bool Logos::evaluateMatch(const Match& m) const
+{
+    return ((m.getRelOrientation() < getIntraOriLimit()) &&
+            (m.getRelScale() < getIntraScaleLimit()) &&
+            (m.getInterOrientation() < getInterOriLimit()) &&
+            (m.getInterScale() < getInterScaleLimit()));
+}
+
+void Logos::updateBin(float input)
+{
+    unsigned int binnumber = static_cast<unsigned int>(cvFloor((input-LB) / BINSIZE));
+    // compare binnumber to BINNUMBER
+    if (binnumber < BINNUMBER)
+    {
+        bins[binnumber]++;
+    }
+    else
+    {
+        bins[BINNUMBER-1]++;
+    }
+}
+
+float Logos::calcGlobalOrientation()
+{
+    // find max bin
+    // check BINNUMBER is big enough
+    if (BINNUMBER < 3)
+    {
+        return 0;
+    }
+
+    std::vector<int> bins2(BINNUMBER);
+    int maxval = 0;
+    unsigned int maxix = 0;
+    bins2[0] = bins[0] + bins[1] + bins[BINNUMBER-1];
+    maxval = bins2[0];
+    for (unsigned int i = 1; i < BINNUMBER; i++)
+    {
+        if (i == BINNUMBER-1)
+        {
+            bins2[i] = bins[i]+bins[i-1]+bins[0];
+        }
+        else
+        {
+            bins2[i] = bins[i]+bins[i-1]+bins[i+1];
+        }
+        if (bins2[i] > maxval)
+        {
+            maxval = bins2[i];
+            maxix = i;
+        }
+    }
+
+    // convert to an angle
+    return LB + maxix*BINSIZE + BINSIZE/2;
+}
+}