[filterSfM] update code to follow latest merges

almarouk · almarouk · commit 27a1b6442b51 · 2024-03-26T12:39:34.000+01:00
diff --git a/src/software/pipeline/main_filterSfM.cpp b/src/software/pipeline/main_filterSfM.cpp
@@ -165,7 +165,7 @@ struct ObservationsAdaptator
     inline size_t kdtree_get_point_count() const { return _data.size(); }
 
     // Returns the dim'th component of the idx'th point in the class:
-    inline T kdtree_get_pt(const size_t idx, int dim) const { return _data[idx].x(dim); }
+    inline T kdtree_get_pt(const size_t idx, int dim) const { return _data[idx].getCoordinates()(dim); }
 
     // Optional bounding-box computation: return false to default to a standard bbox computation loop.
     //   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it
@@ -353,7 +353,7 @@ ObservationsPerView getObservationsPerViews(SfMData& sfmData)
     ObservationsPerView observationsPerView;
     for(auto& landIt : sfmData.getLandmarks())
     {
-        for(const auto& obsIt : landIt.second.observations)
+        for(const auto& obsIt : landIt.second.getObservations())
         {
             IndexT viewId = obsIt.first;
             auto& landmarksSet = observationsPerView[viewId];
@@ -376,7 +376,7 @@ void filterLandmarks_step1(SfMData& sfmData,
         ALICEVISION_LOG_INFO("Removing landmarks having an insufficient number of observations: started.");
         for(auto& it : sfmData.getLandmarks())
         {
-            if(it.second.observations.size() < params.minNbObservationsPerLandmark)
+            if (it.second.getObservations().size() < params.minNbObservationsPerLandmark)
                 continue;
             landmarksData[i++] = it.second;
         }
@@ -415,10 +415,10 @@ void filterLandmarks_step2(SfMData& sfmData,
     for(auto i = 0; i < landmarksData.size(); i++)
     {
         const sfmData::Landmark& landmark = landmarksData[i];
-        const auto& nbObservations = landmark.observations.size();
+        const auto& nbObservations = landmark.getObservations().size();
         auto& [viewIds, neighbors] = viewData[i];
         viewIds.reserve(nbObservations);
-        for(const auto& observationPair : landmark.observations)
+        for (const auto& observationPair : landmark.getObservations())
         {
             const IndexT viewId = observationPair.first;
             viewIds.push_back(viewId);
@@ -504,12 +504,12 @@ void filterLandmarks_step3(SfMData& sfmData,
         // compute landmark pixSize
         double pixSize = 0.;
         int n = 0;
-        for(const auto& observationPair : landmark.observations)
+        for (const auto& observationPair : landmark.getObservations())
         {
             const IndexT viewId = observationPair.first;
             pixSize += mp.getCamPixelSize(Point3d(landmark.X.x(), landmark.X.y(), landmark.X.z()),
                                           mp.getIndexFromViewId(viewId),
-                                          params.useFeatureScale ? observationPair.second.scale : 1);
+                                          params.useFeatureScale ? observationPair.second.getScale() : 1);
             n++;
         }
         pixSize /= n;
@@ -594,13 +594,13 @@ void computeInitialObservationScores(SfMData& sfmData, std::vector<Landmark*>& l
         const sfmData::Landmark& landmark = *landmarksData[i];
 
         // compute observation scores
-        const auto& nbObservations = landmark.observations.size();
+        const auto& nbObservations = landmark.getObservations().size();
         auto& [viewIds, viewScores] = viewScoresData[i];
         viewIds.reserve(nbObservations);
         viewScores.reserve(nbObservations);
         // accumulator for normalizing the scores
         double total = 0.;
-        for(const auto& observationPair : landmark.observations)
+        for (const auto& observationPair : landmark.getObservations())
         {
             const IndexT viewId = observationPair.first;
             const sfmData::View& view = *(sfmData.getViews().at(viewId));
@@ -869,7 +869,7 @@ void removeNonObservedLandmarks(SfMData& sfmData)
     const auto& initialNbLandmarks = sfmData.getLandmarks().size();
     for(auto it = sfmData.getLandmarks().begin(); it != sfmData.getLandmarks().end();)
     {
-        if(it->second.observations.size() == 0)
+        if (it->second.getObservations().size() == 0)
             it = sfmData.getLandmarks().erase(it);
         else
             ++it;
@@ -920,14 +920,13 @@ bool filterObservations3D(SfMData& sfmData, const FilterParams::FilterObservatio
 
         // keep only observations with best scores
         Observations filteredObservations;
-        size_t maxNbObservationsPerLandmark =
-            std::min(static_cast<size_t>(params.maxNbObservationsPerLandmark), landmark.observations.size());
+        size_t maxNbObservationsPerLandmark = std::min(static_cast<size_t>(params.maxNbObservationsPerLandmark), landmark.getObservations().size());
         for(auto j = 0; j < maxNbObservationsPerLandmark; j++)
         {
             // add observation only if it's an original observation and not augmented
             const auto& viewId = viewIds[idx[j]];
-            const auto& obsIt = landmark.observations.find(viewId);
-            if(obsIt != landmark.observations.end())
+            const auto& obsIt = landmark.getObservations().find(viewId);
+            if (obsIt != landmark.getObservations().end())
                 filteredObservations[viewId] = obsIt->second;
             else if (params.observationsPropagationKeep)
             {
@@ -939,7 +938,7 @@ bool filterObservations3D(SfMData& sfmData, const FilterParams::FilterObservatio
                 filteredObservations[viewId] = Observation(x, UndefinedIndexT, 0.0);
             }
         }
-        landmark.observations = std::move(filteredObservations);
+        landmark.getObservations() = std::move(filteredObservations);
     }
     ALICEVISION_LOG_INFO("Selecting observations with best scores: done");
 
@@ -970,7 +969,7 @@ double filter2DView(SfMData& sfmData, const FilterParams::FilterObservations2DPa
         std::vector<double> distances_(nbNeighbors_);
         KnnNonZeroSearch resultSet(nbNeighbors_);
         resultSet.init(&indices_[0], &distances_[0]);
-        tree.findNeighbors(resultSet, obs.x.data());
+        tree.findNeighbors(resultSet, obs.getCoordinates().data());
         const auto& nbFound = resultSet.size();
         if(nbFound == 0)
             continue;
@@ -1023,7 +1022,7 @@ double filter2DView(SfMData& sfmData, const FilterParams::FilterObservations2DPa
 }
 
 bool filterObservations2D(SfMData& sfmData, const FilterParams::FilterObservations2DParams& params,
-                          HashMap<IndexT, double>& estimatedRadii)
+                          std::map<IndexT, double>& estimatedRadii)
 {
     std::set<IndexT> viewIds = sfmData.getValidViews();
     std::vector<double> estimatedRadii_(viewIds.size(), -1.);
@@ -1046,7 +1045,7 @@ bool filterObservations2D(SfMData& sfmData, const FilterParams::FilterObservatio
     // clear and update landmark observations
     for(auto& landmark : sfmData.getLandmarks())
     {
-        landmark.second.observations.clear();
+        landmark.second.getObservations().clear();
     }
     for(int i = 0; i < viewIds.size(); ++i)
     {
@@ -1064,7 +1063,7 @@ bool filterObservations2D(SfMData& sfmData, const FilterParams::FilterObservatio
             auto& landmarks = observationsIt->second.second;
             for(int j = 0; j < observations.size(); j++)
             {
-                landmarks[j]->observations[viewId] = observations[j];
+                landmarks[j]->getObservations()[viewId] = observations[j];
             }
         }
     }
@@ -1163,7 +1162,7 @@ int aliceVision_main(int argc, char *argv[])
 
     // Read the input SfM scene
     SfMData sfmData;
-    if(!sfmDataIO::Load(sfmData, inputSfmFilename, sfmDataIO::ESfMData::ALL))
+    if(!sfmDataIO::load(sfmData, inputSfmFilename, sfmDataIO::ESfMData::ALL))
     {
         ALICEVISION_LOG_ERROR("The input SfMData file '" << inputSfmFilename << "' cannot be read.");
         return EXIT_FAILURE;
@@ -1188,7 +1187,7 @@ int aliceVision_main(int argc, char *argv[])
 
     if(params.filterObservations2D.enabled)
     {
-        HashMap<IndexT, double> estimatedRadii;
+        std::map<IndexT, double> estimatedRadii;
         ALICEVISION_LOG_INFO("Filtering observations in 2D: started.");
         filterObservations2D(sfmData, params.filterObservations2D, estimatedRadii);
         ALICEVISION_LOG_INFO("Filtering observations in 2D: done.");
@@ -1206,7 +1205,7 @@ int aliceVision_main(int argc, char *argv[])
         }
     }
 
-    sfmDataIO::Save(sfmData, outputSfmFilename, sfmDataIO::ESfMData::ALL);
+    sfmDataIO::save(sfmData, outputSfmFilename, sfmDataIO::ESfMData::ALL);
     return EXIT_SUCCESS;
 
 }
diff --git a/src/software/pipeline/main_prepareDenseScene.cpp b/src/software/pipeline/main_prepareDenseScene.cpp
@@ -95,7 +95,7 @@ ObservationsPerView getObservationsPerViews(const SfMData& sfmData)
     ObservationsPerView observationsPerView;
     for(auto& landIt : sfmData.getLandmarks())
     {
-        for(const auto& obsIt : landIt.second.observations)
+        for (const auto& obsIt : landIt.second.getObservations())
         {
             IndexT viewId = obsIt.first;
             auto& observationsSet = observationsPerView[viewId];
@@ -155,7 +155,7 @@ bool prepareDenseScene(const SfMData& sfmData,
 
     bool doMaskLandmarks = landmarksMaskScale > 0.f;
     ObservationsPerView observationsPerView;
-    HashMap<IndexT, double> estimatedRadii;
+    std::map<IndexT, double> estimatedRadii;
     if (doMaskLandmarks)
     {
         observationsPerView = std::move(getObservationsPerViews(sfmData));
@@ -334,11 +334,13 @@ bool prepareDenseScene(const SfMData& sfmData,
                     for(const auto& observation : observations)
                     {
                         const auto& obs = *observation;
-                        for(int y = std::max(obs.x.y() - r, 0.);
-                            y <= std::min(obs.x.y() + r, (double)maskLandmarks.Height() - 1); y++)
+                        for (int y = std::max(obs.getCoordinates().y() - r, 0.);
+                             y <= std::min(obs.getCoordinates().y() + r, (double)maskLandmarks.height() - 1);
+                             y++)
                         {
-                            for(int x = std::max(obs.x.x() - r, 0.);
-                                x <= std::min(obs.x.x() + r, (double)maskLandmarks.Width() - 1); x++)
+                            for (int x = std::max(obs.getCoordinates().x() - r, 0.);
+                                 x <= std::min(obs.getCoordinates().x() + r, (double)maskLandmarks.width() - 1);
+                                 x++)
                             {
                                 maskLandmarks(y, x) = std::numeric_limits<unsigned char>::max();
                             }
@@ -356,13 +358,13 @@ bool prepareDenseScene(const SfMData& sfmData,
                 dstColorImage, cam, metadata, srcImage, evCorrection, exposureCompensation,
                 [&maskLoaded, &mask, &maskLandmarks, &doMaskLandmarks](Image<RGBAfColor>& image)
                 {
-                    if(maskLoaded && (image.Width() * image.Height() != mask.Width() * mask.Height()))
+                    if(maskLoaded && (image.width() * image.height() != mask.width() * mask.height()))
                     {
                         ALICEVISION_LOG_WARNING("Invalid image mask size: mask is ignored.");
                         return;
                     }
 
-                    for(int pix = 0; pix < image.Width() * image.Height(); ++pix)
+                    for(int pix = 0; pix < image.width() * image.height(); ++pix)
                     {
                         image(pix).a() = (maskLoaded && mask(pix) == 0) ? 0.f : (doMaskLandmarks && maskLandmarks(pix) == 127) ? .5f : 1.f;
                     }

Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ struct ObservationsAdaptator`
`165`	`165`	`inline size_t kdtree_get_point_count() const { return _data.size(); }`
`166`	`166`
`167`	`167`	`// Returns the dim'th component of the idx'th point in the class:`
`168`		`- inline T kdtree_get_pt(const size_t idx, int dim) const { return _data[idx].x(dim); }`
	`168`	`+ inline T kdtree_get_pt(const size_t idx, int dim) const { return _data[idx].getCoordinates()(dim); }`
`169`	`169`
`170`	`170`	`// Optional bounding-box computation: return false to default to a standard bbox computation loop.`
`171`	`171`	`// Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it`
`@@ -353,7 +353,7 @@ ObservationsPerView getObservationsPerViews(SfMData& sfmData)`
`353`	`353`	`ObservationsPerView observationsPerView;`
`354`	`354`	`for(auto& landIt : sfmData.getLandmarks())`
`355`	`355`	`{`
`356`		`- for(const auto& obsIt : landIt.second.observations)`
	`356`	`+ for(const auto& obsIt : landIt.second.getObservations())`
`357`	`357`	`{`
`358`	`358`	`IndexT viewId = obsIt.first;`
`359`	`359`	`auto& landmarksSet = observationsPerView[viewId];`
`@@ -376,7 +376,7 @@ void filterLandmarks_step1(SfMData& sfmData,`
`376`	`376`	`ALICEVISION_LOG_INFO("Removing landmarks having an insufficient number of observations: started.");`
`377`	`377`	`for(auto& it : sfmData.getLandmarks())`
`378`	`378`	`{`
`379`		`- if(it.second.observations.size() < params.minNbObservationsPerLandmark)`
	`379`	`+ if (it.second.getObservations().size() < params.minNbObservationsPerLandmark)`
`380`	`380`	`continue;`
`381`	`381`	`landmarksData[i++] = it.second;`
`382`	`382`	`}`
`@@ -415,10 +415,10 @@ void filterLandmarks_step2(SfMData& sfmData,`
`415`	`415`	`for(auto i = 0; i < landmarksData.size(); i++)`
`416`	`416`	`{`
`417`	`417`	`const sfmData::Landmark& landmark = landmarksData[i];`
`418`		`- const auto& nbObservations = landmark.observations.size();`
	`418`	`+ const auto& nbObservations = landmark.getObservations().size();`
`419`	`419`	`auto& [viewIds, neighbors] = viewData[i];`
`420`	`420`	`viewIds.reserve(nbObservations);`
`421`		`- for(const auto& observationPair : landmark.observations)`
	`421`	`+ for (const auto& observationPair : landmark.getObservations())`
`422`	`422`	`{`
`423`	`423`	`const IndexT viewId = observationPair.first;`
`424`	`424`	`viewIds.push_back(viewId);`
`@@ -504,12 +504,12 @@ void filterLandmarks_step3(SfMData& sfmData,`
`504`	`504`	`// compute landmark pixSize`
`505`	`505`	`double pixSize = 0.;`
`506`	`506`	`int n = 0;`
`507`		`- for(const auto& observationPair : landmark.observations)`
	`507`	`+ for (const auto& observationPair : landmark.getObservations())`
`508`	`508`	`{`
`509`	`509`	`const IndexT viewId = observationPair.first;`
`510`	`510`	`pixSize += mp.getCamPixelSize(Point3d(landmark.X.x(), landmark.X.y(), landmark.X.z()),`
`511`	`511`	`mp.getIndexFromViewId(viewId),`
`512`		`- params.useFeatureScale ? observationPair.second.scale : 1);`
	`512`	`+ params.useFeatureScale ? observationPair.second.getScale() : 1);`
`513`	`513`	`n++;`
`514`	`514`	`}`
`515`	`515`	`pixSize /= n;`
`@@ -594,13 +594,13 @@ void computeInitialObservationScores(SfMData& sfmData, std::vector<Landmark*>& l`
`594`	`594`	`const sfmData::Landmark& landmark = *landmarksData[i];`
`595`	`595`
`596`	`596`	`// compute observation scores`
`597`		`- const auto& nbObservations = landmark.observations.size();`
	`597`	`+ const auto& nbObservations = landmark.getObservations().size();`
`598`	`598`	`auto& [viewIds, viewScores] = viewScoresData[i];`
`599`	`599`	`viewIds.reserve(nbObservations);`
`600`	`600`	`viewScores.reserve(nbObservations);`
`601`	`601`	`// accumulator for normalizing the scores`
`602`	`602`	`double total = 0.;`
`603`		`- for(const auto& observationPair : landmark.observations)`
	`603`	`+ for (const auto& observationPair : landmark.getObservations())`
`604`	`604`	`{`
`605`	`605`	`const IndexT viewId = observationPair.first;`
`606`	`606`	`const sfmData::View& view = *(sfmData.getViews().at(viewId));`
`@@ -869,7 +869,7 @@ void removeNonObservedLandmarks(SfMData& sfmData)`
`869`	`869`	`const auto& initialNbLandmarks = sfmData.getLandmarks().size();`
`870`	`870`	`for(auto it = sfmData.getLandmarks().begin(); it != sfmData.getLandmarks().end();)`
`871`	`871`	`{`
`872`		`- if(it->second.observations.size() == 0)`
	`872`	`+ if (it->second.getObservations().size() == 0)`
`873`	`873`	`it = sfmData.getLandmarks().erase(it);`
`874`	`874`	`else`
`875`	`875`	`++it;`
`@@ -920,14 +920,13 @@ bool filterObservations3D(SfMData& sfmData, const FilterParams::FilterObservatio`
`920`	`920`
`921`	`921`	`// keep only observations with best scores`
`922`	`922`	`Observations filteredObservations;`
`923`		`- size_t maxNbObservationsPerLandmark =`
`924`		`- std::min(static_cast<size_t>(params.maxNbObservationsPerLandmark), landmark.observations.size());`
	`923`	`+ size_t maxNbObservationsPerLandmark = std::min(static_cast<size_t>(params.maxNbObservationsPerLandmark), landmark.getObservations().size());`
`925`	`924`	`for(auto j = 0; j < maxNbObservationsPerLandmark; j++)`
`926`	`925`	`{`
`927`	`926`	`// add observation only if it's an original observation and not augmented`
`928`	`927`	`const auto& viewId = viewIds[idx[j]];`
`929`		`- const auto& obsIt = landmark.observations.find(viewId);`
`930`		`- if(obsIt != landmark.observations.end())`
	`928`	`+ const auto& obsIt = landmark.getObservations().find(viewId);`
	`929`	`+ if (obsIt != landmark.getObservations().end())`
`931`	`930`	`filteredObservations[viewId] = obsIt->second;`
`932`	`931`	`else if (params.observationsPropagationKeep)`
`933`	`932`	`{`
`@@ -939,7 +938,7 @@ bool filterObservations3D(SfMData& sfmData, const FilterParams::FilterObservatio`
`939`	`938`	`filteredObservations[viewId] = Observation(x, UndefinedIndexT, 0.0);`
`940`	`939`	`}`
`941`	`940`	`}`
`942`		`- landmark.observations = std::move(filteredObservations);`
	`941`	`+ landmark.getObservations() = std::move(filteredObservations);`
`943`	`942`	`}`
`944`	`943`	`ALICEVISION_LOG_INFO("Selecting observations with best scores: done");`
`945`	`944`
`@@ -970,7 +969,7 @@ double filter2DView(SfMData& sfmData, const FilterParams::FilterObservations2DPa`
`970`	`969`	`std::vector<double> distances_(nbNeighbors_);`
`971`	`970`	`KnnNonZeroSearch resultSet(nbNeighbors_);`
`972`	`971`	`resultSet.init(&indices_[0], &distances_[0]);`
`973`		`- tree.findNeighbors(resultSet, obs.x.data());`
	`972`	`+ tree.findNeighbors(resultSet, obs.getCoordinates().data());`
`974`	`973`	`const auto& nbFound = resultSet.size();`
`975`	`974`	`if(nbFound == 0)`
`976`	`975`	`continue;`
`@@ -1023,7 +1022,7 @@ double filter2DView(SfMData& sfmData, const FilterParams::FilterObservations2DPa`
`1023`	`1022`	`}`
`1024`	`1023`
`1025`	`1024`	`bool filterObservations2D(SfMData& sfmData, const FilterParams::FilterObservations2DParams& params,`
`1026`		`- HashMap<IndexT, double>& estimatedRadii)`
	`1025`	`+ std::map<IndexT, double>& estimatedRadii)`
`1027`	`1026`	`{`
`1028`	`1027`	`std::set<IndexT> viewIds = sfmData.getValidViews();`
`1029`	`1028`	`std::vector<double> estimatedRadii_(viewIds.size(), -1.);`
`@@ -1046,7 +1045,7 @@ bool filterObservations2D(SfMData& sfmData, const FilterParams::FilterObservatio`
`1046`	`1045`	`// clear and update landmark observations`
`1047`	`1046`	`for(auto& landmark : sfmData.getLandmarks())`
`1048`	`1047`	`{`
`1049`		`- landmark.second.observations.clear();`
	`1048`	`+ landmark.second.getObservations().clear();`
`1050`	`1049`	`}`
`1051`	`1050`	`for(int i = 0; i < viewIds.size(); ++i)`
`1052`	`1051`	`{`
`@@ -1064,7 +1063,7 @@ bool filterObservations2D(SfMData& sfmData, const FilterParams::FilterObservatio`
`1064`	`1063`	`auto& landmarks = observationsIt->second.second;`
`1065`	`1064`	`for(int j = 0; j < observations.size(); j++)`
`1066`	`1065`	`{`
`1067`		`- landmarks[j]->observations[viewId] = observations[j];`
	`1066`	`+ landmarks[j]->getObservations()[viewId] = observations[j];`
`1068`	`1067`	`}`
`1069`	`1068`	`}`
`1070`	`1069`	`}`
`@@ -1163,7 +1162,7 @@ int aliceVision_main(int argc, char *argv[])`
`1163`	`1162`
`1164`	`1163`	`// Read the input SfM scene`
`1165`	`1164`	`SfMData sfmData;`
`1166`		`- if(!sfmDataIO::Load(sfmData, inputSfmFilename, sfmDataIO::ESfMData::ALL))`
	`1165`	`+ if(!sfmDataIO::load(sfmData, inputSfmFilename, sfmDataIO::ESfMData::ALL))`
`1167`	`1166`	`{`
`1168`	`1167`	`ALICEVISION_LOG_ERROR("The input SfMData file '" << inputSfmFilename << "' cannot be read.");`
`1169`	`1168`	`return EXIT_FAILURE;`
`@@ -1188,7 +1187,7 @@ int aliceVision_main(int argc, char *argv[])`
`1188`	`1187`
`1189`	`1188`	`if(params.filterObservations2D.enabled)`
`1190`	`1189`	`{`
`1191`		`- HashMap<IndexT, double> estimatedRadii;`
	`1190`	`+ std::map<IndexT, double> estimatedRadii;`
`1192`	`1191`	`ALICEVISION_LOG_INFO("Filtering observations in 2D: started.");`
`1193`	`1192`	`filterObservations2D(sfmData, params.filterObservations2D, estimatedRadii);`
`1194`	`1193`	`ALICEVISION_LOG_INFO("Filtering observations in 2D: done.");`
`@@ -1206,7 +1205,7 @@ int aliceVision_main(int argc, char *argv[])`
`1206`	`1205`	`}`
`1207`	`1206`	`}`
`1208`	`1207`
`1209`		`- sfmDataIO::Save(sfmData, outputSfmFilename, sfmDataIO::ESfMData::ALL);`
	`1208`	`+ sfmDataIO::save(sfmData, outputSfmFilename, sfmDataIO::ESfMData::ALL);`
`1210`	`1209`	`return EXIT_SUCCESS;`
`1211`	`1210`
`1212`	`1211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ ObservationsPerView getObservationsPerViews(const SfMData& sfmData)`
`95`	`95`	`ObservationsPerView observationsPerView;`
`96`	`96`	`for(auto& landIt : sfmData.getLandmarks())`
`97`	`97`	`{`
`98`		`- for(const auto& obsIt : landIt.second.observations)`
	`98`	`+ for (const auto& obsIt : landIt.second.getObservations())`
`99`	`99`	`{`
`100`	`100`	`IndexT viewId = obsIt.first;`
`101`	`101`	`auto& observationsSet = observationsPerView[viewId];`
`@@ -155,7 +155,7 @@ bool prepareDenseScene(const SfMData& sfmData,`
`155`	`155`
`156`	`156`	`bool doMaskLandmarks = landmarksMaskScale > 0.f;`
`157`	`157`	`ObservationsPerView observationsPerView;`
`158`		`- HashMap<IndexT, double> estimatedRadii;`
	`158`	`+ std::map<IndexT, double> estimatedRadii;`
`159`	`159`	`if (doMaskLandmarks)`
`160`	`160`	`{`
`161`	`161`	`observationsPerView = std::move(getObservationsPerViews(sfmData));`
`@@ -334,11 +334,13 @@ bool prepareDenseScene(const SfMData& sfmData,`
`334`	`334`	`for(const auto& observation : observations)`
`335`	`335`	`{`
`336`	`336`	`const auto& obs = *observation;`
`337`		`- for(int y = std::max(obs.x.y() - r, 0.);`
`338`		`- y <= std::min(obs.x.y() + r, (double)maskLandmarks.Height() - 1); y++)`
	`337`	`+ for (int y = std::max(obs.getCoordinates().y() - r, 0.);`
	`338`	`+ y <= std::min(obs.getCoordinates().y() + r, (double)maskLandmarks.height() - 1);`
	`339`	`+ y++)`
`339`	`340`	`{`
`340`		`- for(int x = std::max(obs.x.x() - r, 0.);`
`341`		`- x <= std::min(obs.x.x() + r, (double)maskLandmarks.Width() - 1); x++)`
	`341`	`+ for (int x = std::max(obs.getCoordinates().x() - r, 0.);`
	`342`	`+ x <= std::min(obs.getCoordinates().x() + r, (double)maskLandmarks.width() - 1);`
	`343`	`+ x++)`
`342`	`344`	`{`
`343`	`345`	`maskLandmarks(y, x) = std::numeric_limits<unsigned char>::max();`
`344`	`346`	`}`
`@@ -356,13 +358,13 @@ bool prepareDenseScene(const SfMData& sfmData,`
`356`	`358`	`dstColorImage, cam, metadata, srcImage, evCorrection, exposureCompensation,`
`357`	`359`	`[&maskLoaded, &mask, &maskLandmarks, &doMaskLandmarks](Image<RGBAfColor>& image)`
`358`	`360`	`{`
`359`		`- if(maskLoaded && (image.Width() * image.Height() != mask.Width() * mask.Height()))`
	`361`	`+ if(maskLoaded && (image.width() * image.height() != mask.width() * mask.height()))`
`360`	`362`	`{`
`361`	`363`	`ALICEVISION_LOG_WARNING("Invalid image mask size: mask is ignored.");`
`362`	`364`	`return;`
`363`	`365`	`}`
`364`	`366`
`365`		`- for(int pix = 0; pix < image.Width() * image.Height(); ++pix)`
	`367`	`+ for(int pix = 0; pix < image.width() * image.height(); ++pix)`
`366`	`368`	`{`
`367`	`369`	`image(pix).a() = (maskLoaded && mask(pix) == 0) ? 0.f : (doMaskLandmarks && maskLandmarks(pix) == 127) ? .5f : 1.f;`
`368`	`370`	`}`