软件步骤6：OpenMVG实现增量式和全局式SFM

最新推荐文章于 2024-05-14 11:28:23 发布
最新推荐文章于 2024-05-14 11:28:23 发布
阅读量156 收藏
点赞数 1
分类专栏： 3D Vison 文章标签： 3d 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48465302/article/details/138168427
版权 
#include "openMVG/cameras/Camera_Common.hpp"
#include "openMVG/cameras/Cameras_Common_command_line_helper.hpp"

#include "openMVG/sfm/pipelines/sfm_features_provider.hpp"
#include "openMVG/sfm/pipelines/sfm_matches_provider.hpp"
#include "openMVG/sfm/sfm_data.hpp"
#include "openMVG/sfm/sfm_data_io.hpp"
#include "openMVG/sfm/sfm_report.hpp"
#include "openMVG/sfm/sfm_view.hpp"
#include "openMVG/system/timer.hpp"
#include "openMVG/types.hpp"

// SfM Engines
#include "openMVG/sfm/pipelines/sequential/sequential_SfM.hpp"
#include "openMVG/sfm/pipelines/sequential/sequential_SfM2.hpp"
#include "openMVG/sfm/pipelines/sequential/SfmSceneInitializerMaxPair.hpp"
#include "openMVG/sfm/pipelines/sequential/SfmSceneInitializerStellar.hpp"
#include "openMVG/sfm/pipelines/global/GlobalSfM_rotation_averaging.hpp"
#include "openMVG/sfm/pipelines/global/GlobalSfM_translation_averaging.hpp"
#include "openMVG/sfm/pipelines/global/sfm_global_engine_relative_motions.hpp"

#include "third_party/cmdLine/cmdLine.h"
#include "third_party/stlplus3/filesystemSimplified/file_system.hpp"

#include <cstdlib>
#include <memory>
#include <string>
#include <utility>

using namespace openMVG;
using namespace openMVG::cameras;
using namespace openMVG::sfm;

//SFM初始化方式，INCREMENTALV2版本才能用到
enum class ESfMSceneInitializer
{
  INITIALIZE_EXISTING_POSES,
  INITIALIZE_MAX_PAIR,
  INITIALIZE_AUTO_PAIR,
  INITIALIZE_STELLAR
};
//SFM Engine选用
enum class ESfMEngine
{
  INCREMENTAL,
  INCREMENTALV2,
  GLOBAL
};

bool StringToEnum
(
  const std::string & str,
  ESfMEngine & sfm_engine
)
{
  const std::map<std::string, ESfMEngine> string_to_enum_mapping =
  {
    {"INCREMENTAL", ESfMEngine::INCREMENTAL},
    {"INCREMENTALV2", ESfMEngine::INCREMENTALV2},
    {"GLOBAL", ESfMEngine::GLOBAL},
  };
  const auto it  = string_to_enum_mapping.find(str);
  if (it == string_to_enum_mapping.end())
    return false;
  sfm_engine = it->second;
  return true;
}

bool StringToEnum
(
  const std::string & str,
  ESfMSceneInitializer & scene_initializer
)
{
  const std::map<std::string, ESfMSceneInitializer> string_to_enum_mapping =
  {
    {"EXISTING_POSE", ESfMSceneInitializer::INITIALIZE_EXISTING_POSES},
    {"MAX_PAIR", ESfMSceneInitializer::INITIALIZE_MAX_PAIR},
    {"AUTO_PAIR", ESfMSceneInitializer::INITIALIZE_AUTO_PAIR},
    {"STELLAR", ESfMSceneInitializer::INITIALIZE_STELLAR},
  };
  const auto it  = string_to_enum_mapping.find(str);
  if (it == string_to_enum_mapping.end())
    return false;
  scene_initializer = it->second;
  return true;
}
//给两个文件名字，找到两个文件对应的View的索引
bool computeIndexFromImageNames(
  const SfM_Data & sfm_data,
  const std::pair<std::string,std::string>& initialPairName,
  Pair& initialPairIndex)
{
  if (initialPairName.first == initialPairName.second)
  {
    OPENMVG_LOG_ERROR << "Invalid image names. You cannot use the same image to initialize a pair.";
    return false;
  }

  initialPairIndex = {UndefinedIndexT, UndefinedIndexT};

  /// List views filenames and find the one that correspond to the user ones:
  for (Views::const_iterator it = sfm_data.GetViews().begin();
    it != sfm_data.GetViews().end(); ++it)
  {
    const View * v = it->second.get();
    const std::string filename = stlplus::filename_part(v->s_Img_path);
    if (filename == initialPairName.first)
    {
      initialPairIndex.first = v->id_view;
    }
    else{
      if (filename == initialPairName.second)
      {
        initialPairIndex.second = v->id_view;
      }
    }
  }
  return (initialPairIndex.first != UndefinedIndexT &&
      initialPairIndex.second != UndefinedIndexT);
}

