Non removable poses concept

Author: Fabien Servant

src/aliceVision/sfm/sfmFilters.cpp

@@ -160,56 +160,68 @@ bool eraseUnstablePoses(sfmData::SfMData& sfmData, const IndexT minPointsPerPose
     // Count the observation poses occurrence
     std::map<IndexT, IndexT> posesCount;
 
-    // Init with 0 count, undefined rig id (in order to be able to remove non referenced elements)
-    for (sfmData::Poses::const_iterator itPoses = sfmData.getPoses().begin(); itPoses != sfmData.getPoses().end(); ++itPoses)
-        posesCount[itPoses->first] = 0;
+    // Loop over all poses
+    for (auto & [poseId, pose] : sfmData.getPoses())
+    {
+        if (!pose.isRemovable())
+        {
+            continue;
+        }
+
+        posesCount[poseId] = 0;
+    }
 
     // Count occurrence of the poses in the Landmark observations
-    for (sfmData::Landmarks::const_iterator itLandmarks = landmarks.begin(); itLandmarks != landmarks.end(); ++itLandmarks)
+    for (const auto & [idLandmark, landmark] : landmarks)
     {
-        const sfmData::Observations& observations = itLandmarks->second.getObservations();
-        for (sfmData::Observations::const_iterator itObs = observations.begin(); itObs != observations.end(); ++itObs)
-        {
-            const IndexT viewId = itObs->first;
-            const sfmData::View* v = sfmData.getViews().at(viewId).get();
-            const auto poseInfoIt = posesCount.find(v->getPoseId());
+        const sfmData::Observations& observations = landmark.getObservations();
 
+        for (const auto & [viewId, obs] : observations)
+        {
+            const sfmData::View & v = sfmData.getView(viewId);
+            
+            const auto poseInfoIt = posesCount.find(v.getPoseId());
             if (poseInfoIt != posesCount.end())
+            {
                 poseInfoIt->second++;
-            else  // all pose should be defined in map_PoseId_Count
-                throw std::runtime_error(std::string("eraseUnstablePoses: found unknown pose id referenced by a view.\n\t- view id: ") +
-                                         std::to_string(v->getViewId()) + std::string("\n\t- pose id: ") + std::to_string(v->getPoseId()));
+            }
         }
     }
 
     // If usage count is smaller than the threshold, remove the Pose
-    for (std::map<IndexT, IndexT>::const_iterator it = posesCount.begin(); it != posesCount.end(); ++it)
+    for (const auto & [idPose, count] : posesCount)
     {
-        if (it->second < minPointsPerPose)
+        if (count < minPointsPerPose)
         {
-            sfmData.erasePose(it->first, true);  // no throw
+            sfmData.erasePose(idPose, true);  // no throw
 
-            for (auto& viewPair : sfmData.getViews())
+            for (auto& [viewId, view] : sfmData.getViews())
             {
-                if (viewPair.second->getPoseId() == it->first)
+                if (view->getPoseId() == idPose)
                 {
-                    if (viewPair.second->isPartOfRig())
+                    if (view->isPartOfRig())
                     {
-                        // the pose is now independent
-                        viewPair.second->setPoseId(viewPair.first);
-                        viewPair.second->setIndependantPose(true);
+                        // the pose is now independant
+                        view->setPoseId(idPose);
+                        view->setIndependantPose(true);
                     }
 
                     // add view id to the removedViewsId set
                     if (outRemovedViewsId != NULL)
-                        outRemovedViewsId->insert(viewPair.first);
+                    {
+                        outRemovedViewsId->insert(viewId);
+                    }
                 }
             }
             ++removedElements;
         }
     }
+    
     if (removedElements)
+    {
         ALICEVISION_LOG_DEBUG("eraseUnstablePoses: " << removedElements);
+    }
+
     return removedElements > 0;
 }
 

src/aliceVision/sfmData/CameraPose.hpp

@@ -93,13 +93,33 @@ class CameraPose
         _rotationOnly = partial;
     }
 
