colmap 子模型对齐中的 Ransac

这段代码，用 src 和 ref_images 保存 在 src重建和ref 重建中都存在的图像。

重建类包含有关单个重建模型的所有信息。 它由映射和捆绑调整类使用，并且可以写入磁盘和从磁盘读取。重建类中的图像类：
图像类是保存有关图像的信息的类。 图像是在某个位置（参数化为姿势）拍摄的一台相机的产物。 一个图像可以与多个其他图像共享一个相机，如果它的内在特性是相同的

  for (size_t i = 0; i < common_image_ids.size(); ++i) {
    src_images[i] = &src_reconstruction.Image(common_image_ids[i]);
    ref_images[i] = &ref_reconstruction.Image(common_image_ids[i]);
  }

然年调用 ransac 进行两个子模型的对准

  const auto report = ransac.Estimate(src_images, ref_images);

如下是Estimate的参数，可见其只需要两个 图像列表(src_images 和 ref_images)，返回是一个Report（涵盖了模型对其的结果数据和是否成功布尔判断吧应该）

typename LORANSAC<Estimator, LocalEstimator, SupportMeasurer, Sampler>::Report
LORANSAC<Estimator, LocalEstimator, SupportMeasurer, Sampler>::Estimate(
    const std::vector<typename Estimator::X_t>& X,
    const std::vector<typename Estimator::Y_t>& Y) {

下面应该是一些准备工作，num_samples就是采样数，程序中 采样数=两模型共有的图片数，比如共有 10张图 那么ransac就采样10次，ransac应该是估计出满足这10张图片的一个模型，嗯。

 CHECK_EQ(X.size(), Y.size());

  const size_t num_samples = X.size();

  typename RANSAC<Estimator, SupportMeasurer, Sampler>::Report report;
  report.success = false;
  report.num_trials = 0;

  if (num_samples < Estimator::kMinNumSamples) {
    return report;
  }

这边是申请一些变量，变量的含义在注释中

 //最优的模型解
  typename SupportMeasurer::Support best_support;
  typename Estimator::M_t best_model;
  bool best_model_is_local = false;

  bool abort = false;
//最大的残差
  const double max_residual = options_.max_error * options_.max_error;
// 用于存储每个 采样点残差 的数组
  std::vector<double> residuals(num_samples);
// 
  std::vector<typename LocalEstimator::X_t> X_inlier;
  std::vector<typename LocalEstimator::Y_t> Y_inlier;
// 临时的全局 Estimator
  std::vector<typename Estimator::X_t> X_rand(Estimator::kMinNumSamples);
  std::vector<typename Estimator::Y_t> Y_rand(Estimator::kMinNumSamples);
// 采样类的实例化，参数只是一个采样数
  sampler.Initialize(num_samples);
// 确定采样数
  size_t max_num_trials = options_.max_num_trials;
  max_num_trials = std::min<size_t>(max_num_trials, sampler.MaxNumSamples());
  size_t dyn_max_num_trials = max_num_trials;

假如说num_trials为100，意思是进行100轮的ransac估计，下面就是for循环

for (report.num_trials = 0; report.num_trials < max_num_trials;
       ++report.num_trials) {
       // 暂停，跳过一次循环
    if (abort) {
      report.num_trials += 1;
      break;
    }
		// 进行采样，以common images数量为10为例，这里随机采样10个图片吧应该
    sampler.SampleXY(X, Y, &X_rand, &Y_rand);

    // 用采样到的这10张图片，估计模型，怎么估计的，估计的细节是什么在下一个博客
    // 返回不止一个模型，返回一个模型集合 sample_models
    const std::vector<typename Estimator::M_t> sample_models =
        estimator.Estimate(X_rand, Y_rand);
	// 循环选择出最好的
    for (const auto& sample_model : sample_models) {
    // 用模型估计残差，怎么估计，估计的细节在下一个博客
      estimator.Residuals(X, Y, sample_model, &residuals);
      CHECK_EQ(residuals.size(), X.size());
	
      const auto support = support_measurer.Evaluate(residuals, max_residual);
	
      // Do local optimization if better than all previous subsets.
      if (support_measurer.Compare(support, best_support)) {
        //如果当前的模型最优 ↓↓↓↓
        best_support = support;
        best_model = sample_model;
        best_model_is_local = false;

        // Estimate locally optimized model from inliers.
        // Estimator 和 LocalEstimator 应该分别指的是全局的ransac估计和
        // 这10个采样的ransac估计？
        if (support.num_inliers > Estimator::kMinNumSamples &&
            support.num_inliers >= LocalEstimator::kMinNumSamples) {
          X_inlier.clear();
          Y_inlier.clear();
          X_inlier.reserve(support.num_inliers);
          Y_inlier.reserve(support.num_inliers);
          // ransac的策略，如果遇到更好的，就用当前的10张图片为基础，
          // 在这10个的基础上进行估计
          // X_inlier 和 Y_inlier 是更好的采样数据
          // 通过计算内点的数量并对所有内点残差求和来衡量模型的支持度。 
          // 如果它具有更多的内点和更小的残差总和，则此模型为更好
          for (size_t i = 0; i < residuals.size(); ++i) {
            if (residuals[i] <= max_residual) {
              X_inlier.push_back(X[i]);
              Y_inlier.push_back(Y[i]);
            }
          }
		
          const std::vector<typename LocalEstimator::78h> local_models =
              local_estimator.Estimate(X_inlier, Y_inlier);
			//在更好的采样结果上重复筛选操作
          for (const auto& local_model : local_models) {
            local_estimator.Residuals(X, Y, local_model, &residuals);
            CHECK_EQ(residuals.size(), X.size());

            const auto local_support =
                support_measurer.Evaluate(residuals, max_residual);

            // 保存最好的结果
            if (support_measurer.Compare(local_support, best_support)) {
              best_support = local_support;
              best_model = local_model;
              best_model_is_local = true;
            }
          }
        }
		// 调整一下循环次数，优化时间
        dyn_max_num_trials =
            RANSAC<Estimator, SupportMeasurer, Sampler>::ComputeNumTrials(
                best_support.num_inliers, num_samples, options_.confidence,
                options_.dyn_num_trials_multiplier);
      }
		// 特判跳出循环
      if (report.num_trials >= dyn_max_num_trials &&
          report.num_trials >= options_.min_num_trials) {
        abort = true;
        break;
      }
    }
  }