Injecting survey points

Author: Fabien Servant

src/aliceVision/sfmData/CMakeLists.txt

@@ -12,6 +12,7 @@ set(sfmData_files_headers
   ExposureSetting.hpp
   Observation.hpp
   ConstraintPoint.hpp
+  SurveyPoint.hpp
   Constraint2D.hpp
 )
 

src/aliceVision/sfmData/SfMData.hpp

@@ -12,6 +12,7 @@
 #include <aliceVision/sfmData/Constraint2D.hpp>
 #include <aliceVision/sfmData/ConstraintPoint.hpp>
 #include <aliceVision/sfmData/RotationPrior.hpp>
+#include <aliceVision/sfmData/SurveyPoint.hpp>
 #include <aliceVision/sfmData/View.hpp>
 #include <aliceVision/sfmData/Rig.hpp>
 #include <aliceVision/camera/camera.hpp>
@@ -54,9 +55,14 @@ using Constraints2D = std::vector<Constraint2D>;
 /// Define a collection of constraints
 using ConstraintsPoint = std::map<IndexT, ConstraintPoint>;
 
+/// Define a collection of surveyed points
+using SurveyPoints = std::map<IndexT, std::vector<SurveyPoint>>;
+
 /// Define a collection of rotation priors
 using RotationPriors = std::vector<RotationPrior>;
 
+
+
 /**
  * @brief SfMData container
  * Store structure and camera properties
@@ -148,6 +154,13 @@ class SfMData
     const ConstraintsPoint& getConstraintsPoint() const { return _constraintsPoint; }
     ConstraintsPoint& getConstraintsPoint() { return _constraintsPoint; }
 
+    /**
+     * @brief Get SurveyPoints
+     * @return SurveyPoints
+     */
+    const SurveyPoints & getSurveyPoints() const { return _surveyPoints; }
+    SurveyPoints& getSurveyPoints() { return _surveyPoints; }
+
     /**
      * @brief Get RotationPriors
      * @return RotationPriors
@@ -661,6 +674,8 @@ class SfMData
     ConstraintsPoint _constraintsPoint;
     /// Rotation priors
     RotationPriors _rotationpriors;
+    /// Survey points
+    SurveyPoints _surveyPoints;
 
     /**
      * @brief Get Rig pose of a given camera view

src/aliceVision/sfmData/SfMData.i

@@ -14,6 +14,7 @@
 %include <aliceVision/sfmData/CameraPose.i>
 %include <aliceVision/sfmData/Constraint2D.i>
 %include <aliceVision/sfmData/ConstraintPoint.i>
+%include <aliceVision/sfmData/SurveyPoint.i>
 %include <aliceVision/sfmData/Landmark.i>
 %include <aliceVision/sfmData/Observation.i>
 %include <aliceVision/sfmData/Rig.i>

src/aliceVision/sfmData/SurveyPoint.hpp

@@ -0,0 +1,38 @@
+// This file is part of the AliceVision project.
+// Copyright (c) 2025 AliceVision contributors.
+// This Source Code Form is subject to the terms of the Mozilla Public License,
+// 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/.
+
+#pragma once
+
+#include <aliceVision/numeric/numeric.hpp>
+
+namespace aliceVision {
+namespace sfmData {
+
+/**
+ * @brief SurveyPoint is a surveyed 3D point on an image
+ */
+struct SurveyPoint
+{
+    SurveyPoint() = default;
+
+    SurveyPoint(const Vec3 & paramPoint3d, const Vec2 & paramSurvey)
+      : point3d(paramPoint3d), 
+        survey(paramSurvey)
+    {}
+
+    Vec3 point3d;
+    Vec2 survey;
+
+    bool operator==(const SurveyPoint& other) const
+    {
+        return (point3d == other.point3d) && (survey == other.survey);
+    }
+
+    inline bool operator!=(const SurveyPoint& other) const { return !(*this == other); }
+};
+
+}  // namespace sfmData
+}  // namespace aliceVision