+    /**
+     * @brief Can this pose be removed from sfmdata given heuristics ?
+     * @param removable true if it can be removed normally
+    */
+    void setRemovable(bool removable)
+    {
+        _removable = removable;
+    }
+
+    /**
+     * @brief Can this pose be removed from sfmdata given heuristics ?
+     * @return true if it can be removed normally
+    */
+    bool isRemovable() const
+    {
+        return _removable;
+    }
+
   private:
     /// camera 3d transformation
     geometry::Pose3 _transform;
     /// camera lock
     bool _locked = false;
     /// Only rotation is solved
     bool _rotationOnly = false;
+    /// Can be removed
+    bool _removable = true;
     /// Estimator state
     EEstimatorParameterState _state = EEstimatorParameterState::REFINED;
 };

src/aliceVision/sfmDataIO/AlembicExporter.cpp

@@ -112,6 +112,7 @@ void AlembicExporter::DataImpl::addCamera(const std::string& name,
     {
         OBoolProperty(userProps, "mvg_poseLocked").set(pose->isLocked());
         OBoolProperty(userProps, "mvg_rotationOnly").set(pose->isRotationOnly());
+        OBoolProperty(userProps, "mvg_removable").set(pose->isRemovable());
 
         // Convert from computer vision convention to computer graphics (opengl-like)
         Eigen::Matrix4d M = Eigen::Matrix4d::Identity();

src/aliceVision/sfmDataIO/AlembicImporter.cpp

@@ -418,6 +418,7 @@ bool readCamera(const Version& abcVersion,
     bool intrinsicLocked = false;
     bool poseLocked = false;
     bool rotationOnly = false;
+    bool removable = true;
     bool poseIndependant = true;
     bool lockRatio = true;
     bool lockOffset = false;
@@ -495,6 +496,10 @@ bool readCamera(const Version& abcVersion,
             {
                 rotationOnly = getAbcProp<Alembic::Abc::IBoolProperty>(userProps, *propHeader, "mvg_rotationOnly", sampleFrame);
             }
+            if (const Alembic::Abc::PropertyHeader* propHeader = userProps.getPropertyHeader("mvg_removable"))
+            {
+                removable = getAbcProp<Alembic::Abc::IBoolProperty>(userProps, *propHeader, "mvg_removable", sampleFrame);
+            }
             if (const Alembic::Abc::PropertyHeader* propHeader = userProps.getPropertyHeader("mvg_poseIndependant"))
             {
                 poseIndependant = getAbcProp<Alembic::Abc::IBoolProperty>(userProps, *propHeader, "mvg_poseIndependant", sampleFrame);
@@ -818,6 +823,7 @@ bool readCamera(const Version& abcVersion,
         {
             sfmData::CameraPose cp(pose, poseLocked);
             cp.setRotationOnly(rotationOnly);
+            cp.setRemovable(removable);
             sfmData.setPose(*view, cp);
         }
     }

src/aliceVision/sfmDataIO/jsonIO.hpp

@@ -107,6 +107,7 @@ inline void saveCameraPose(const std::string& name, const sfmData::CameraPose& c
     savePose3("transform", cameraPose.getTransform(), cameraPoseTree);
     cameraPoseTree.put("locked", cameraPose.isLocked());
     cameraPoseTree.put("rotationOnly", cameraPose.isRotationOnly());
+    cameraPoseTree.put("removable", cameraPose.isRemovable());
     parentTree.add_child(name, cameraPoseTree);
 }
 
@@ -135,7 +136,8 @@ inline void loadCameraPose(const std::string& name, sfmData::CameraPose& cameraP
         cameraPose.unlock();
     }
 
-    poseTree.get<bool>("rotationOnly", false);
+    cameraPose.setRotationOnly(poseTree.get<bool>("rotationOnly", false));
+    cameraPose.setRemovable(poseTree.get<bool>("removable", false));
 }
 
 /**

src/software/utils/main_sfmPoseInjecting.cpp

@@ -228,6 +228,7 @@ int aliceVision_main(int argc, char** argv)
             {
                 geometry::Pose3 pose(rpose.T);
                 sfmData::CameraPose cpose(pose, false);
+                cpose.setRemovable(false);
                 sfmData.setAbsolutePose(id, cpose);
             }
         }