软件步骤5：OpenMVG匹配对几何验证

已于 2024-04-24 19:43:13 修改
阅读量220 收藏
点赞数 3
分类专栏： 3D Vison 文章标签： 3d 计算机视觉
于 2024-04-24 14:28:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48465302/article/details/138157966
版权

基于图像的外观匹配后，我们可以得到初始的匹配结果。然而由于图像局部相似性，可能会导致出现部分错误匹配对，这些匹配对会对后续的运动估计产生较大的影响：最直接的是引入外点，导致运动估计的误差增大，同时使三维重建的耗时增加，并且重建结果很不理想。

因此在初始匹配后，我们通常会采用几何验证的方法过滤部分不满足几何约束的匹配对。最最常见的策略是使用RANSAC，通过随机采样后估计运动模型，并用剩余的非采样点验证模型可靠性，若模型满足约束，则保留所有满足误差约束的匹配对，实现几何过滤。
在这里插入图片描述过滤之后的邻接矩阵
在这里插入图片描述过滤之后的邻接图

#include "openMVG/features/akaze/image_describer_akaze.hpp"
#include "openMVG/features/descriptor.hpp"
#include "openMVG/features/feature.hpp"
#include "openMVG/graph/graph.hpp"
#include "openMVG/graph/graph_stats.hpp"
#include "openMVG/matching/indMatch.hpp"
#include "openMVG/matching/indMatch_utils.hpp"
#include "openMVG/matching/pairwiseAdjacencyDisplay.hpp"
#include "openMVG/matching_image_collection/Cascade_Hashing_Matcher_Regions.hpp"
#include "openMVG/matching_image_collection/E_ACRobust.hpp"
#include "openMVG/matching_image_collection/E_ACRobust_Angular.hpp"
#include "openMVG/matching_image_collection/Eo_Robust.hpp"
#include "openMVG/matching_image_collection/F_ACRobust.hpp"
#include "openMVG/matching_image_collection/GeometricFilter.hpp"
#include "openMVG/matching_image_collection/H_ACRobust.hpp"
#include "openMVG/matching_image_collection/Matcher_Regions.hpp"
#include "openMVG/matching_image_collection/Pair_Builder.hpp"
#include "openMVG/sfm/pipelines/sfm_features_provider.hpp"
#include "openMVG/sfm/pipelines/sfm_regions_provider.hpp"
#include "openMVG/sfm/pipelines/sfm_regions_provider_cache.hpp"
#include "openMVG/sfm/sfm_data.hpp"
#include "openMVG/sfm/sfm_data_io.hpp"
#include "openMVG/stl/stl.hpp"
#include "openMVG/system/timer.hpp"

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

#include <cstdlib>
#include <iostream>
#include <locale>
#include <memory>
#include <string>

using namespace openMVG;
using namespace openMVG::matching;
using namespace openMVG::robust;
using namespace openMVG::sfm;
using namespace openMVG::matching_image_collection;

//几何模型选择
enum EGeometricModel
{
  FUNDAMENTAL_MATRIX       = 0,
  ESSENTIAL_MATRIX         = 1,
  HOMOGRAPHY_MATRIX        = 2,
  ESSENTIAL_MATRIX_ANGULAR = 3,
  ESSENTIAL_MATRIX_ORTHO   = 4,
  ESSENTIAL_MATRIX_UPRIGHT = 5
};