src/aliceVision/sfmData/SurveyPoint.i

@@ -0,0 +1,11 @@
+// This file is part of the AliceVision project.
+// Copyright (c) 2025 AliceVision contributors.
+// This Source Code Form is subject to the terms of the Mozilla Public License,
+// 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/.
+
+%include <aliceVision/sfmData/SurveyPoint.hpp>
+
+%{
+#include <aliceVision/sfmData/SurveyPoint.hpp>
+%}

src/aliceVision/sfmDataIO/AlembicExporter.cpp

@@ -36,6 +36,7 @@ struct AlembicExporter::DataImpl
         _mvgCloud = Alembic::AbcGeom::OXform(_mvgRoot, "mvgCloud");
         _mvgPointCloud = Alembic::AbcGeom::OXform(_mvgCloud, "mvgPointCloud");
         _mvgAncestors = Alembic::AbcGeom::OXform(_mvgRoot, "mvgAncestors");
+        _mvgSurveys = Alembic::AbcGeom::OXform(_mvgCloud, "mvgSurveys");
 
         // add version as custom property
         const std::vector<::uint32_t> abcVersion = {
@@ -76,6 +77,7 @@ struct AlembicExporter::DataImpl
     Alembic::AbcGeom::OXform _mvgAncestors;
     Alembic::AbcGeom::OXform _mvgCloud;
     Alembic::AbcGeom::OXform _mvgPointCloud;
+    Alembic::AbcGeom::OXform _mvgSurveys;
     Alembic::AbcGeom::OXform _xform;
     Alembic::AbcGeom::OCamera _camObj;
     Alembic::AbcGeom::OUInt32ArrayProperty _propSensorSize_pix;
@@ -358,6 +360,11 @@ void AlembicExporter::addSfM(const sfmData::SfMData& sfmData, ESfMData flagsPart
                      (flagsPart & ESfMData::OBSERVATIONS_WITH_FEATURES));
     }
 
+    if (flagsPart & ESfMData::SURVEYS)
+    {
+        addSurveys(sfmData.getSurveyPoints());
+    }
+
     if (flagsPart & ESfMData::VIEWS || flagsPart & ESfMData::EXTRINSICS)
     {
         std::map<IndexT, std::map<IndexT, std::vector<IndexT>>> rigsViewIds;  // map<rigId,map<poseId,viewId>>
@@ -612,6 +619,32 @@ void AlembicExporter::addLandmarks(const sfmData::Landmarks& landmarks,
     }
 }
 
+void AlembicExporter::addSurveys(const sfmData::SurveyPoints & points)
+{
+    OPoints outPoints(_dataImpl->_mvgSurveys, "surveys");
+    OPointsSchema& pSchema = outPoints.getSchema();
+    OCompoundProperty userProps = pSchema.getUserProperties();
+
+    std::vector<IndexT> indices;
+    std::vector<double> data;
+
+    for (const auto & [viewId, vsp] : points)
+    {
+        for (const auto & sp : vsp)
+        {
+            indices.push_back(viewId);
+            data.push_back(sp.point3d.x());
+            data.push_back(sp.point3d.y());
+            data.push_back(sp.point3d.z());
+            data.push_back(sp.survey.x());
+            data.push_back(sp.survey.y());
+        }
+    }
+
+    OUInt32ArrayProperty(userProps, "mvg_surveyIds").set(indices);
+    ODoubleArrayProperty(userProps, "mvg_surveyData").set(data);
+}
+
 void AlembicExporter::addCamera(const std::string& name,
                                 const sfmData::View& view,
                                 const sfmData::CameraPose* pose,

src/aliceVision/sfmDataIO/AlembicExporter.hpp

@@ -63,6 +63,12 @@ class AlembicExporter
                       bool withVisibility = true,
                       bool withFeatures = true);
 
