augment contaminated brackets

src/aliceVision/hdr/brackets.cpp

@@ -303,6 +303,42 @@ std::vector<std::vector<LuminanceInfo>> splitMonotonics(const std::vector<Lumina
  return splitted;
 }
 
+/**
+* @brief assume ref is smaller than larger
+* Try to find a subpart of larger which has the same set of exposures that smaller
+* @param smaller the set to compare
+* @param larger the set where the subpart should be
+* @return the index of the subpart or -1 if not found
+*/
+int extractIndex(const std::vector<LuminanceInfo> & smaller, const std::vector<LuminanceInfo> & larger)
+{
+ int largerSize = larger.size();
+ int smallerSize = smaller.size();
+ int diff = largerSize - smallerSize;
+
+ //For all continuous subparts of the erased sequence
+ for (int indexStart = 0; indexStart < diff; indexStart++)
+ {
+ //Check that the subpart is the same set of exposures
+ bool allCorrect = true;
+ for (int pos = 0; pos < smallerSize; pos++)
+ {
+ if (smaller[pos].mexposure != larger[indexStart + pos].mexposure)
+ {
+ allCorrect = false;
+ }
+ }
+
+ if (allCorrect)
+ {
+ return indexStart;
+ }
+ }
+
+ return -1;
+}
+
+
 std::vector<std::vector<IndexT>> estimateGroups(const std::vector<LuminanceInfo> & luminanceInfos)
 {
  std::vector<std::vector<IndexT>> groups;
@@ -321,6 +357,16 @@ std::vector<std::vector<IndexT>> estimateGroups(const std::vector<LuminanceInfo>
  monotonics.insert(monotonics.end(), lmonotonics.begin(), lmonotonics.end());
  }
 
+ //Sort the voters groups by exposure increasing
+ for (auto & group : monotonics)
+ {
+ std::sort(group.begin(), 
+ group.end(), 
+ [](const LuminanceInfo& a, const LuminanceInfo& b) {
+ return (a.mexposure < b.mexposure);
+ });
+ }
+
  // Vote for the best bracket count
  std::map<size_t, int> counters;
  for (const auto& group : monotonics)
@@ -355,10 +401,12 @@ std::vector<std::vector<IndexT>> estimateGroups(const std::vector<LuminanceInfo>
 
  // Only keep voters with the majority bracket size
  auto groupIt = monotonics.begin();
+ std::vector<std::vector<LuminanceInfo>> eraseds;
  while (groupIt != monotonics.end())
  {
  if (groupIt->size() != bestBracketCount)
  {
+ eraseds.push_back(*groupIt);
  groupIt = monotonics.erase(groupIt);
  }
  else
@@ -367,14 +415,39 @@ std::vector<std::vector<IndexT>> estimateGroups(const std::vector<LuminanceInfo>
  }
  }
 
- //Sort the voters groups by exposure increasing
- for (auto & group : monotonics)
+ //Try to push back erased
+ for (const auto & erased: eraseds)
  {
- std::sort(group.begin(), 
- group.end(), 
- [](const LuminanceInfo& a, const LuminanceInfo& b) {
- return (a.mexposure < b.mexposure);
- });
+ //If erased is larger than the most voted, then 
+ //Maybe it contains outliers. Try to find a correct subpart
+ int diff = int(erased.size()) - bestBracketCount;
+ if (diff < 0)
+ {
+ continue;
+ }
+
+
+ //Compare with all valid monotonics
+ int offset = -1;
+ for (const auto& monotonic : monotonics)
+ {
+ offset = extractIndex(monotonic, erased);
+ if (offset >= 0)
+ {
+ break;
+ }
+ }
+
+ //If something found, put it back on list of monotonics
+ if (offset >= 0)
+ {
+ std::vector<LuminanceInfo> subpart;
+ for (int index = 0; index < bestBracketCount; index++)
+ {
+ subpart.push_back(erased[offset + index]);
+ }
+ monotonics.push_back(subpart);
+ }
  }
 
  //check coherency
@@ -411,6 +484,8 @@ std::vector<std::vector<IndexT>> estimateGroups(const std::vector<LuminanceInfo>
  groups.push_back(group);
  }
 
+ ALICEVISION_LOG_INFO("Groups found : " << monotonics.size());
+
  return groups;
 }