int main( int argc, char** argv )
{
  CmdLine cmd;

  // The scene
  std::string sSfM_Data_Filename;
  // The input matches
  std::string sPutativeMatchesFilename;
  // The output matches
  std::string sFilteredMatchesFilename;
  // The input pairs
  std::string sInputPairsFilename;
  // The output pairs
  std::string sOutputPairsFilename;

  std::string  sGeometricModel   = "f";
  bool         bForce            = false;
  bool         bGuided_matching  = false;
  int          imax_iteration    = 2048;
  unsigned int ui_max_cache_size = 0;

  //required
  cmd.add( make_option( 'i', sSfM_Data_Filename, "input_file" ) );
  cmd.add( make_option( 'o', sFilteredMatchesFilename, "output_file" ) );
  cmd.add( make_option( 'm', sPutativeMatchesFilename, "matches" ) );
  // Options
  cmd.add( make_option( 'p', sInputPairsFilename, "input_pairs" ) );
  cmd.add( make_option( 's', sOutputPairsFilename, "output_pairs" ) );
  cmd.add( make_option( 'g', sGeometricModel, "geometric_model" ) );
  cmd.add( make_option( 'f', bForce, "force" ) );
  cmd.add( make_option( 'r', bGuided_matching, "guided_matching" ) );
  cmd.add( make_option( 'I', imax_iteration, "max_iteration" ) );
  cmd.add( make_option( 'c', ui_max_cache_size, "cache_size" ) );

  try
  {
    if ( argc == 1 )
      throw std::string( "Invalid command line parameter." );
    cmd.process( argc, argv );
  }
  catch ( const std::string& s )
  {
    OPENMVG_LOG_INFO << "Usage: " << argv[0] << '\n'
                     << "[-i|--input_file]       A SfM_Data file\n"
                     << "[-m|--matches]          (Input) matches filename\n"
                     << "[-o|--output_file]      (Output) filtered matches filename\n"
                     << "\n[Optional]\n"
                     << "[-p|--input_pairs]      (Input) pairs filename\n"
                     << "[-s|--output_pairs]     (Output) filtered pairs filename\n"
                     << "[-f|--force]            Force to recompute data\n"
                     << "[-g|--geometric_model]\n"
                     << "  (pairwise correspondences filtering thanks to robust model estimation):\n"
                     << "   f: (default) fundamental matrix,\n"
                     << "   e: essential matrix,\n"
                     << "   h: homography matrix.\n"
                     << "   a: essential matrix with an angular parametrization,\n"
                     << "   u: upright essential matrix with an angular parametrization,\n"
                     << "   o: orthographic essential matrix.\n"
                     << "[-r|--guided_matching]  Use the found model to improve the pairwise correspondences.\n"
                     << "[-c|--cache_size]\n"
                     << "  Use a regions cache (only cache_size regions will be stored in memory)\n"
                     << "  If not used, all regions will be load in memory.";

    OPENMVG_LOG_INFO << s;
    return EXIT_FAILURE;
  }

  OPENMVG_LOG_INFO << " You called : "
                   << "\n"
                   << argv[0] << "\n"
                   << "--input_file:        " << sSfM_Data_Filename << "\n"
                   << "--matches:           " << sPutativeMatchesFilename << "\n"
                   << "--output_file:       " << sFilteredMatchesFilename << "\n"
                   << "Optional parameters: "
                   << "\n"
                   << "--input_pairs        " << sInputPairsFilename << "\n"
                   << "--output_pairs       " << sOutputPairsFilename << "\n"
                   << "--force              " << (bForce ? "true" : "false") << "\n"
                   << "--geometric_model    " << sGeometricModel << "\n"
                   << "--guided_matching    " << bGuided_matching << "\n"
                   << "--cache_size         " << ((ui_max_cache_size == 0) ? "unlimited" : std::to_string(ui_max_cache_size));

  if ( sFilteredMatchesFilename.empty() )
  {
    OPENMVG_LOG_ERROR << "It is an invalid output file";
    return EXIT_FAILURE;
  }
  if ( sSfM_Data_Filename.empty() )
  {
    OPENMVG_LOG_ERROR << "It is an invalid SfM file";
    return EXIT_FAILURE;
  }
  if ( sPutativeMatchesFilename.empty() )
  {
    OPENMVG_LOG_ERROR << "It is an invalid putative matche file";
    return EXIT_FAILURE;
  }

  const std::string sMatchesDirectory = stlplus::folder_part( sPutativeMatchesFilename );

  EGeometricModel eGeometricModelToCompute = FUNDAMENTAL_MATRIX;
  switch ( std::tolower(sGeometricModel[ 0 ], std::locale()) )
  {
    case 'f':
      eGeometricModelToCompute = FUNDAMENTAL_MATRIX;
      break;
    case 'e':
      eGeometricModelToCompute = ESSENTIAL_MATRIX;
      break;
    case 'h':
      eGeometricModelToCompute = HOMOGRAPHY_MATRIX;
      break;
    case 'a':
      eGeometricModelToCompute = ESSENTIAL_MATRIX_ANGULAR;
      break;
    case 'u':
      eGeometricModelToCompute = ESSENTIAL_MATRIX_UPRIGHT;
      break;
    case 'o':
      eGeometricModelToCompute = ESSENTIAL_MATRIX_ORTHO;
      break;
    default:
      OPENMVG_LOG_ERROR << "Unknown geometric model";
      return EXIT_FAILURE;
  }

  // -----------------------------
  // - Load SfM_Data Views & intrinsics data
  // a. Load putative descriptor matches
  // [a.1] Filter matches with input pairs
  // b. Geometric filtering of putative matches
  // + Export some statistics
  // -----------------------------

  //SFM场景读取
  SfM_Data sfm_data;
  if ( !Load( sfm_data, sSfM_Data_Filename, ESfM_Data( VIEWS | INTRINSICS ) ) )
  {
    OPENMVG_LOG_ERROR << "The input SfM_Data file \"" << sSfM_Data_Filename << "\" cannot be read.";
    return EXIT_FAILURE;
  }

  // 读取特征和描述子
  using namespace openMVG::features;
  // Consider that the image_describer.json is inside the matches directory (which is bellow the sfm_data.bin)
  const std::string        sImage_describer = stlplus::create_filespec( sMatchesDirectory, "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;
  }

  //---------------------------------------
  // a. Compute putative descriptor matches
  //    - Descriptor matching (according user method choice)
  //    - Keep correspondences only if NearestNeighbor ratio is ok
  //---------------------------------------

  // Load the corresponding view regions
  std::shared_ptr<Regions_Provider> regions_provider;
  if ( ui_max_cache_size == 0 )
  {
    // Default regions provider (load & store all regions in memory)
    regions_provider = std::make_shared<Regions_Provider>();
  }
  else
  {
    // Cached regions provider (load & store regions on demand)
    regions_provider = std::make_shared<Regions_Provider_Cache>( ui_max_cache_size );
  }

  // Show the progress on the command line:
  system::LoggerProgress progress;

  if ( !regions_provider->load( sfm_data, sMatchesDirectory, regions_type, &progress ) )
  {
    OPENMVG_LOG_ERROR << "Invalid regions.";
    return EXIT_FAILURE;
  }

  PairWiseMatches map_PutativeMatches;
  //---------------------------------------
  // A. 加载初始匹配关系
  //---------------------------------------
  if ( !Load( map_PutativeMatches, sPutativeMatchesFilename ) )
  {
    OPENMVG_LOG_ERROR << "Failed to load the initial matches file.";
    return EXIT_FAILURE;
  }

  if ( !sInputPairsFilename.empty() )
  {
    // Load input pairs
    OPENMVG_LOG_INFO << "Loading input pairs ...";
    Pair_Set input_pairs;
    loadPairs( sfm_data.GetViews().size(), sInputPairsFilename, input_pairs );

    // Filter matches with the given pairs
    OPENMVG_LOG_INFO << "Filtering matches with the given pairs.";
    map_PutativeMatches = getPairs( map_PutativeMatches, input_pairs );
  }

  //---------------------------------------
  // b. Geometric filtering of putative matches
  //    - A Contrario Estimation of the desired geometric model
  //    - Use an upper bound for the a contrario estimated threshold
  //---------------------------------------

  std::unique_ptr<ImageCollectionGeometricFilter> filter_ptr(
      new ImageCollectionGeometricFilter( &sfm_data, regions_provider ) );

  if ( filter_ptr )
  {
    system::Timer timer;
    const double  d_distance_ratio = 0.6;

    PairWiseMatches map_GeometricMatches;
    switch ( eGeometricModelToCompute )
    {
      case HOMOGRAPHY_MATRIX:
      {
        const bool bGeometric_only_guided_matching = true;
        filter_ptr->Robust_model_estimation(
            GeometricFilter_HMatrix_AC( 4.0, imax_iteration ),
            map_PutativeMatches,
            bGuided_matching,
            bGeometric_only_guided_matching ? -1.0 : d_distance_ratio,
            &progress );
        map_GeometricMatches = filter_ptr->Get_geometric_matches();
      }
      break;
      case FUNDAMENTAL_MATRIX:
      {
        filter_ptr->Robust_model_estimation(
            GeometricFilter_FMatrix_AC( 4.0, imax_iteration ),
            map_PutativeMatches,
            bGuided_matching,
            d_distance_ratio,
            &progress );
        map_GeometricMatches = filter_ptr->Get_geometric_matches();
      }
      break;
      case ESSENTIAL_MATRIX:
      {
        filter_ptr->Robust_model_estimation(
            GeometricFilter_EMatrix_AC( 4.0, imax_iteration ),
            map_PutativeMatches,
            bGuided_matching,
            d_distance_ratio,
            &progress );
        map_GeometricMatches = filter_ptr->Get_geometric_matches();

        //-- Perform an additional check to remove pairs with poor overlap
        std::vector<PairWiseMatches::key_type> vec_toRemove;
        for ( const auto& pairwisematches_it : map_GeometricMatches )
        {
          const size_t putativePhotometricCount = map_PutativeMatches.find( pairwisematches_it.first )->second.size();
          const size_t putativeGeometricCount   = pairwisematches_it.second.size();
          const float  ratio                    = putativeGeometricCount / static_cast<float>( putativePhotometricCount );
          if ( putativeGeometricCount < 50 || ratio < .3f )
          {
            // the pair will be removed
            vec_toRemove.push_back( pairwisematches_it.first );
          }
        }
        //-- remove discarded pairs
        for ( const auto& pair_to_remove_it : vec_toRemove )
        {
          map_GeometricMatches.erase( pair_to_remove_it );
        }
      }
      break;
      case ESSENTIAL_MATRIX_ANGULAR:
      {
        filter_ptr->Robust_model_estimation(
          GeometricFilter_ESphericalMatrix_AC_Angular<false>(4.0, imax_iteration),
          map_PutativeMatches, bGuided_matching, d_distance_ratio, &progress);
        map_GeometricMatches = filter_ptr->Get_geometric_matches();
      }
      break;
      case ESSENTIAL_MATRIX_UPRIGHT:
      {
        filter_ptr->Robust_model_estimation(
          GeometricFilter_ESphericalMatrix_AC_Angular<true>(4.0, imax_iteration),
          map_PutativeMatches, bGuided_matching, d_distance_ratio, &progress);
        map_GeometricMatches = filter_ptr->Get_geometric_matches();
      }
      break;
      case ESSENTIAL_MATRIX_ORTHO:
      {
        filter_ptr->Robust_model_estimation(
            GeometricFilter_EOMatrix_RA( 2.0, imax_iteration ),
            map_PutativeMatches,
            bGuided_matching,
            d_distance_ratio,
            &progress );
        map_GeometricMatches = filter_ptr->Get_geometric_matches();
      }
      break;
    }

    //---------------------------------------
    //-- 导出几何过滤之后的匹配关系
    //---------------------------------------
    if ( !Save( map_GeometricMatches, sFilteredMatchesFilename ) )
    {
      OPENMVG_LOG_ERROR << "Cannot save filtered matches in: " << sFilteredMatchesFilename;
      return EXIT_FAILURE;
    }

    // -- export Geometric View Graph statistics
    graph::getGraphStatistics(sfm_data.GetViews().size(), getPairs(map_GeometricMatches));

    OPENMVG_LOG_INFO << "Task done in (s): " << timer.elapsed();

    //-- export Adjacency matrix
    OPENMVG_LOG_INFO <<  "\n Export Adjacency Matrix of the pairwise's geometric matches";

    PairWiseMatchingToAdjacencyMatrixSVG( sfm_data.GetViews().size(),
                                          map_GeometricMatches,
                                          stlplus::create_filespec( sMatchesDirectory, "GeometricAdjacencyMatrix", "svg" ) );

    const Pair_Set outputPairs = getPairs( map_GeometricMatches );

    //-- export view pair graph once geometric filter have been done
    {
      std::set<IndexT> set_ViewIds;
      std::transform( sfm_data.GetViews().begin(), sfm_data.GetViews().end(), std::inserter( set_ViewIds, set_ViewIds.begin() ), stl::RetrieveKey() );
      graph::indexedGraph putativeGraph( set_ViewIds, outputPairs );
      graph::exportToGraphvizData(
          stlplus::create_filespec( sMatchesDirectory, "geometric_matches" ),
          putativeGraph );
    }

    // Write pairs
    if ( !sOutputPairsFilename.empty() )
    {
      OPENMVG_LOG_INFO << "Saving pairs to: " << sOutputPairsFilename;
      if ( !savePairs( sOutputPairsFilename, outputPairs ) )
      {
        OPENMVG_LOG_ERROR << "Failed to write pairs file";
        return EXIT_FAILURE;
      }
    }
  }
  return EXIT_SUCCESS;
}
小郑不学习
关注
专栏目录
三维匹配_多视图几何三维重建实战系列之COLMAP
weixin_39916520的博客
11-03 836
作者：浩南来源：公众号 @3D视觉工坊链接：多视图几何三维重建实战系列之COLMAP 为了方便大家了解基于多视图立体的三维重建技术，更重要的是能亲手利用开源数据集或者自己采集的影像跑一遍流程，进而对整个流程更为熟悉，本文整理了近年来几种经典的基于传统方法和基于深度学习方法的三维重建技术Pipeline，并详细介绍从多视图影像到深度图估计，再到恢复三维点云的整个过程。因为三维重建原理复杂，且各种软件...
OpenMVG及OpenMVS配置安装包（第二部分）
05-10
OpenMVG（Multiple View Geometry）和OpenMVS（Multiple View Stereo）是两个广泛应用于计算机视觉领域的开源库，专注于三维重建和多视图几何。本文将详细介绍这两个库的配置与安装过程，以及涉及到的关键技术。 ...
匹配几何校验_源代码与参考资料.zip
05-16
数字图像处理（DIA）相关实验，包括matlab的源代码、效果图与论文等参考资料。 任务描述： 1. 给定一对图像，利用提取好的SIFT特征文件，根据距离阈值准则（跨图像的局部SIFT特征距离小于0.4），得到图像间的初始局部特征匹配关系； 2. 基于上述初步匹配结果，实现spatial coding方法，进行匹配校验，确定几何不一致的匹配； 3. 将几何一致的匹配和不一致的匹配在图像上画出来，分别用蓝色和红色进行区分。
openMVG安装&&问题解决
Meteor的笔记
05-29 229
在ubuntu16.04配置openMV，G时报如图错误，我的解决方案是，把libpng16.so.16先删除，然后再编译，成功。(▽)
OpenMVG 安装和配置指南
gitblog_09095的博客
09-13 416
OpenMVG 安装和配置指南 openMVG open Multiple View Geometry library. Basis for 3D computer vision and Structure from Motion. ...
COLMAP进化版：Global Structure-from-Motion Revisited论文粗读（更新中）
m0_74310646的博客
07-31 1105
从图像中恢复 3D 结构和相机运动一直是计算机视觉研究的长期焦点，被称为运动结构 （SfM）。这个问题的解决方案分为渐进式和全局式两种。到目前为止，最受欢迎的系统由于其卓越的准确性和鲁棒性而遵循增量范式，而全局方法的可扩展性和效率大大提高。在这项工作中，我们重新审视了全局 SfM 的问题，并提出 GLOMAP 作为一种新的通用系统，其性能优于全球 SfM 的最新技术。在准确性和稳健性方面，我们实现的结果与COLMAP（使用最广泛的增量SfM）相当或更胜一筹，同时速度快几个数量级。
P-MVSNet：学习多视点立体匹配置信度聚集
10452P-MVSNet：学习多视点立体匹配置信度聚集罗科扬1，关涛1，3，鞠丽丽2，3，黄海鹏3，罗亚伟1*1华中科技大学华中科技大学2南卡罗来纳大学，美国3Farsee2 Technology Ltd，中国{kyluo，qd gt，royalvane}@ hust....
通过迭代动态代价体积实现高效的多视图立体匹配
MVSNetUCS-NetPatchmatchNetOurs(Iters: 3 3 3)Ours(Iters: 1 1 1)86550通过迭代动态代价体积实现高效的多视图立体匹配0邵谦王�李波�戴宇超* 西北工业大学电子与信息学院，中国西安0摘要0在本文中，我们提出了一...
openMVS.zip
07-23
在实际操作中，openMVS首先通过SfM（结构化光谱建模）软件如openMVG获取相机的相对姿态和粗略的三维点云，然后利用这些信息对图像进行多视图立体匹配，生成更精确的深度信息。通过优化和后处理，openMVS能够生成高...
SRT3D: A Sparse Region-Based 3D Object Tracking Approach for the Real World
weixin_45834800的博客
09-13 1037
基于区域的方法在基于模型的单目3D跟踪无纹理物体的复杂场景中变得越来越流行。然而，尽管它们能够实现最先进的结果，大多数方法的计算开销很大，需要大量资源来实时运行。在下文中，我们基于之前的工作，开发了SRT3D，这是一种稀疏的基于区域的3D物体跟踪方法，旨在弥合效率上的差距。我们的方法在所谓的对应线（这些线模型化了物体轮廓位置的概率）上稀疏地考虑图像信息。由此，我们改进了当前的技术，并引入了考虑定义的全局和局部不确定性的平滑阶跃函数。对于所得到的概率公式，提供了详尽的分析。
使用java程序生成具有3D效果的图片
C7211BA的博客
09-11 508
光照效果：使用 RadialGradientPaint 实现径向渐变效果，模拟从图片中心向外扩散的光照，使图片有深度感，营造出三维空间的效果。每个椭圆形的颜色、大小、位置都是随机的，椭圆图形具有立体感的黑色阴影。图像初始化：创建一个800x800像素的 BufferedImage 对象，并使用 Graphics2D 进行绘图操作。文件保存：生成的图片以PNG格式保存，文件名为当前时间戳加上随机数，确保文件名唯一。边缘高光：为每个椭圆的边缘添加半透明的高光线条，模拟光照反射，增强3D视觉效果。
vue3+ts+supermap iclient3d for cesium功能集合
最新发布
2301_77133858的博客
09-14 380
会把各项功能链接放在这。
python绘制3D瀑布图
qq_40292148的博客
09-10 2197
【代码】python绘制3D瀑布图。
3D云渲染农场为何怎么贵？主要消耗成本介绍
Renderbus瑞云渲染的博客
09-12 617
例如，Renderbus瑞云渲染配备了高性能的SSD存储，并且支持Windows、Mac和Linux的多操作系统，保证了令人印象深刻的99.99%的运行时间。渲染农场中的每台机器都必须安装并授权必要的软件以执行云渲染任务。需要不断监控、故障排除和用户协助，这会产生显著的劳动力成本，这些成本通常反映在渲染农场服务的定价中。然而，用户经常想知道为什么渲染农场的价格如此之高，理解背后的原因可以帮助艺术家做出更好的选择。渲染农场的高成本可以归因于从昂贵的硬件和维护费用到软件许可费用和劳动力成本的各种因素。
三维数字图像相关法（3D-DIC）用于复合材料力学性能测试
xtop3d的博客
09-11 816
为助力碳纤维及复合材料产业发展，新拓三维携三维数字图像相关法3D-DIC系列产品方案参展中国（第九届）碳纤维及复合材料技术创新与应用发展论坛。三维数字图像相关法（3D-DIC技术），用于复合材料力学性能测试，可获取全场位移、应变值，弹性模量、泊松比、N值、R值等，分析材料力学变形行为、裂纹扩展、疲劳断裂等。
已开源！无限场景生成和高效数据迁移：3D金字塔扩散模型斩获ECCV24 Oral
soaring_casia的专栏
09-12 1298
扩散模型在生成二维图像和小尺度三维物体方面表现出了显著的效果。然而，它们在合成大规模三维场景中的应用却很少被探索。这主要是因为三维场景数据（尤其是户外场景）固有的复杂性和庞大的规模，以及综合真实世界数据集的有限性，使得训练一个稳定的场景扩散模型是比较困难的。在本工作中，作者探索了如何使用由粗到细的范式有效地生成大规模三维场景，他引入了一个框架，即金字塔离散扩散模型（PDD），该模型采用尺度变化的扩散模型来逐步生成高质量的户外场景。
CesiumJS+SuperMap3D.js混用实现可视域分析 S3M图层加载 裁剪区域绘制
weixin_51983847的博客
09-11 1358
SuperMap技术资源中心|为您提供全面的在线技术服务Cesium：场景初始化、渲染、Bing地图、S3M图层加载。SuperMap3D：可视域分析、S3M图层加载、裁剪区域绘制、Knockout绑定等功能。两者结合：Cesium 提供基础渲染和事件处理，SuperMap3D 提供高级的功能实现。
利用LM-Gaussian增强稀疏视图3D重建：利用大型模型先验实现高质量场景合成
为不同的业务场景定制多个配置，释放创造力，实现个性化需求
09-13 759
总之，LM-Gaussian 提出了一个新颖的稀疏视图3D重建方法，利用了大型视觉模型的先验知识。未来的工作旨在结合动态3DGS方法，潜在地扩展该方法在动态建模中的应用，并进一步提高其在各种3D重建场景中的有效性。如果您正寻找提升企业流量和效能的解决方案，光年AI提供了无代码平台和全方位的支持，是您的理想选择。这一综合方法通过创新的初始化、正则化和细化技术，有效解决了稀疏视图3D重建的难题。LM-Gaussian的引入代表了这一领域的一个新方向，结合大模型先验来提高从有限图像中重建的质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值