+    /**
+     * @brief Add a set of point survey
+     * @param[in] points The survey points to add
+     */
+    void addSurveys(const sfmData::SurveyPoints & points);
+
     /**
      * @brief Add a camera
      * @param[in] name The camera identifier

src/aliceVision/sfmDataIO/AlembicImporter.cpp

@@ -373,6 +373,53 @@ bool readPointCloud(const Version& abcVersion, IObject iObj, M44d mat, sfmData::
     return true;
 }
 
+bool readSurveys(IObject iObj, sfmData::SfMData& sfmdata)
+{
+    using namespace aliceVision::geometry;
+
+    IPoints points(iObj, kWrapExisting);
+    IPointsSchema& ms = points.getSchema();
+    ICompoundProperty userProps = getAbcUserProperties(ms);
+
+    if (!(userProps.getPropertyHeader("mvg_surveyIds") && userProps.getPropertyHeader("mvg_surveyData")))
+    {
+        return false;
+    }
+
+    AV_UInt32ArraySamplePtr sampleId;
+    DoubleArraySamplePtr sampleData;
+
+    sampleId.read(userProps, "mvg_surveyIds");
+
+    IDoubleArrayProperty propData(userProps, "mvg_surveyData");
+    propData.get(sampleData);
+
+    const int sampleDataSize = 5;
+
+    if (sampleId.size() * sampleDataSize != sampleData->size())
+    {
+        return false;
+    }
+
+    sfmData::SurveyPoints & output = sfmdata.getSurveyPoints();
+    for (int pos = 0; pos < sampleId.size(); pos++)
+    {
+        IndexT viewId = sampleId[pos];
+
+        sfmData::SurveyPoint pt;
+        pt.point3d.x() = (*sampleData)[pos * sampleDataSize + 0];
+        pt.point3d.y() = (*sampleData)[pos * sampleDataSize + 1];
+        pt.point3d.z() = (*sampleData)[pos * sampleDataSize + 2];
+        pt.survey.x() = (*sampleData)[pos * sampleDataSize + 3];
+        pt.survey.y() = (*sampleData)[pos * sampleDataSize + 4];
+
+        output[viewId].push_back(pt);
+    }
+
+    return true;
+}
+
+
 bool readCamera(const Version& abcVersion,
                 const ICamera& camera,
                 const M44d& mat,
@@ -1005,9 +1052,22 @@ void visitObject(const Version& abcVersion, IObject iObj, M44d mat, sfmData::SfM
         isReconstructed = false;
 
     const MetaData& md = iObj.getMetaData();
-    if (IPoints::matches(md) && (flagsPart & ESfMData::STRUCTURE))
+    if (IPoints::matches(md))
     {
-        readPointCloud(abcVersion, iObj, mat, sfmdata, flagsPart);
+        if (iObj.getName() == "surveys")
+        {
+            if (flagsPart & ESfMData::SURVEYS)
+            {
+                readSurveys(iObj, sfmdata);
+            }
+        }
+        else 
+        {
+            if (flagsPart & ESfMData::STRUCTURE )
+            {
+                readPointCloud(abcVersion, iObj, mat, sfmdata, flagsPart);
+            }
+        }
     }
     else if (IXform::matches(md))
     {

src/aliceVision/sfmDataIO/jsonIO.cpp

@@ -563,6 +563,55 @@ void loadLandmark(IndexT& landmarkId, sfmData::Landmark& landmark, bpt::ptree& l
     }
 }
 
+void saveSurveyPoints(const sfmData::SurveyPoints& spoints, bpt::ptree& parentTree)
+{
+    for (const auto & [viewId, vPoints]: spoints)
+    {
+        bpt::ptree viewTree;
+
+        viewTree.put("viewId", viewId);
+
+        bpt::ptree pointsTree;
+        for (const auto & point : vPoints)
+        {
+            bpt::ptree pointTree;
+
+            pointTree.put("X", point.point3d.x());
+            pointTree.put("Y", point.point3d.y());
+            pointTree.put("Z", point.point3d.z());
+            pointTree.put("u", point.survey.x());
+            pointTree.put("v", point.survey.y());
+            
+            pointsTree.push_back(std::make_pair("", pointTree));
+        }
+
+        viewTree.add_child("points", pointsTree);
+
+        parentTree.push_back(std::make_pair("", viewTree));
+    }
+}
+
+void loadSurveyPoints(sfmData::SurveyPoints& spoints, bpt::ptree& parentTree)
+{
+    for (const bpt::ptree::value_type& viewTree : parentTree.get_child(""))
+    {
+        IndexT viewId = viewTree.second.get<IndexT>("viewId");
+        
+        for (const bpt::ptree::value_type& pointTree : viewTree.second.get_child("points"))
+        {
+            sfmData::SurveyPoint p;
+
+            p.point3d.x() = pointTree.second.get<double>("X");
+            p.point3d.y() = pointTree.second.get<double>("Y");
+            p.point3d.z() = pointTree.second.get<double>("Z");
+            p.survey.x() = pointTree.second.get<double>("u");
+            p.survey.y() = pointTree.second.get<double>("v");
+
+            spoints[viewId].push_back(p);
+        }
+    }
+}
+
 bool saveJSON(const sfmData::SfMData& sfmData, const std::string& filename, ESfMData partFlag)
 {
     const Vec3i version = {ALICEVISION_SFMDATAIO_VERSION_MAJOR, ALICEVISION_SFMDATAIO_VERSION_MINOR, ALICEVISION_SFMDATAIO_VERSION_REVISION};
@@ -573,6 +622,7 @@ bool saveJSON(const sfmData::SfMData& sfmData, const std::string& filename, ESfM
     const bool saveIntrinsics = (partFlag & INTRINSICS) == INTRINSICS;
     const bool saveExtrinsics = (partFlag & EXTRINSICS) == EXTRINSICS;
     const bool saveStructure = (partFlag & STRUCTURE) == STRUCTURE;
+    const bool saveSurveys = (partFlag & SURVEYS) == SURVEYS;
     const bool saveFeatures = (partFlag & OBSERVATIONS_WITH_FEATURES) == OBSERVATIONS_WITH_FEATURES;
     const bool saveObservations = saveFeatures || ((partFlag & OBSERVATIONS) == OBSERVATIONS);
 
@@ -687,6 +737,16 @@ bool saveJSON(const sfmData::SfMData& sfmData, const std::string& filename, ESfM
         fileTree.add_child("structure", structureTree);
     }
 
+    // surveys
+    if (saveSurveys)
+    {
+        bpt::ptree surveyTree;
+
+        saveSurveyPoints(sfmData.getSurveyPoints(), surveyTree);
+
+        fileTree.add_child("surveys", surveyTree);
+    }
+
     // write the json file with the tree
 
     bpt::write_json(filename, fileTree);
@@ -709,6 +769,7 @@ bool loadJSON(sfmData::SfMData& sfmData,
     const bool loadIntrinsics = (partFlag & INTRINSICS) == INTRINSICS;
     const bool loadExtrinsics = (partFlag & EXTRINSICS) == EXTRINSICS;
     const bool loadStructure = (partFlag & STRUCTURE) == STRUCTURE;
+    const bool loadSurveys = (partFlag & SURVEYS) == SURVEYS;
     const bool loadFeatures = (partFlag & OBSERVATIONS_WITH_FEATURES) == OBSERVATIONS_WITH_FEATURES;
     const bool loadObservations = loadFeatures || ((partFlag & OBSERVATIONS) == OBSERVATIONS);
 
@@ -881,6 +942,15 @@ bool loadJSON(sfmData::SfMData& sfmData,
         }
     }
 
+    // surveyx
+    if (loadSurveys && fileTree.count("surveys"))
+    {
+        sfmData::SurveyPoints& surveyPoints = sfmData.getSurveyPoints();
+
+        loadSurveyPoints(surveyPoints, fileTree.get_child("surveys"));
+    }
+    
+
     return true;
 }