int main(int argc, char **argv)
{
  using namespace std;
  OPENMVG_LOG_INFO
    << "\n-----------------------------------------------------------"
    << "\n Structure from Motion:"
    << "\n-----------------------------------------------------------";
  CmdLine cmd;

  // Common options:
  std::string
    filename_sfm_data,
    directory_match,
    filename_match,
    directory_output,
    engine_name = "INCREMENTAL";

  // Bundle adjustment options:
  std::string sIntrinsic_refinement_options = "ADJUST_ALL";
  std::string sExtrinsic_refinement_options = "ADJUST_ALL";
  bool b_use_motion_priors = false;

  // Incremental SfM options
  int triangulation_method = static_cast<int>(ETriangulationMethod::DEFAULT);
  int resection_method  = static_cast<int>(resection::SolverType::DEFAULT);
  int user_camera_model = PINHOLE_CAMERA_RADIAL3;

  // SfM v1
  std::pair<std::string,std::string> initial_pair_string("","");

  // SfM v2
  std::string sfm_initializer_method = "STELLAR";

  // Global SfM options
  int rotation_averaging_method = int (ROTATION_AVERAGING_L2);
  int translation_averaging_method = int (TRANSLATION_AVERAGING_SOFTL1);


  // Common options
  cmd.add( make_option('i', filename_sfm_data, "input_file") );
  cmd.add( make_option('m', directory_match, "match_dir") );
  cmd.add( make_option('M', filename_match, "match_file") );
  cmd.add( make_option('o', directory_output, "output_dir") );
  cmd.add( make_option('s', engine_name, "sfm_engine") );

  // Bundle adjustment options
  cmd.add( make_option('f', sIntrinsic_refinement_options, "refine_intrinsic_config") );
  cmd.add( make_option('e', sExtrinsic_refinement_options, "refine_extrinsic_config") );
  cmd.add( make_switch('P', "prior_usage") );

  // Incremental SfM pipeline options
  cmd.add( make_option('t', triangulation_method, "triangulation_method"));
  cmd.add( make_option('r', resection_method, "resection_method"));
  cmd.add( make_option('c', user_camera_model, "camera_model") );
  // Incremental SfM2
  cmd.add( make_option('S', sfm_initializer_method, "sfm_initializer") );
  // Incremental SfM1
  cmd.add( make_option('a', initial_pair_string.first, "initial_pair_a") );
  cmd.add( make_option('b', initial_pair_string.second, "initial_pair_b") );
  // Global SfM
  cmd.add( make_option('r', rotation_averaging_method, "rotationAveraging") );
  cmd.add( make_option('t', translation_averaging_method, "translationAveraging") );

  try {
    if (argc == 1) throw std::string("Invalid parameter.");
    cmd.process(argc, argv);
  } catch (const std::string& s) {

    OPENMVG_LOG_INFO << "Usage: " << argv[0] << '\n'
    << "[Required]\n"
    << "[-i|--input_file] path to a SfM_Data scene\n"
    << "[-m|--match_dir] path to the matches that corresponds to the provided SfM_Data scene\n"
    << "[-o|--output_dir] path where the output data will be stored\n"
    << "[-s|--sfm_engine] Type of SfM Engine to use for the reconstruction\n"
      << "\t INCREMENTAL   : add image sequentially to a 2 view seed\n"
      << "\t INCREMENTALV2 : add image sequentially to a 2 or N view seed (experimental)\n"
      << "\t GLOBAL        : initialize globally rotation and translations\n"
    << "\n\n"
    << "[Optional parameters]\n"
    << "\n\n"
    << "[Common]\n"
    << "[-M|--match_file] path to the match file to use (i.e matches.f.txt or matches.f.bin)\n"
    << "[-f|--refine_extrinsic_config] Intrinsic parameters refinement option\n"
      << "\t ADJUST_ALL -> refine all existing parameters (default) \n"
      << "\t NONE -> intrinsic parameters are held as constant\n"
      << "\t ADJUST_FOCAL_LENGTH -> refine only the focal length\n"
      << "\t ADJUST_PRINCIPAL_POINT -> refine only the principal point position\n"
      << "\t ADJUST_DISTORTION -> refine only the distortion coefficient(s) (if any)\n"
      << "\t -> NOTE: options can be combined thanks to '|'\n"
      << "\t ADJUST_FOCAL_LENGTH|ADJUST_PRINCIPAL_POINT\n"
      <<      "\t\t-> refine the focal length & the principal point position\n"
      << "\t ADJUST_FOCAL_LENGTH|ADJUST_DISTORTION\n"
      <<      "\t\t-> refine the focal length & the distortion coefficient(s) (if any)\n"
      << "\t ADJUST_PRINCIPAL_POINT|ADJUST_DISTORTION\n"
      <<      "\t\t-> refine the principal point position & the distortion coefficient(s) (if any)\n"
    << "[-e|--refine_extrinsic_config] Extrinsic parameters refinement option\n"
      << "\t ADJUST_ALL -> refine all existing parameters (default) \n"
      << "\t NONE -> extrinsic parameters are held as constant\n"
    << "[-P|--prior_usage] Enable usage of motion priors (i.e GPS positions) (default: false)\n"
    << "\n\n"
    << "[Engine specifics]\n"
    << "\n\n"
    << "[INCREMENTAL]\n"
    << "\t[-a|--initial_pair_a] filename of the first image (without path)\n"
    << "\t[-b|--initial_pair_b] filename of the second image (without path)\n"
    << "\t[-c|--camera_model] Camera model type for view with unknown intrinsic:\n"
      << "\t\t 1: Pinhole \n"
      << "\t\t 2: Pinhole radial 1\n"
      << "\t\t 3: Pinhole radial 3 (default)\n"
      << "\t\t 4: Pinhole radial 3 + tangential 2\n"
      << "\t\t 5: Pinhole fisheye\n"
    << "\t[--triangulation_method] triangulation method (default=" << triangulation_method << "):\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::DIRECT_LINEAR_TRANSFORM) << ": DIRECT_LINEAR_TRANSFORM\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::L1_ANGULAR) << ": L1_ANGULAR\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::LINFINITY_ANGULAR) << ": LINFINITY_ANGULAR\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::INVERSE_DEPTH_WEIGHTED_MIDPOINT) << ": INVERSE_DEPTH_WEIGHTED_MIDPOINT\n"
    << "\t[--resection_method] resection/pose estimation method (default=" << resection_method << "):\n"
    << "\t\t" << static_cast<int>(resection::SolverType::DLT_6POINTS) << ": DIRECT_LINEAR_TRANSFORM 6Points | does not use intrinsic data\n"
    << "\t\t" << static_cast<int>(resection::SolverType::P3P_KE_CVPR17) << ": P3P_KE_CVPR17\n"
    << "\t\t" << static_cast<int>(resection::SolverType::P3P_KNEIP_CVPR11) << ": P3P_KNEIP_CVPR11\n"
    << "\t\t" << static_cast<int>(resection::SolverType::P3P_NORDBERG_ECCV18) << ": P3P_NORDBERG_ECCV18\n"
    << "\t\t" << static_cast<int>(resection::SolverType::UP2P_KUKELOVA_ACCV10)  << ": UP2P_KUKELOVA_ACCV10 | 2Points | upright camera\n"
    << "\n\n"
    << "[INCREMENTALV2]\n"
    << "\t[-S|--sfm_initializer] Choose the SfM initializer method:\n"
      << "\t\t 'EXISTING_POSE'-> Initialize the reconstruction from the existing sfm_data camera poses\n"
      << "\t\t 'MAX_PAIR'-> Initialize the reconstruction from the pair that has the most of matches\n"
      << "\t\t 'AUTO_PAIR'-> Initialize the reconstruction with a pair selected automatically\n"
      << "\t\t 'STELLAR'-> Initialize the reconstruction with a 'stellar' reconstruction\n"
    << "\t[-c|--camera_model] Camera model type for view with unknown intrinsic:\n"
      << "\t\t 1: Pinhole \n"
      << "\t\t 2: Pinhole radial 1\n"
      << "\t\t 3: Pinhole radial 3 (default)\n"
      << "\t\t 4: Pinhole radial 3 + tangential 2\n"
      << "\t\t 5: Pinhole fisheye\n"
    << "\t[--triangulation_method] triangulation method (default=" << triangulation_method << "):\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::DIRECT_LINEAR_TRANSFORM) << ": DIRECT_LINEAR_TRANSFORM\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::L1_ANGULAR) << ": L1_ANGULAR\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::LINFINITY_ANGULAR) << ": LINFINITY_ANGULAR\n"
    << "\t\t" << static_cast<int>(ETriangulationMethod::INVERSE_DEPTH_WEIGHTED_MIDPOINT) << ": INVERSE_DEPTH_WEIGHTED_MIDPOINT\n"
    << "\t[--resection_method] resection/pose estimation method (default=" << resection_method << "):\n"
    << "\t\t" << static_cast<int>(resection::SolverType::DLT_6POINTS) << ": DIRECT_LINEAR_TRANSFORM 6Points | does not use intrinsic data\n"
    << "\t\t" << static_cast<int>(resection::SolverType::P3P_KE_CVPR17) << ": P3P_KE_CVPR17\n"
    << "\t\t" << static_cast<int>(resection::SolverType::P3P_KNEIP_CVPR11) << ": P3P_KNEIP_CVPR11\n"
    << "\t\t" << static_cast<int>(resection::SolverType::P3P_NORDBERG_ECCV18) << ": P3P_NORDBERG_ECCV18\n"
    << "\t\t" << static_cast<int>(resection::SolverType::UP2P_KUKELOVA_ACCV10)  << ": UP2P_KUKELOVA_ACCV10 | 2Points | upright camera\n"
    << "\n\n"
    << "[GLOBAL]\n"
    << "\t[-r|--rotationAveraging]\n"
      << "\t\t 1 -> L1 minimization\n"
      << "\t\t 2 -> L2 minimization (default)\n"
    << "\t[-t|--translationAveraging]:\n"
      << "\t\t 1 -> L1 minimization\n"
      << "\t\t 2 -> L2 minimization of sum of squared Chordal distances\n"
      << "\t\t 3 -> SoftL1 minimization (default)\n";

    OPENMVG_LOG_ERROR << s;
    return EXIT_FAILURE;
  }

  b_use_motion_priors = cmd.used('P');

  // Check validity of command line parameters:
  if ( !isValid(static_cast<ETriangulationMethod>(triangulation_method))) {
    OPENMVG_LOG_ERROR << "Invalid triangulation method";
    return EXIT_FAILURE;
  }

  if ( !isValid(openMVG::cameras::EINTRINSIC(user_camera_model)) )  {
    OPENMVG_LOG_ERROR << "Invalid camera type";
    return EXIT_FAILURE;
  }

  const cameras::Intrinsic_Parameter_Type intrinsic_refinement_options =
    cameras::StringTo_Intrinsic_Parameter_Type(sIntrinsic_refinement_options);
  if (intrinsic_refinement_options == static_cast<cameras::Intrinsic_Parameter_Type>(0) )
  {
    OPENMVG_LOG_ERROR << "Invalid input for Bundle Adjustment Intrinsic parameter refinement option";
    return EXIT_FAILURE;
  }

   const sfm::Extrinsic_Parameter_Type extrinsic_refinement_options =
    sfm::StringTo_Extrinsic_Parameter_Type(sExtrinsic_refinement_options);
  if (extrinsic_refinement_options == static_cast<sfm::Extrinsic_Parameter_Type>(0) )
  {
    OPENMVG_LOG_ERROR << "Invalid input for the Bundle Adjustment Extrinsic parameter refinement option";
    return EXIT_FAILURE;
  }

  ESfMSceneInitializer scene_initializer_enum;
  if (!StringToEnum(sfm_initializer_method, scene_initializer_enum))
  {
    OPENMVG_LOG_ERROR << "Invalid input for the SfM initializer option";
    return EXIT_FAILURE;
  }

  ESfMEngine sfm_engine_type;
  if (!StringToEnum(engine_name, sfm_engine_type))
  {
    OPENMVG_LOG_ERROR << "Invalid input for the SfM Engine type";
    return EXIT_FAILURE;
  }

  if (rotation_averaging_method < ROTATION_AVERAGING_L1 ||
      rotation_averaging_method > ROTATION_AVERAGING_L2 )  {
    OPENMVG_LOG_ERROR << "Rotation averaging method is invalid";
    return EXIT_FAILURE;
  }

  if (translation_averaging_method < TRANSLATION_AVERAGING_L1 ||
      translation_averaging_method > TRANSLATION_AVERAGING_SOFTL1 )  {
    OPENMVG_LOG_ERROR << "Translation averaging method is invalid";
    return EXIT_FAILURE;
  }

  if (directory_output.empty())  {
    OPENMVG_LOG_ERROR << "It is an invalid output directory";
    return EXIT_FAILURE;
  }
  //跟之前一样，读取SFM场景数据
  SfM_Data sfm_data;
  const ESfM_Data sfm_data_loading_etypes =
    scene_initializer_enum == ESfMSceneInitializer::INITIALIZE_EXISTING_POSES ?
      ESfM_Data(VIEWS|INTRINSICS|EXTRINSICS) : ESfM_Data(VIEWS|INTRINSICS);
  if (!Load(sfm_data, filename_sfm_data, sfm_data_loading_etypes)) {
    OPENMVG_LOG_ERROR << "The input SfM_Data file \""<< filename_sfm_data << "\" cannot be read.";
    return EXIT_FAILURE;
  }

  if (!stlplus::folder_exists(directory_output))
  {
    if (!stlplus::folder_create(directory_output))
    {
      OPENMVG_LOG_ERROR << "Cannot create the output directory";
      return EXIT_FAILURE;
    }
  }
 //读取特征
  if (directory_match.empty() && !filename_match.empty() && stlplus::file_exists(filename_match))
  {
    directory_match = stlplus::folder_part(filename_match);
    filename_match = stlplus::filename_part(filename_match);
  }

  using namespace openMVG::features;
  const std::string sImage_describer = stlplus::create_filespec(directory_match, "image_describer", "json");
  std::unique_ptr<Regions> regions_type = Init_region_type_from_file(sImage_describer);
  if (!regions_type)
  {
    OPENMVG_LOG_ERROR << "Invalid: " << sImage_describer << " regions type file.";
    return EXIT_FAILURE;
  }

  std::shared_ptr<Features_Provider> feats_provider = std::make_shared<Features_Provider>();
  if (!feats_provider->load(sfm_data, directory_match, regions_type)) {
    OPENMVG_LOG_ERROR << "Cannot load view corresponding features in directory: " << directory_match << ".";
    return EXIT_FAILURE;
  }
  // 读取匹配
  std::shared_ptr<Matches_Provider> matches_provider = std::make_shared<Matches_Provider>();
  if // Try to read the provided match filename or the default one (matches.f.txt/bin)
  (
    !(matches_provider->load(sfm_data, stlplus::create_filespec(directory_match, filename_match)) ||
      matches_provider->load(sfm_data, stlplus::create_filespec(directory_match, "matches.f.txt")) ||
      matches_provider->load(sfm_data, stlplus::create_filespec(directory_match, "matches.f.bin")) ||
      matches_provider->load(sfm_data, stlplus::create_filespec(directory_match, "matches.e.txt")) ||
      matches_provider->load(sfm_data, stlplus::create_filespec(directory_match, "matches.e.bin")))
  )
  {
    OPENMVG_LOG_ERROR << "Cannot load the match file.";
    return EXIT_FAILURE;
  }
  //场景初始化器
  std::unique_ptr<SfMSceneInitializer> scene_initializer;
  switch(scene_initializer_enum)
  {
    case ESfMSceneInitializer::INITIALIZE_AUTO_PAIR:
      OPENMVG_LOG_ERROR << "Not yet implemented.";
      return EXIT_FAILURE;
    break;
    case ESfMSceneInitializer::INITIALIZE_MAX_PAIR:
      scene_initializer.reset(new SfMSceneInitializerMaxPair(sfm_data,
        feats_provider.get(),
        matches_provider.get()));
    break;
    case ESfMSceneInitializer::INITIALIZE_EXISTING_POSES:
      scene_initializer.reset(new SfMSceneInitializer(sfm_data,
        feats_provider.get(),
        matches_provider.get()));
    break;
    case ESfMSceneInitializer::INITIALIZE_STELLAR:
      scene_initializer.reset(new SfMSceneInitializerStellar(sfm_data,
        feats_provider.get(),
        matches_provider.get()));
    break;
    default:
      OPENMVG_LOG_ERROR << "Unknown SFM Scene initializer method";
      return EXIT_FAILURE;
  }
  if (!scene_initializer)
  {
    OPENMVG_LOG_ERROR << "Invalid scene initializer.";
    return EXIT_FAILURE;
  }

 //SFM引擎，前面都是数据准备部分，INCREMENTAL，INCREMENTALV2，GLOBAL版本
  std::unique_ptr<ReconstructionEngine> sfm_engine;
  switch (sfm_engine_type)
  {
  case ESfMEngine::INCREMENTAL:
  {
    SequentialSfMReconstructionEngine * engine =
      new SequentialSfMReconstructionEngine(
        sfm_data,
        directory_output,
        stlplus::create_filespec(directory_output, "Reconstruction_Report.html"));

    // Configuration:
    engine->SetFeaturesProvider(feats_provider.get());
    engine->SetMatchesProvider(matches_provider.get());

    // Configure reconstruction parameters
    engine->SetUnknownCameraType(EINTRINSIC(user_camera_model));
    engine->Set_Use_Motion_Prior(b_use_motion_priors);
    engine->SetTriangulationMethod(static_cast<ETriangulationMethod>(triangulation_method));
    engine->SetResectionMethod(static_cast<resection::SolverType>(resection_method));

    // Handle Initial pair parameter
    if (!initial_pair_string.first.empty() && !initial_pair_string.second.empty())
    {
      Pair initial_pair_index;
      if (!computeIndexFromImageNames(sfm_data, initial_pair_string, initial_pair_index))
      {
          OPENMVG_LOG_ERROR << "Could not find the initial pairs <" << initial_pair_string.first
            <<  ", " << initial_pair_string.second << ">!";
        return EXIT_FAILURE;
      }
      engine->setInitialPair(initial_pair_index);
    }

    sfm_engine.reset(engine);
  }
    break;
  case ESfMEngine::INCREMENTALV2:
  {
    SequentialSfMReconstructionEngine2 * engine =
      new SequentialSfMReconstructionEngine2(
        scene_initializer.get(),
        sfm_data,
        directory_output,
        stlplus::create_filespec(directory_output, "Reconstruction_Report.html"));

    // Configuration:
    engine->SetFeaturesProvider(feats_provider.get());
    engine->SetMatchesProvider(matches_provider.get());

    // Configure reconstruction parameters
    engine->Set_Intrinsics_Refinement_Type(intrinsic_refinement_options);
    engine->SetUnknownCameraType(EINTRINSIC(user_camera_model));
    engine->Set_Use_Motion_Prior(b_use_motion_priors);
    engine->SetTriangulationMethod(static_cast<ETriangulationMethod>(triangulation_method));
    engine->SetResectionMethod(static_cast<resection::SolverType>(resection_method));

    sfm_engine.reset(engine);
  }
  break;
  case ESfMEngine::GLOBAL:
  {
    GlobalSfMReconstructionEngine_RelativeMotions * engine =
      new GlobalSfMReconstructionEngine_RelativeMotions(
        sfm_data,
        directory_output,
        stlplus::create_filespec(directory_output, "Reconstruction_Report.html"));

    // Configuration:
    engine->SetFeaturesProvider(feats_provider.get());
    engine->SetMatchesProvider(matches_provider.get());

    // Configure reconstruction parameters
    engine->Set_Intrinsics_Refinement_Type(intrinsic_refinement_options);
    engine->Set_Use_Motion_Prior(b_use_motion_priors);

    // Configure motion averaging method
    engine->SetRotationAveragingMethod(ERotationAveragingMethod(rotation_averaging_method));
    engine->SetTranslationAveragingMethod(ETranslationAveragingMethod(translation_averaging_method));

    sfm_engine.reset(engine);
  }
  break;
  default:
    break;
  }
  if (!sfm_engine)
  {
    OPENMVG_LOG_ERROR << "Cannot create the requested SfM Engine.";
    return EXIT_FAILURE;
  }

  sfm_engine->Set_Intrinsics_Refinement_Type(intrinsic_refinement_options);
  sfm_engine->Set_Extrinsics_Refinement_Type(extrinsic_refinement_options);

  //---------------------------------------
  // Sequential reconstruction process
  //---------------------------------------

  openMVG::system::Timer timer;

  if (sfm_engine->Process())
  {
    OPENMVG_LOG_INFO << " Total Sfm took (s): " << timer.elapsed();

    OPENMVG_LOG_INFO << "...Generating SfM_Report.html";
    Generate_SfM_Report(sfm_engine->Get_SfM_Data(),
      stlplus::create_filespec(directory_output, "SfMReconstruction_Report.html"));

    //-- Export to disk computed scene (data & viewable results)
    OPENMVG_LOG_INFO << "...Export SfM_Data to disk.";
    Save(sfm_engine->Get_SfM_Data(),
      stlplus::create_filespec(directory_output, "sfm_data", ".bin"),
      ESfM_Data(ALL));

    Save(sfm_engine->Get_SfM_Data(),
      stlplus::create_filespec(directory_output, "cloud_and_poses", ".ply"),
      ESfM_Data(ALL));

    return EXIT_SUCCESS;
  }
  return EXIT_FAILURE;
}
小郑不学习
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenCV3.0实现SfM双目三维重建.zip
05-03
OpenCV3.0实现SfM双目三维重建,代码是用VS2013写的，OpenCV版本为3.0且包含扩展部分，如果不使用SIFT特征，可以修改源代码，然后使用官方未包含扩展部分的库。软件运行后会将三维重建的结果写入Viewer目录下的...
最新OpenMVG编译安装与逐命令运行增量式和全局式SfM教程（文末附自动化运行脚本）
zeeq的博客
02-24 1801
openmvg是一个轻便的可以逐步运行的SfM开源库，它同时实现了增量式和全局式两种算法。
增量式SfM详细流程介绍及实现方法
zeeq的博客
12-12 1万+
目前主流的SfM（Structure from Motion，运动结构恢复）可以分为两大类型，一种是全局式的，一种是增量式的。全局式sfm能够一次性得出所有的相机姿态和场景点结构。它通常先求得所有相机的位姿，然后再通过三角化获得场景点。其效率较高，但是其鲁棒性差，很容易受到outlier的影响而导致重建失败。增量式sfm则是一边三角化（triangulation）和pnp（perspective-n-points），一边进行局部BA。这类方法在每次添加图像后都要进行一次BA，效率较低，而且由于误差累积，容易
SFM图像三维重建（二）
禾羽木的学习记录
03-24 6854
openMVG/openMVS/bundler基于SFM的图像三维重建（二）Linux下使用openMVG+PMVS进行三维重建1. openMVG简介2. 过程与结果1.安装openMVG2.安装PMVS-CMVS3.使用openmvg例程进行三维重建4.使用自己的图片做出来的实验效果。 SFM图像三维重建（一）的地址：https://blog.csdn.net/abccc250110119/a...
SFM（Structure from Motion）一点总结
热门推荐
Z5122的博客
11-22 2万+
SFM（Structure from Motion）一点总结 运动结构恢复(Structure from motion)数十年来一直是计算机视觉领域的热门研究方向之一，实现了众多实际应用，尤其在近景三维重建中，该算法从获取的目标物系列影像出发，最终获取较高精度的目标物稀疏三维点云。 简介 运动结构恢复(Structure from motion)，即给出多幅图像及其图像特征的一个稀疏对应集合，估计...
SFM系列压电式蜂鸣器.pdf-综合文档
05-25
SFM系列压电式蜂鸣器.pdf
SFM系列压电式蜂鸣器.docx-综合文档
05-25
SFM系列压电式蜂鸣器.docx
SFM系列压电式蜂鸣器.zip-综合文档
05-20
SFM系列压电式蜂鸣器.zip
SFM系列压电式蜂鸣器.rar-综合文档
05-10
SFM系列压电式蜂鸣器.rar
夜晚也清晰可见！ContextualFusion技术突破传统传感器限制，3D对象检测性能显著提升
math_bearrr的博客
05-08 859
1. 模型概述ContextualFusion是一个多传感器融合模型，专为在恶劣操作条件下进行3D对象检测而设计。该模型利用环境上下文信息，通过智能地分配激光雷达和摄像头模态在不同光照和雨天条件下的重要性，显著提高感知性能。例如，在夜间或低光照条件下，ContextualFusion能够准确地检测到激光雷达和摄像头视图中都可见的车辆，而现有的一些基于摄像头的方法则无法做到。2. 3D对象检测。
NX/UG二次开发—3D几何—多边形内部最大圆
门前大桥下，游过一群鸭，快来看一看，原来是C++
05-11 399
最后注意，随着边界的BOX尺寸变化，运行时间变化较大，因此需要对二维矩阵点位进行尺寸归一，这样运算速度变化就不会太大了，尺寸归一会导致尺寸大的模型缩小时的细节特征丢失。如果正方形或正凸多边形，最大内部圆是与边相切的，但对于不规则多边形，很多情况是正好经过一些凹点。6、在最接近点周围取点迭代，直到找到在设置好的公差内的点：参考如下博客。2、离散曲线，按顺序取点，注意直线段只取一个点，防止增加运算次数。5、计算点到多边形的距离，找到最接近点：参考如下博客。3、以封闭边界平面为参考，创建二维矩阵，即方块格子。
面向电商家居行业3D室内场景合成中的空间感知
淘系技术
05-10 453
本文主要介绍了3D场景合成技术在电商领域，尤其是家居家装行业的应用。它解释了如何使用3D场景合成创建逼真的室内设计，让消费者能够交互式地查看和体验产品，提高购物的趣味性和效率。文章提到了两种主要的3D室内场景生成算法：传统方法和深度学习方法，并着重介绍了如何通过空间感知和物理约束、功能约束以及美学认知来优化家具布局。此外，文章还讨论了在3D场景中处理碰撞检测、漂浮问题、通行区域和家具访问空间的重要...
HOOPS Visualize：工业级3D可视化SDK，打造移动端和PC端工程应用程序
Juvien_Huang的博客
05-08 1070
HOOPS Visualize具有强大的渲染能力、跨平台支持、丰富的交互功能、高度定制化和快速部署等主要功能，为开发人员提供了丰富的工具和解决方案，助力他们构建高质量、高性能的3D可视化应用。
【文献解析】3D高斯抛雪球是个什么玩意
HUASHUDEYANJING的博客
05-08 571
辐射场：辐射场是三维空间中光分布的表示，它捕捉光如何与环境中的表面和材料相互作用。显式辐射场：相反，显式辐射场直接表示离散空间结构中的光分布，隐式辐射场：隐式辐射场表示场景中的光分布，而不明确定义场景的几何体。显式表达方法（点、网格、体素）的连续性质有助于优化，但渲染所需的随机采样成本高昂，并且可能会导致噪声。隐式表达（NeRF）耗费计算资源巨大，运行速度慢。3D GS 表示从隐式辐射场到显式辐射场的转变。它通过利用3D高斯作为灵活高效的表示，利用了这两种方法的优势。
3D轻量化引擎HOOPS Communicator在PLM全生命周期管理中的应用
最新发布
Juvien_Huang的博客
05-14 720
HOOPS Communicator作为3D轻量化引擎，在PLM全生命周期管理中的应用，不仅提高了数据的处理效率，还优化了用户体验。通过其强大的功能和灵活性，HOOPS Communicator正在成为工业领域中不可或缺的工具，助力企业实现数字化转型和持续创新。
CAXA 3D实体设计2024：塑造未来的创新引擎
2401_82627223的博客
05-07 309
CAXA 3D实体设计2024是一款功能强大、易于使用且富有创新性的3D CAD实体建模设计软件。
如何用多个高斯泼溅合成新的场景【3DGS】
新缸中之脑
05-08 780
3D高斯泼溅（3D Gaussian Splatting）作为一种突破性摄影测量和可视化技术作为 SIGGRAPH 2023 上发表的研究论文的一部分发布。我相信3DGS是允许像你我这样的日常用户扫描 3D 的最佳现代方法并保留有机材料的精细细节，尤其是植物、树木、花卉和其他自然元素——所有我们希望在街道上看到更多的东西！这仍然是一个研发项目，尚未成为 3DStreet 支持的内置功能。
3d中如何对模型粉碎处理？---模大狮模型网
modashi3dmax的博客
05-08 359
通过使用碎片化插件、利用物理引擎或手动建模和动画，您可以轻松地实现模型的粉碎处理，为您的作品注入活力和创意。掌握这些方法，将帮助您打造出令人惊叹的3D场景，吸引观众的眼球，为您的项目带来更多的关注和赞誉。在3D建模和动画设计中，模型粉碎处理是一种引人注目的效果，可以为场景增添动态和震撼的视觉效果。通过分解模型、添加碎裂效果和创建相应的动画，您可以完全控制模型粉碎的过程，创造出独特的视觉效果。通过简单的操作和调整参数，您就可以轻松地实现模型的粉碎处理，为您的作品增添动感和戏剧性。
openmvg sfm
09-24
OpenMVG是一个用于结构从运动（Structure from Motion，简称SfM）的开源库。它提供了处理SfM相关数据的存储和解决SfM问题的方法，包括相机位姿估计、结构三角重构和捆集调整等。在OpenMVG中，SfM数据被存储在一个通用的数据容器中，可以通过使用该库提供的函数和类进行处理和操作。 想获取OpenMVG的源代码可以从官方网站https://github.com/openMVG/openMVG下载。 OpenMVG提供了一个通用的捆集调整（Bundle Adjustment，简称BA）框架，可以对相机内部参数（内部方位参数，即相机投影模型）、相机外部参数（外部方位参数，即相机位姿）和结构（三维点）进行改进或保持不变。在使用OpenMVG进行BA时，首先初始化SfM数据，然后通过调用Bundle_Adjustment类的对象进行捆集调整。最后，可以计算调整前后的残差（RMSE）来评估调整的效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值