Feature matching chunks

Author: Fabien Servant

meshroom/aliceVision/FeatureMatching.py

@@ -8,7 +8,7 @@ class FeatureMatching(desc.AVCommandLineNode):
     commandLine = "aliceVision_featureMatching {allParams}"
     size = avpar.DynamicViewsSize("input")
     parallelization = desc.Parallelization(blockSize=20)
-    commandLineRange = "--rangeStart {rangeStart} --rangeSize {rangeBlockSize}"
+    commandLineRange = "--rangeIteration {rangeIteration} --rangeBlocksCount {rangeBlocksCount}"
 
     category = "Sparse Reconstruction"
     documentation = """

src/aliceVision/matchingImageCollection/ImagePairListIO.cpp

@@ -14,21 +14,13 @@
 namespace aliceVision {
 namespace matchingImageCollection {
 
-bool loadPairs(std::istream& stream, PairSet& pairs, int rangeStart, int rangeSize, bool useSymmetry)
+bool loadPairs(std::istream& stream, PairSet& pairs, bool useSymmetry)
 {
     std::size_t nbLine = 0;
     std::string sValue;
 
     for (; std::getline(stream, sValue); ++nbLine)
     {
-        if (rangeStart != -1 && rangeSize != 0)
-        {
-            if (nbLine < rangeStart)
-                continue;
-            if (nbLine >= rangeStart + rangeSize)
-                break;
-        }
-
         std::vector<std::string> vec_str;
         boost::trim(sValue);
         boost::split(vec_str, sValue, boost::is_any_of("\t "), boost::token_compress_on);
@@ -39,6 +31,7 @@ bool loadPairs(std::istream& stream, PairSet& pairs, int rangeStart, int rangeSi
             ALICEVISION_LOG_WARNING("loadPairs: Invalid input file.");
             return false;
         }
+
         std::stringstream oss;
         oss.clear();
         oss.str(vec_str[0]);
@@ -102,8 +95,6 @@ void savePairs(std::ostream& stream, const PairSet& pairs)
 
 bool loadPairsFromFile(const std::string& sFileName,  // filename of the list file,
                        PairSet& pairs,
-                       int rangeStart,
-                       int rangeSize,
                        bool useSymmetry)
 {
     std::ifstream in(sFileName);
@@ -113,7 +104,7 @@ bool loadPairsFromFile(const std::string& sFileName,  // filename of the list fi
         return false;
     }
 
-    if (!loadPairs(in, pairs, rangeStart, rangeSize, useSymmetry))
+    if (!loadPairs(in, pairs, useSymmetry))
     {
         ALICEVISION_LOG_WARNING("loadPairsFromFile: Failed to read file: \"" << sFileName << "\".");
         return false;
@@ -130,7 +121,29 @@ bool savePairsToFile(const std::string& sFileName, const PairSet& pairs)
         return false;
     }
 
-    savePairs(outStream, pairs);
+    if (pairs.empty())
+    {
+        return false;
+    }
+    
+    outStream << pairs.begin()->first << " " << pairs.begin()->second;
+    IndexT previousIndex = pairs.begin()->first;
+
+    // Pairs is sorted so we will always receive elements with the same first pair ID in
+    // continuous blocks.
+    for (auto it = std::next(pairs.begin()); it != pairs.end(); ++it)
+    {
+        if (it->first == previousIndex)
+        {
+            outStream << " " << it->second;
+        }
+        else
+        {
+            outStream << "\n" << it->first << " " << it->second;
+            previousIndex = it->first;
+        }
+    }
+    outStream << "\n";
 
     return !outStream.bad();
 }

src/aliceVision/matchingImageCollection/ImagePairListIO.hpp

@@ -5,6 +5,15 @@
 // v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at https://mozilla.org/MPL/2.0/.
 
+/**
+ * @file ImagePairListIO.hpp
+ * @brief Input/Output functions for reading and writing image pair lists.
+ * 
+ * This file provides utilities for loading and saving sets of image pairs
+ * to and from streams and files. Image pairs are used in the matching process
+ * to define which images should be compared for feature matching.
+ */
+
 #include <aliceVision/types.hpp>
 
 #include <iosfwd>
@@ -13,23 +22,54 @@
 namespace aliceVision {
 namespace matchingImageCollection {
 
-/// Load a set of PairSet from a stream
-/// I J K L (pair that link I)
-bool loadPairs(std::istream& stream, PairSet& pairs, int rangeStart = -1, int rangeSize = 0, bool useSymmetry = true);
+/**
+ * @brief Load image pairs from an input stream.
+ * 
+ * Reads image pair data from the provided input stream and populates the pairs set.
+ * Optionally supports symmetry handling.
+ * 
+ * @param[in] stream Input stream containing the pair data
+ * @param[out] pairs Set of image pairs to be populated
+ * @param[in] useSymmetry If true, automatically adds symmetric pairs (i,j) and (j,i) (default: true)
+ * @return true if pairs were successfully loaded, false otherwise
+ */
+bool loadPairs(std::istream& stream, PairSet& pairs, bool useSymmetry = true);
 
-/// Save a set of PairSet to a stream (one pair per line)
-/// I J
-/// I K
+/**
+ * @brief Save image pairs to an output stream.
+ * 
+ * Writes the image pair data to the provided output stream.
+ * 
+ * @param[out] stream Output stream where pairs will be written
+ * @param[in] pairs Set of image pairs to save
+ */
 void savePairs(std::ostream& stream, const PairSet& pairs);
 
-/// Same as loadPairs, but loads from a given file
+/**
+ * @brief Load image pairs from a file.
+ * 
+ * Reads image pair data from the specified file and populates the pairs set.
+ * This is a convenience wrapper around loadPairs() that opens the file.
+ * 
+ * @param[in] sFileName Path to the file containing the pair data
+ * @param[out] pairs Set of image pairs to be populated
+ * @param[in] useSymmetry If true, automatically adds symmetric pairs (i,j) and (j,i) (default: true)
+ * @return true if the file was opened and pairs were successfully loaded, false otherwise
+ */
 bool loadPairsFromFile(const std::string& sFileName,  // filename of the list file,
                        PairSet& pairs,
-                       int rangeStart = -1,
-                       int rangeSize = 0,
                        bool useSymmetry = true);
 
-/// Same as savePairs, but saves to a given file
+/**
+ * @brief Save image pairs to a file.
+ * 
+ * Writes the image pair data to the specified file.
+ * This is a convenience wrapper around savePairs() that creates the file.
+ * 
+ * @param[in] sFileName Path to the output file
+ * @param[in] pairs Set of image pairs to save
+ * @return true if the file was created and pairs were successfully saved, false otherwise
+ */
 bool savePairsToFile(const std::string& sFileName, const PairSet& pairs);
 
 }  // namespace matchingImageCollection

src/aliceVision/matchingImageCollection/ImagePairListIO_test.cpp

@@ -24,7 +24,7 @@ BOOST_AUTO_TEST_CASE(read_write_pairs_to_file)
 
     PairSet pairSetGTsorted;
     pairSetGTsorted.insert(std::make_pair(0, 1));
-    pairSetGTsorted.insert(std::make_pair(0, 2));
+    pairSetGTsorted.insert(std::make_pair(2, 0));
     pairSetGTsorted.insert(std::make_pair(1, 2));
 
     BOOST_CHECK(savePairsToFile("pairsT_IO.txt", pairSetGT));
@@ -35,26 +35,3 @@ BOOST_AUTO_TEST_CASE(read_write_pairs_to_file)
     std::remove("pairsT_IO.txt");
 }
 
-BOOST_AUTO_TEST_CASE(save_pairs)
-{
-    PairSet pairs = {{0, 2}, {0, 4}, {0, 5}, {8, 2}, {0, 1}, {5, 9}};
-
-    std::stringstream output;
-    savePairs(output, pairs);
-    BOOST_CHECK_EQUAL(output.str(), std::string("0 1 2 4 5\n5 9\n8 2\n"));
-}
-
-BOOST_AUTO_TEST_CASE(load_multiple_pairs_per_line)
-{
-    std::stringstream input;
-    input.str(R"( 0 2 4 5
-        0 1
-        5 9
-)");
-
-    PairSet loadedPairs;
-    BOOST_CHECK(loadPairs(input, loadedPairs));
-
-    PairSet expectedPairs = {{0, 2}, {0, 4}, {0, 5}, {0, 1}, {5, 9}};
-    BOOST_CHECK(loadedPairs == expectedPairs);
-}

src/aliceVision/matchingImageCollection/pairBuilder.cpp

@@ -19,29 +19,23 @@
 namespace aliceVision {
 
 /// Generate all the (I,J) pairs of the upper diagonal of the NxN matrix
-PairSet exhaustivePairs(const sfmData::Views& views, int rangeStart, int rangeSize)
+PairSet exhaustivePairs(const std::set<IndexT> & viewIds)
 {
     PairSet pairs;
-    sfmData::Views::const_iterator itA = views.begin();
-    sfmData::Views::const_iterator itAEnd = views.end();
-
-    // If we have a rangeStart, only compute the matching for (rangeStart, X).
-    if (rangeStart != -1 && rangeSize != 0)
-    {
-        if (rangeStart >= views.size())
-            return pairs;
-        std::advance(itA, rangeStart);
-        itAEnd = views.begin();
-        std::advance(itAEnd, std::min(std::size_t(rangeStart + rangeSize), views.size()));
-    }
+    auto itA = viewIds.begin();
+    auto itAEnd = viewIds.end();
 
     for (; itA != itAEnd; ++itA)
     {
-        sfmData::Views::const_iterator itB = itA;
+        auto itB = itA;
         std::advance(itB, 1);
-        for (; itB != views.end(); ++itB)
-            pairs.insert(std::make_pair(itA->first, itB->first));
+
+        for (; itB != viewIds.end(); ++itB)
+        {
+            pairs.insert(std::make_pair(*itA, *itB));
+        }
     }
+
     return pairs;
 }
 

src/aliceVision/matchingImageCollection/pairBuilder.hpp

@@ -13,7 +13,11 @@
 
 namespace aliceVision {
 
-/// Generate all the (I,J) pairs of the upper diagonal of the NxN matrix
-PairSet exhaustivePairs(const sfmData::Views& views, int rangeStart = -1, int rangeSize = 0);
+/**
+ * @brief Generate all the (I,J) pairs of the upper diagonal of the NxN matrix
+ * @param views the sfmData views indices list
+ * @return a generated set of pairs
+ */
+PairSet exhaustivePairs(const std::set<IndexT> & viewIds);
 
 };  // namespace aliceVision

src/aliceVision/matchingImageCollection/pairBuilder_test.cpp

@@ -34,20 +34,15 @@ bool checkPairOrder(const IterablePairs& pairs)
 
 BOOST_AUTO_TEST_CASE(matchingImageCollection_exhaustivePairs)
 {
-    sfmData::Views views;
     {
         // Empty
-        PairSet pairSet = exhaustivePairs(views);
+        std::set<IndexT> indices;
+        PairSet pairSet = exhaustivePairs(indices);
         BOOST_CHECK_EQUAL(0, pairSet.size());
     }
     {
-        std::vector<IndexT> indexes = {{12, 54, 89, 65}};
-        for (IndexT i : indexes)
-        {
-            views.emplace(i, std::make_shared<sfmData::View>("filepath", i));
-        }
-
-        PairSet pairSet = exhaustivePairs(views);
+        std::set<IndexT> indices = {12, 54, 89, 65};
+        PairSet pairSet = exhaustivePairs(indices);
         BOOST_CHECK(checkPairOrder(pairSet));
         BOOST_CHECK_EQUAL(6, pairSet.size());
         BOOST_CHECK(pairSet.find(std::make_pair(12, 54)) != pairSet.end());