【opencv】示例-stiching_detailed.cpp 使用OpenCV进行图像拼接的整体流程

#include <iostream> // 引入输入输出流库
#include <fstream> // 引入文件流库，用于文件输入输出
#include <string> // 引入字符串库
#include "opencv2/opencv_modules.hpp" // 引入OpenCV模块
#include <opencv2/core/utility.hpp> // 引入OpenCV核心和辅助功能
#include "opencv2/imgcodecs.hpp" // 引入图像编解码模块
#include "opencv2/highgui.hpp" // 引入高级GUI模块，用于展示图片等
#include "opencv2/stitching/detail/autocalib.hpp" // 引入图像缝合细节中的自动校准模块
#include "opencv2/stitching/detail/blenders.hpp" // 引入图像缝合细节中的图像融合模块
#include "opencv2/stitching/detail/timelapsers.hpp" // 引入时间错位模块
#include "opencv2/stitching/detail/camera.hpp" // 引入图像缝合细节中的相机模块
#include "opencv2/stitching/detail/exposure_compensate.hpp" // 引入曝光补偿模块
#include "opencv2/stitching/detail/matchers.hpp" // 引入特征匹配模块
#include "opencv2/stitching/detail/motion_estimators.hpp" // 引入运动估计模块
#include "opencv2/stitching/detail/seam_finders.hpp" // 引入接缝查找模块
#include "opencv2/stitching/detail/warpers.hpp" // 引入图像扭曲模块
#include "opencv2/stitching/warpers.hpp" // 引入图像扭曲模块#ifdef HAVE_OPENCV_XFEATURES2D // 条件编译，检查是否包含特征检测模块
#include "opencv2/xfeatures2d.hpp" // 引入扩展特征检测模块
#include "opencv2/xfeatures2d/nonfree.hpp" // 引入非自由特征检测模块（如SIFT、SURF等）
#endif#define ENABLE_LOG 1 // 定义一个用于控制是否打印日志的宏
#define LOG(msg) std::cout << msg // 定义一个宏，用于输出日志信息到控制台
#define LOGLN(msg) std::cout << msg << std::endl // 定义一个宏，用于输出日志信息到控制台，并换行using namespace std; // 使用标准命名空间
using namespace cv; // 使用OpenCV命名空间
using namespace cv::detail; // 使用OpenCV细节命名空间// 函数printUsage用于打印使用说明
// 打印使用说明
static void printUsage(char** argv)
{cout <<"旋转模型图像拼接器。\n\n"<< argv[0] << " img1 img2 [...imgN] [flags]\n\n""Flags:\n""  --preview\n""      以预览模式运行拼接。比普通模式更快，但输出图像分辨率较低。\n""  --try_cuda (yes|no)\n""      尝试使用CUDA。默认值为'no'。所有默认值均为CPU模式。\n""\n运动估计标志:\n""  --work_megapix <float>\n""      图像配准步骤的分辨率。默认值为0.6百万像素。\n""  --features (surf|orb|sift|akaze)\n""      用于图像匹配的特征类型。\n""      如果可用，默认为surf，否则为orb。\n""  --matcher (homography|affine)\n""      用于两两图像匹配的匹配器。\n""  --estimator (homography|affine)\n""      用于变换估计的估计器类型。\n""  --match_conf <float>\n""      特征匹配步骤的置信度。对于surf，默认值为0.65，对于orb，默认值为0.3。\n""  --conf_thresh <float>\n""      两个图像为同一全景图的置信度阈值。\n""      默认值为1.0。\n""  --ba (no|reproj|ray|affine)\n""      捆绑调整成本函数。默认为ray。\n""  --ba_refine_mask (mask)\n""      为捆绑调整设置细化掩模。格式为'x_xxx'，其中'x'表示细化相应参数，'_'表示不细化，格式如下：\n""      <fx><skew><ppx><aspect><ppy>。默认掩模为'xxxxx'。如果捆绑调整不支持所选参数的估计，则相应标志将被忽略。\n""  --wave_correct (no|horiz|vert)\n""      执行波效果校正。默认为'horiz'。\n""  --save_graph <file_name>\n""      将匹配图保存为DOT语言表示的<file_name>文件。\n""      标签说明：Nm是匹配数，Ni是内点数，C是置信度。\n""\n合成标志:\n""  --warp (affine|plane|cylindrical|spherical|fisheye|stereographic|compressedPlaneA2B1|compressedPlaneA1.5B1|compressedPlanePortraitA2B1|compressedPlanePortraitA1.5B1|paniniA2B1|paniniA1.5B1|paniniPortraitA2B1|paniniPortraitA1.5B1|mercator|transverseMercator)\n""      变换表面类型。默认为'spherical'。\n""  --seam_megapix <float>\n""      接缝估计步骤的分辨率。默认为0.1百万像素。\n""  --seam (no|voronoi|gc_color|gc_colorgrad)\n""      接缝估计方法。默认为'gc_color'。\n""  --compose_megapix <float>\n""      合成步骤的分辨率。使用-1表示原始分辨率。\n""      默认值为-1。\n""  --expos_comp (no|gain|gain_blocks|channels|channels_blocks)\n""      曝光补偿方法。默认为'gain_blocks'。\n""  --expos_comp_nr_feeds <int>\n""      曝光补偿反馈次数。默认为1。\n""  --expos_comp_nr_filtering <int>\n""      曝光补偿增益的过滤迭代次数。仅在使用块曝光补偿方法时使用。\n""      默认为2。\n""  --expos_comp_block_size <int>\n""      曝光补偿器使用的块大小（以像素为单位）。\n""      仅在使用块曝光补偿方法时使用。\n""      默认为32。\n""  --blend (no|feather|multiband)\n""      混合方法。默认为'multiband'。\n""  --blend_strength <float>\n""      混合强度范围为[0,100]。默认值为5。\n""  --output <result_img>\n""      输出图像的文件名。默认为'result.jpg'。\n""  --timelapse (as_is|crop) \n""      将扭曲后的图像单独输出为时间-lapse电影的帧，输入文件名前加上'fixed_'。\n""  --rangewidth <int>\n""      使用range_width限制要匹配的图像数量。\n";
}// 默认的命令行参数
vector<String> img_names; // 存储图像文件名的向量
bool preview = false; // 是否预览模式的标志，默认关闭
bool try_cuda = false; // 是否尝试使用CUDA加速的标志，默认关闭
double work_megapix = 0.6; // 用于图像注册步骤的分辨率，默认为0.6百万像素
double seam_megapix = 0.1; // 用于估算缝合线的图像分辨率，默认为0.1百万像素
double compose_megapix = -1; // 图像融合步骤的分辨率，默认为原始分辨率
float conf_thresh = 1.f; // 配准图像的置信度阈值，默认为1.0
#ifdef HAVE_OPENCV_XFEATURES2D
string features_type = "surf"; // 默认特征类型为SURF，如果库中包含xfeatures2d特征
float match_conf = 0.65f; // 特征匹配的置信度，默认为0.65
#else
string features_type = "orb"; // 不包含xfeatures2d时，默认特征类型为ORB
float match_conf = 0.3f; // ORB特征的匹配置信度，默认为0.3
#endif
string matcher_type = "homography"; // 特征匹配器类型，默认为基于单应性矩阵的匹配器
string estimator_type = "homography"; // 用于变换估计的类型，默认也是单应性
string ba_cost_func = "ray"; // 光束平差(Bundle Adjustment)的代价函数，默认为"ray"
string ba_refine_mask = "xxxxx"; // 光束平差细化掩模，默认对所有参数进行细化
bool do_wave_correct = true; // 是否进行波形校正，默认开启
WaveCorrectKind wave_correct = detail::WAVE_CORRECT_HORIZ; // 波形校正的方向，默认水平方向
bool save_graph = false; // 是否保存图像匹配状态图，默认关闭
std::string save_graph_to; // 保存图像匹配状态图的文件名称
string warp_type = "spherical"; // 进行图像变形的类型，默认为球形变形
int expos_comp_type = ExposureCompensator::GAIN_BLOCKS; // 曝光补偿的类型，默认为gain_blocks
int expos_comp_nr_feeds = 1; // 曝光补偿阶段的输入数，默认为1
int expos_comp_nr_filtering = 2; // 曝光补偿增益的滤波迭代次数，默认为2次
int expos_comp_block_size = 32; // 曝光补偿时块的大小，默认为32像素
string seam_find_type = "gc_color"; // 缝合线发现的方法，默认为基于颜色的图割方法
int blend_type = Blender::MULTI_BAND; // 图像融合的方法，默认为多频段融合
int timelapse_type = Timelapser::AS_IS; // 创建时光延展图像的类型，默认为AS_IS（即原样）
float blend_strength = 5; // 融合的强度，默认值为5
string result_name = "result.jpg"; // 最终生成的全景图像的文件名，默认为result.jpg
bool timelapse = false; // 是否创建时光延展图像，默认为否
int range_width = -1; // 限制匹配图像数量的范围宽度，默认不限制```cpp
// 解析命令行参数的静态函数定义
static int parseCmdArgs(int argc, char** argv)
{// 如果只有一个参数（程序名），打印使用说明并返回-1if (argc == 1){printUsage(argv);return -1;}// 遍历命令行提供的所有参数for (int i = 1; i < argc; ++i){// 如果命令行参数为"--help"或"/?"，打印使用说明并返回-1if (string(argv[i]) == "--help" || string(argv[i]) == "/?"){printUsage(argv);return -1;}// 如果命令行参数为"--preview"，设置预览模式标志为真else if (string(argv[i]) == "--preview"){preview = true;}// 如果命令行参数为"--try_cuda"，根据后续参数选择是否尝试CUDA加速else if (string(argv[i]) == "--try_cuda"){// 根据后续参数的值 ("no" 或 "yes") 设定try_cuda变量if (string(argv[i + 1]) == "no")try_cuda = false;else if (string(argv[i + 1]) == "yes")try_cuda = true;else{cout << "Bad --try_cuda flag value\n"; // 错误的命令行参数值return -1;}i++;}// 如果命令行参数为"--work_megapix"，设置图像注册步骤的分辨率else if (string(argv[i]) == "--work_megapix"){work_megapix = atof(argv[i + 1]);i++;}// 如果命令行参数为"--seam_megapix"，设置缝合线估算步骤的分辨率else if (string(argv[i]) == "--seam_megapix"){seam_megapix = atof(argv[i + 1]);i++;}// 如果命令行参数为"--compose_megapix"，设置图像融合步骤的分辨率else if (string(argv[i]) == "--compose_megapix"){compose_megapix = atof(argv[i + 1]);i++;}// 如果命令行参数为"--result"，设置最终结果图像的文件名else if (string(argv[i]) == "--result"){result_name = argv[i + 1];i++;}// 如果命令行参数为"--features"，设置特征类型，并根据特征类型可能调整特征匹配置信度else if (string(argv[i]) == "--features"){features_type = argv[i + 1];if (string(features_type) == "orb")match_conf = 0.3f; // 如果是ORB特征，则将特征匹配置信度调整为0.3i++;}// 如果命令行参数为"--matcher"，设置特征匹配器的类型else if (string(argv[i]) == "--matcher"){if (string(argv[i + 1]) == "homography" || string(argv[i + 1]) == "affine")matcher_type = argv[i + 1];else{cout << "Bad --matcher flag value\n"; // 错误的命令行参数值return -1;}i++;}// 设置变换估计器类型，例如单应性或仿射else if (string(argv[i]) == "--estimator"){if (string(argv[i + 1]) == "homography" || string(argv[i + 1]) == "affine")estimator_type = argv[i + 1];else{cout << "Bad --estimator flag value\n";return -1;}i++; // 增加索引来跳过已经处理的参数值}// 允许用户设置特征匹配置信度else if (string(argv[i]) == "--match_conf"){match_conf = static_cast<float>(atof(argv[i + 1]));i++;}// 设置配准图像的置信度阈值else if (string(argv[i]) == "--conf_thresh"){conf_thresh = static_cast<float>(atof(argv[i + 1]));i++;}// 用户可以设定光束平差的代价函数类型else if (string(argv[i]) == "--ba"){ba_cost_func = argv[i + 1];i++;}// 设置光束平差细化掩码，用于指定哪些相机参数会被进行细化else if (string(argv[i]) == "--ba_refine_mask"){ba_refine_mask = argv[i + 1];if (ba_refine_mask.size() != 5){cout << "Incorrect refinement mask length.\n";return -1;}i++;}// 是否开启波形校正以及校正的方向else if (string(argv[i]) == "--wave_correct"){if (string(argv[i + 1]) == "no")do_wave_correct = false;else if (string(argv[i + 1]) == "horiz"){do_wave_correct = true;wave_correct = detail::WAVE_CORRECT_HORIZ;}else if (string(argv[i + 1]) == "vert"){do_wave_correct = true;wave_correct = detail::WAVE_CORRECT_VERT;}else{cout << "Bad --wave_correct flag value\n";return -1;}i++;}// 是否保存图像匹配状态图到指定文件else if (string(argv[i]) == "--save_graph"){save_graph = true;save_graph_to = argv[i + 1];i++;}// 允许用户设置图像变形的类型else if (string(argv[i]) == "--warp"){warp_type = string(argv[i + 1]);i++;}// 设置曝光补偿的类型else if (string(argv[i]) == "--expos_comp"){if (string(argv[i + 1]) == "no")expos_comp_type = ExposureCompensator::NO;else if (string(argv[i + 1]) == "gain")expos_comp_type = ExposureCompensator::GAIN;else if (string(argv[i + 1]) == "gain_blocks")expos_comp_type = ExposureCompensator::GAIN_BLOCKS;else if (string(argv[i + 1]) == "channels")expos_comp_type = ExposureCompensator::CHANNELS;else if (string(argv[i + 1]) == "channels_blocks")expos_comp_type = ExposureCompensator::CHANNELS_BLOCKS;else{cout << "Bad exposure compensation method\n";return -1;}i++;}// 参数：设置曝光补偿时所用的feeds数目else if (string(argv[i]) == "--expos_comp_nr_feeds"){expos_comp_nr_feeds = atoi(argv[i + 1]);i++; // 跳过下一步读取的参数值}// 参数：设置曝光补偿时过滤使用的迭代次数else if (string(argv[i]) == "--expos_comp_nr_filtering"){expos_comp_nr_filtering = atoi(argv[i + 1]);i++;}// 参数：设置曝光补偿区块的大小else if (string(argv[i]) == "--expos_comp_block_size"){expos_comp_block_size = atoi(argv[i + 1]);i++;}// 参数：设置接缝发现的方法else if (string(argv[i]) == "--seam"){if (string(argv[i + 1]) == "no" ||string(argv[i + 1]) == "voronoi" ||string(argv[i + 1]) == "gc_color" ||string(argv[i + 1]) == "gc_colorgrad" ||string(argv[i + 1]) == "dp_color" ||string(argv[i + 1]) == "dp_colorgrad")seam_find_type = argv[i + 1]; // 根据用户指定的类型来设置接缝发现策略else{cout << "Bad seam finding method\n"; // 输入了错误的接缝发现方法return -1;}i++;}// 参数：设置图像融合的方法else if (string(argv[i]) == "--blend"){if (string(argv[i + 1]) == "no")blend_type = Blender::NO; // 不进行融合else if (string(argv[i + 1]) == "feather")blend_type = Blender::FEATHER; // 羽化融合else if (string(argv[i + 1]) == "multiband")blend_type = Blender::MULTI_BAND; // 多带融合else{cout << "Bad blending method\n"; // 输入了错误的融合方法return -1;}i++;}// 参数：设置是否开启延时摄影模式以及其类型else if (string(argv[i]) == "--timelapse"){timelapse = true; // 开启延时摄影模式if (string(argv[i + 1]) == "as_is")timelapse_type = Timelapser::AS_IS; // 按原样else if (string(argv[i + 1]) == "crop")timelapse_type = Timelapser::CROP; // 裁剪对齐else{cout << "Bad timelapse method\n"; // 输入了错误的延时摄影方法return -1;}i++;}// 参数：设置运动范围宽度else if (string(argv[i]) == "--rangewidth"){range_width = atoi(argv[i + 1]);i++;}// 参数：设置融合强度else if (string(argv[i]) == "--blend_strength"){blend_strength = static_cast<float>(atof(argv[i + 1]));i++;}// 参数：指定输出文件的名称else if (string(argv[i]) == "--output"){result_name = argv[i + 1];i++;}// 如果参数不是以"--"开头的标志，则被当作输入图片的文件名elseimg_names.push_back(argv[i]);}// 如果在预览模式下，设置合成的图像分辨率为0.6if (preview){compose_megapix = 0.6;}// 返回0表示参数解析成功return 0;
}// 主函数定义
int main(int argc, char* argv[])
{// 开启日志
#if ENABLE_LOGint64 app_start_time = getTickCount();
#endif// 如果需要，设置异常情况下暂停（调试用）
#if 0cv::setBreakOnError(true);
#endif// 解析命令行参数int retval = parseCmdArgs(argc, argv);if (retval)return retval;  // 如果解析失败则退出// 检查是否有足够的图像进行拼接int num_images = static_cast<int>(img_names.size());if (num_images < 2){LOGLN("Need more images");return -1;  // 需要至少两张图像}// 初始化各种尺度变量，并设置标志double work_scale = 1, seam_scale = 1, compose_scale = 1;bool is_work_scale_set = false, is_seam_scale_set = false, is_compose_scale_set = false;LOGLN("Finding features...");
#if ENABLE_LOGint64 t = getTickCount();  // 开始记录查找特征的时间
#endif// 根据用户选择的特征类型创建特征检测器Ptr<Feature2D> finder;if (features_type == "orb"){finder = ORB::create();}else if (features_type == "akaze"){finder = AKAZE::create();}// 如果编译时包含了xfeatures2d模块，则添加SURF作为可能的特征
#ifdef HAVE_OPENCV_XFEATURES2Delse if (features_type == "surf"){finder = xfeatures2d::SURF::create();}
#endifelse if (features_type == "sift"){finder = SIFT::create();}else{cout << "Unknown 2D features type: '" << features_type << "'.\n";return -1;  // 如果输入的特征类型未知则退出}// 初始化用于图像处理的变量Mat full_img, img;vector<ImageFeatures> features(num_images);vector<Mat> images(num_images);vector<Size> full_img_sizes(num_images);double seam_work_aspect = 1;// 开始读取和处理所有图像for (int i = 0; i < num_images; ++i){full_img = imread(samples::findFile(img_names[i]));full_img_sizes[i] = full_img.size();// 如果图像读取失败，则退出if (full_img.empty()){LOGLN("Can't open image " << img_names[i]);return -1;}// 确定工作图像的尺度if (work_megapix < 0){img = full_img;work_scale = 1;is_work_scale_set = true;}else{// 如果未设置工作尺度，则根据megapixels计算尺度if (!is_work_scale_set){work_scale = min(1.0, sqrt(work_megapix * 1e6 / full_img.size().area()));is_work_scale_set = true;}// 调整图像尺寸resize(full_img, img, Size(), work_scale, work_scale, INTER_LINEAR_EXACT);}// 确定接缝图像的尺度if (!is_seam_scale_set){seam_scale = min(1.0, sqrt(seam_megapix * 1e6 / full_img.size().area()));seam_work_aspect = seam_scale / work_scale;is_seam_scale_set = true;}// 查找图像特征computeImageFeatures(finder, img, features[i]);features[i].img_idx = i;  // 记录图像索引LOGLN("Features in image #" << i+1 << ": " << features[i].keypoints.size());// 将图像调整到接缝尺寸并存储resize(full_img, img, Size(), seam_scale, seam_scale, INTER_LINEAR_EXACT);images[i] = img.clone();}// 释放不再使用的图像内存full_img.release();img.release();// 打印查找特征的时间LOGLN("Finding features, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");// 配对匹配LOG("Pairwise matching");
#if ENABLE_LOGt = getTickCount();  // 开始记录配对匹配的时间
#endifvector<MatchesInfo> pairwise_matches;Ptr<FeaturesMatcher> matcher;// 选择匹配器类型if (matcher_type == "affine")matcher = makePtr<AffineBestOf2NearestMatcher>(false, try_cuda, match_conf);else if (range_width==-1)matcher = makePtr<BestOf2NearestMatcher>(try_cuda, match_conf);elsematcher = makePtr<BestOf2NearestRangeMatcher>(range_width, try_cuda, match_conf);// 进行配对匹配(*matcher)(features, pairwise_matches);// 回收匹配器的垃圾空间matcher->collectGarbage();// 打印配对匹配的时间LOGLN("Pairwise matching, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");// 检查是否需要保存图像匹配关系图if (save_graph){LOGLN("Saving matches graph..."); // 记录日志ofstream f(save_graph_to.c_str()); // 打开文件流f << matchesGraphAsString(img_names, pairwise_matches, conf_thresh); // 将匹配关系图转换为字符串并保存}// 保留确定属于同一全景的图像集vector<int> indices = leaveBiggestComponent(features, pairwise_matches, conf_thresh); // 留下最大组件的索引vector<Mat> img_subset; // 新图像集合vector<String> img_names_subset; // 新图像名称集合vector<Size> full_img_sizes_subset; // 新图像尺寸集合for (size_t i = 0; i < indices.size(); ++i){img_names_subset.push_back(img_names[indices[i]]); // 添加图像名称img_subset.push_back(images[indices[i]]); // 添加图像full_img_sizes_subset.push_back(full_img_sizes[indices[i]]); // 添加图像尺寸}images = img_subset; // 更新图像集合img_names = img_names_subset; // 更新图像名称集合full_img_sizes = full_img_sizes_subset; // 更新图像尺寸集合// 再次检查是否有足够的图像num_images = static_cast<int>(img_names.size()); // 更新图像数量if (num_images < 2){LOGLN("Need more images"); // 记录日志return -1; // 若图像不够，则退出}// 创建估算器来估计相机参数Ptr<Estimator> estimator;if (estimator_type == "affine")estimator = makePtr<AffineBasedEstimator>(); // 仿射估算器elseestimator = makePtr<HomographyBasedEstimator>(); // 单应性估算器vector<CameraParams> cameras; // 相机参数集合if (!(*estimator)(features, pairwise_matches, cameras)) // 如果估计失败{cout << "Homography estimation failed.\n"; // 打印失败信息return -1; // 失败则退出}// 将内定参数更正为适合的格式并记录for (size_t i = 0; i < cameras.size(); ++i){Mat R;cameras[i].R.convertTo(R, CV_32F); // 将旋转矩阵转换为浮点数格式cameras[i].R = R; // 更新旋转矩阵LOGLN("Initial camera intrinsics #" << indices[i]+1 << ":\nK:\n" << cameras[i].K() << "\nR:\n" << cameras[i].R); // 记录相机内参}// 创建捆绑调整器来微调相机参数Ptr<detail::BundleAdjusterBase> adjuster;if (ba_cost_func == "reproj") adjuster = makePtr<detail::BundleAdjusterReproj>(); // 重投影调整器else if (ba_cost_func == "ray") adjuster = makePtr<detail::BundleAdjusterRay>(); // 射线调整器else if (ba_cost_func == "affine") adjuster = makePtr<detail::BundleAdjusterAffinePartial>(); // 仿射调整器else if (ba_cost_func == "no") adjuster = makePtr<NoBundleAdjuster>(); // 不使用捆绑调整else{cout << "Unknown bundle adjustment cost function: '" << ba_cost_func << "'.\n"; // 未知的调整器return -1; // 未知的调整器则退出}adjuster->setConfThresh(conf_thresh); // 设置置信度阈值Mat_<uchar> refine_mask = Mat::zeros(3, 3, CV_8U); // 创造细化掩码if (ba_refine_mask[0] == 'x') refine_mask(0,0) = 1; // 设置细化掩码if (ba_refine_mask[1] == 'x') refine_mask(0,1) = 1; // 设置细化掩码if (ba_refine_mask[2] == 'x') refine_mask(0,2) = 1; // 设置细化掩码if (ba_refine_mask[3] == 'x') refine_mask(1,1) = 1; // 设置细化掩码if (ba_refine_mask[4] == 'x') refine_mask(1,2) = 1; // 设置细化掩码adjuster->setRefinementMask(refine_mask); // 应用细化掩码if (!(*adjuster)(features, pairwise_matches, cameras)) // 如果调整失败{cout << "Camera parameters adjusting failed.\n"; // 打印失败信息return -1; // 调整失败则退出}// 计算所有相机的中值焦距vector<double> focals;for (size_t i = 0; i < cameras.size(); ++i){LOGLN("Camera #" << indices[i]+1 << ":\nK:\n" << cameras[i].K() << "\nR:\n" << cameras[i].R); // 记录相机内参focals.push_back(cameras[i].focal); // 记录焦距}sort(focals.begin(), focals.end()); // 对焦距进行排序float warped_image_scale; // 变形后的图像尺度if (focals.size() % 2 == 1)warped_image_scale = static_cast<float>(focals[focals.size() / 2]); // 选择中值焦距elsewarped_image_scale = static_cast<float>(focals[focals.size() / 2 - 1] + focals[focals.size() / 2]) * 0.5f; // 计算中值焦距// 波形矫正if (do_wave_correct){vector<Mat> rmats; // 旋转矩阵集合for (size_t i = 0; i < cameras.size(); ++i)rmats.push_back(cameras[i].R.clone()); // 复制所有的旋转矩阵waveCorrect(rmats, wave_correct); // 波形矫正for (size_t i = 0; i < cameras.size(); ++i)cameras[i].R = rmats[i]; // 更新矫正后的旋转矩阵}LOGLN("Warping images (auxiliary)... "); // 记录日志
#if ENABLE_LOGt = getTickCount(); // 记录时间
#endifvector<Point> corners(num_images); // 图像变形后的角点vector<UMat> masks_warped(num_images); // 变形后图像的蒙版vector<UMat> images_warped(num_images); // 变形后的图像vector<Size> sizes(num_images); // 变形后的尺寸vector<UMat> masks(num_images); // 初始化蒙版// 准备图像蒙版for (int i = 0; i < num_images; ++i){masks[i].create(images[i].size(), CV_8U);  // 创建大小相同的空蒙版masks[i].setTo(Scalar::all(255));  // 将蒙版置为白色，意味着图像的所有区域都用于拼接}// 对图像和它们的掩模进行变形处理Ptr<WarperCreator> warper_creator;// 如果定义了CUDA变形，并且CUDA可用，则根据变形类型创建对应的GPU变形器
#ifdef HAVE_OPENCV_CUDAWARPINGif (try_cuda && cuda::getCudaEnabledDeviceCount() > 0){if (warp_type == "plane")warper_creator = makePtr<cv::PlaneWarperGpu>();else if (warp_type == "cylindrical")warper_creator = makePtr<cv::CylindricalWarperGpu>();else if (warp_type == "spherical")warper_creator = makePtr<cv::SphericalWarperGpu>();}else
#endif{// 根据变形类型创建相应的CPU变形器if (warp_type == "plane")warper_creator = makePtr<cv::PlaneWarper>(); // 平面变形器else if (warp_type == "affine")warper_creator = makePtr<cv::AffineWarper>(); // 仿射变形器else if (warp_type == "cylindrical")warper_creator = makePtr<cv::CylindricalWarper>(); // 圆柱变形器else if (warp_type == "spherical")warper_creator = makePtr<cv::SphericalWarper>(); // 球形变形器else if (warp_type == "fisheye")warper_creator = makePtr<cv::FisheyeWarper>(); // 鱼眼变形器else if (warp_type == "stereographic")warper_creator = makePtr<cv::StereographicWarper>(); // 立体图变形器else if (warp_type == "compressedPlaneA2B1")warper_creator = makePtr<cv::CompressedRectilinearWarper>(2.0f, 1.0f); // 压缩平面变形器 A=2,B=1else if (warp_type == "compressedPlaneA1.5B1")warper_creator = makePtr<cv::CompressedRectilinearWarper>(1.5f, 1.0f); // 压缩平面变形器 A=1.5,B=1else if (warp_type == "compressedPlanePortraitA2B1")warper_creator = makePtr<cv::CompressedRectilinearPortraitWarper>(2.0f, 1.0f); // 压缩平面人像变形器 A=2,B=1else if (warp_type == "compressedPlanePortraitA1.5B1")warper_creator = makePtr<cv::CompressedRectilinearPortraitWarper>(1.5f, 1.0f); // 压缩平面人像变形器 A=1.5,B=1else if (warp_type == "paniniA2B1")warper_creator = makePtr<cv::PaniniWarper>(2.0f, 1.0f); // Panini变形器 A=2,B=1else if (warp_type == "paniniA1.5B1")warper_creator = makePtr<cv::PaniniWarper>(1.5f, 1.0f); // Panini变形器 A=1.5,B=1else if (warp_type == "paniniPortraitA2B1")warper_creator = makePtr<cv::PaniniPortraitWarper>(2.0f, 1.0f); // Panini人像变形器 A=2,B=1else if (warp_type == "paniniPortraitA1.5B1")warper_creator = makePtr<cv::PaniniPortraitWarper>(1.5f, 1.0f); // Panini人像变形器 A=1.5,B=1else if (warp_type == "mercator")warper_creator = makePtr<cv::MercatorWarper>(); // Mercator变形器else if (warp_type == "transverseMercator")warper_creator = makePtr<cv::TransverseMercatorWarper>(); // 横向Mercator变形器}// 如果创建变形器失败，则输出错误并返回if (!warper_creator){cout << "Can't create the following warper '" << warp_type << "'\n";return 1;}// 创建变形器，并设置变形尺度Ptr<RotationWarper> warper = warper_creator->create(static_cast<float>(warped_image_scale * seam_work_aspect));for (int i = 0; i < num_images; ++i){Mat_<float> K;// 获取并调整第i个相机的内部参数以适应变形尺度cameras[i].K().convertTo(K, CV_32F);float swa = (float)seam_work_aspect;K(0,0) *= swa; K(0,2) *= swa;K(1,1) *= swa; K(1,2) *= swa;// 变形第i张图像及其掩模corners[i] = warper->warp(images[i], K, cameras[i].R, INTER_LINEAR, BORDER_REFLECT, images_warped[i]);sizes[i] = images_warped[i].size();warper->warp(masks[i], K, cameras[i].R, INTER_NEAREST, BORDER_CONSTANT, masks_warped[i]);}// 将变形后图像的数据类型从8位无符号整数转换到32位浮点数vector<UMat> images_warped_f(num_images);for (int i = 0; i < num_images; ++i)images_warped[i].convertTo(images_warped_f[i], CV_32F);// 打印变形图像的时间LOGLN("Warping images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");// 开始进行曝光补偿处理LOGLN("Compensating exposure...");
#if ENABLE_LOGt = getTickCount(); // 开始记录曝光补偿的时间
#endif// 创建曝光补偿器，并根据类型进行相应的配置Ptr<ExposureCompensator> compensator = ExposureCompensator::createDefault(expos_comp_type);// 曝光补偿器的特定配置// 根据补偿器类型对其进行动态类型转换并配置参数if (dynamic_cast<GainCompensator*>(compensator.get())){GainCompensator* gcompensator = dynamic_cast<GainCompensator*>(compensator.get());gcompensator->setNrFeeds(expos_comp_nr_feeds); // 设置增益补偿器的饲喂次数}if (dynamic_cast<ChannelsCompensator*>(compensator.get())){ChannelsCompensator* ccompensator = dynamic_cast<ChannelsCompensator*>(compensator.get());ccompensator->setNrFeeds(expos_comp_nr_feeds); // 设置通道补偿器的饲喂次数}if (dynamic_cast<BlocksCompensator*>(compensator.get())){BlocksCompensator* bcompensator = dynamic_cast<BlocksCompensator*>(compensator.get());bcompensator->setNrFeeds(expos_comp_nr_feeds); // 设置块补偿器的饲喂次数bcompensator->setNrGainsFilteringIterations(expos_comp_nr_filtering); // 设置增益过滤迭代次数bcompensator->setBlockSize(expos_comp_block_size, expos_comp_block_size); // 设置块大小}// 使用曝光补偿器处理变形后的图像和掩模compensator->feed(corners, images_warped, masks_warped);// 打印曝光补偿时间LOGLN("Compensating exposure, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");// 开始寻找最佳的缝合线LOGLN("Finding seams...");
#if ENABLE_LOGt = getTickCount(); // 开始记录寻找缝合线的时间
#endif// 创建缝合线查找器，根据选择的类型进行实例化Ptr<SeamFinder> seam_finder;// 如果不存在缝合线查找，将其设置为NoSeamFinder；否则，根据选择的类型进行实例化// 创建缝合线查找器，根据选择的类型进行实例化if (seam_find_type == "no")seam_finder = makePtr<detail::NoSeamFinder>(); // 不使用缝合线查找器else if (seam_find_type == "voronoi")seam_finder = makePtr<detail::VoronoiSeamFinder>(); // Voronoi缝合线查找器else if (seam_find_type == "gc_color"){
#ifdef HAVE_OPENCV_CUDALEGACYif (try_cuda && cuda::getCudaEnabledDeviceCount() > 0)seam_finder = makePtr<detail::GraphCutSeamFinderGpu>(GraphCutSeamFinderBase::COST_COLOR); // 使用GPU的图割缝合线查找器，颜色成本else
#endifseam_finder = makePtr<detail::GraphCutSeamFinder>(GraphCutSeamFinderBase::COST_COLOR); // 图割缝合线查找器，颜色成本}else if (seam_find_type == "gc_colorgrad"){
#ifdef HAVE_OPENCV_CUDALEGACYif (try_cuda && cuda::getCudaEnabledDeviceCount() > 0)seam_finder = makePtr<detail::GraphCutSeamFinderGpu>(GraphCutSeamFinderBase::COST_COLOR_GRAD); // 使用GPU的图割缝合线查找器，颜色梯度成本else
#endifseam_finder = makePtr<detail::GraphCutSeamFinder>(GraphCutSeamFinderBase::COST_COLOR_GRAD); // 图割缝合线查找器，颜色梯度成本}else if (seam_find_type == "dp_color")seam_finder = makePtr<detail::DpSeamFinder>(DpSeamFinder::COLOR); // 动态规划缝合线查找器，颜色成本else if (seam_find_type == "dp_colorgrad")seam_finder = makePtr<detail::DpSeamFinder>(DpSeamFinder::COLOR_GRAD); // 动态规划缝合线查找器，颜色梯度成本// 如果缝合线查找器创建失败，则输出错误并返回if (!seam_finder){cout << "Can't create the following seam finder '" << seam_find_type << "'\n";return 1;}// 使用缝合线查找器来寻找图像之间的缝合线seam_finder->find(images_warped_f, corners, masks_warped);// 记录缝合线查找的耗时LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");// 释放不再使用的内存资源images.clear();images_warped.clear();images_warped_f.clear();masks.clear();// 开始图像合成步骤LOGLN("Compositing...");// 如果启用了日志，则记录合成开始的时间
#if ENABLE_LOGt = getTickCount();
#endif// 初始化合成所需的变量Mat img_warped, img_warped_s;Mat dilated_mask, seam_mask, mask, mask_warped;Ptr<Blender> blender;Ptr<Timelapser> timelapser;// 变量用于计算合成图像的工作尺寸，这里没有用到注释掉的变量double compose_work_aspect = 1;// 对所有图像进行遍历处理，以实现拼接// 遍历所有需要合成的图片for (int img_idx = 0; img_idx < num_images; ++img_idx){// 记录正在合成的图片编号LOGLN("Compositing image #" << indices[img_idx]+1);// 读取图片，并根据需要调整尺寸full_img = imread(samples::findFile(img_names[img_idx]));if (!is_compose_scale_set){// 如果还没有设置合成图片的比例，则根据需要进行设置if (compose_megapix > 0)compose_scale = min(1.0, sqrt(compose_megapix * 1e6 / full_img.size().area()));is_compose_scale_set = true;// 计算相对尺度，以及必要的缩放比例compose_work_aspect = compose_scale / work_scale;// 更新变形图像的比例warped_image_scale *= static_cast<float>(compose_work_aspect);warper = warper_creator->create(warped_image_scale);// 更新每张图片的角点和尺寸for (int i = 0; i < num_images; ++i){// 更新相机内参cameras[i].focal *= compose_work_aspect;cameras[i].ppx *= compose_work_aspect;cameras[i].ppy *= compose_work_aspect;// 更新图片角点和尺寸Size sz = full_img_sizes[i];if (std::abs(compose_scale - 1) > 1e-1){sz.width = cvRound(full_img_sizes[i].width * compose_scale);sz.height = cvRound(full_img_sizes[i].height * compose_scale);}// 计算变形后的ROIMat K;cameras[i].K().convertTo(K, CV_32F);Rect roi = warper->warpRoi(sz, K, cameras[i].R);corners[i] = roi.tl();sizes[i] = roi.size();}}// 根据比例调整图片大小if (abs(compose_scale - 1) > 1e-1)resize(full_img, img, Size(), compose_scale, compose_scale, INTER_LINEAR_EXACT);elseimg = full_img;full_img.release();Size img_size = img.size();// 准备图片变形所需的矩阵Mat K;cameras[img_idx].K().convertTo(K, CV_32F);// 对当前图片进行变形处理warper->warp(img, K, cameras[img_idx].R, INTER_LINEAR, BORDER_REFLECT, img_warped);// 创建并对当前图片的掩码进行变形处理mask.create(img_size, CV_8U);mask.setTo(Scalar::all(255));warper->warp(mask, K, cameras[img_idx].R, INTER_NEAREST, BORDER_CONSTANT, mask_warped);// 应用曝光补偿compensator->apply(img_idx, corners[img_idx], img_warped, mask_warped);// 将变形后的图片转换为有符号的16位整数格式用于合成img_warped.convertTo(img_warped_s, CV_16S);img_warped.release();img.release();mask.release();// 对蒙版进行膨胀处理，以便用于缝合线的掩饰dilate(masks_warped[img_idx], dilated_mask, Mat());resize(dilated_mask, seam_mask, mask_warped.size(), 0, 0, INTER_LINEAR_EXACT);mask_warped = seam_mask & mask_warped;// 如果没在延时摄影模式中并且还未创建blender对象，则创建它if (!blender && !timelapse){blender = Blender::createDefault(blend_type, try_cuda);Size dst_sz = resultRoi(corners, sizes).size();float blend_width = sqrt(static_cast<float>(dst_sz.area())) * blend_strength / 100.f;if (blend_width < 1.f)blender = Blender::createDefault(Blender::NO, try_cuda);else if (blend_type == Blender::MULTI_BAND){// 如果是多频段混合则创建并设置多频段blenderMultiBandBlender* mb = dynamic_cast<MultiBandBlender*>(blender.get());mb->setNumBands(static_cast<int>(ceil(log(blend_width)/log(2.)) - 1.));LOGLN("Multi-band blender, number of bands: " << mb->numBands());}else if (blend_type == Blender::FEATHER){// 如果是羽化混合类型则创建并设置羽化blenderFeatherBlender* fb = dynamic_cast<FeatherBlender*>(blender.get());fb->setSharpness(1.f/blend_width);LOGLN("Feather blender, sharpness: " << fb->sharpness());}// 为blender对象准备图片合成blender->prepare(corners, sizes);}else if (!timelapser && timelapse){// 如果在延时摄影模式且未创建timelapser则创建它timelapser = Timelapser::createDefault(timelapse_type);timelapser->initialize(corners, sizes);}// 把当前图片合成到全景图中if (timelapse){timelapser->process(img_warped_s, Mat::ones(img_warped_s.size(), CV_8UC1), corners[img_idx]);String fixedFileName;size_t pos_s = String(img_names[img_idx]).find_last_of("/\\");if (pos_s == String::npos){fixedFileName = "fixed_" + img_names[img_idx];}else{fixedFileName = "fixed_" + String(img_names[img_idx]).substr(pos_s + 1, String(img_names[img_idx]).length() - pos_s);}imwrite(fixedFileName, timelapser->getDst());}else{// 如果不在延时摄影模式则用blender合成图片blender->feed(img_warped_s, mask_warped, corners[img_idx]);}}// 如果不在延时摄影模式则完成图片合成，融合所有图片并写入输出文件if (!timelapse){Mat result, result_mask;blender->blend(result, result_mask);// 记录合成的耗时LOGLN("Compositing, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");// 将合成的结果图片写入文件imwrite(result_name, result);}// 输出程序总体完成的时间信息LOGLN("Finished, total time: " << ((getTickCount() - app_start_time) / getTickFrequency()) << " sec");return 0;
}
此代码是一个使用OpenCV库的C++程序，它实现了图像拼接器的功能。主要步骤包括：1. 解析传递给程序的命令行参数。2. 检查是否有足够的图像进行拼接。3. 使用不同的特征检测方法来查找图像中的特征点。4. 对特征点进行匹配以找到最佳配对图像。5. 使用运动估计算法估计相机参数。6. 应用曝光补偿来调整图像亮度，使拼接结果更自然。7. 找到接缝，确保图像拼接无缝。8. 使用扭曲算法改变图像的视角，使其匹配相邻图像。9. 应用图像融合算法将图像融合在一起以产生最终的全景图像。10. 如果需要，生成时间错位视频。11. 最后，将结果图像输出到文件。整个过程涉及图像处理、特征匹配和优化算法等多个领域的高级技术。代码中使用了OpenCV库的高级功能，如特征检测、特征匹配、图像扭曲和融合等，以实现这个相对复杂的图像处理任务。
这段代码主要描述的是使用OpenCV进行图像拼接的整体流程。以下是该代码的功能概述：1. 通过命令行参数读取待拼接的多个图像文件，并进行了一系列参数配置，包括预览模式、CUDA加速、各种算法参数等。2. 进行了图像特征提取、特征匹配，并基于这些匹配对相机参数（如内参矩阵、畸变系数等）进行估计。3. 根据相机参数，对图像进行畸变矫正和摄像机视角变换。4. 对透视变换后的图像进行曝光补偿和接缝处优化，以减少拼接痕迹。5. 使用不同的图像混合方法，如Feather和MultiBand，对图像进行融合，以生成无缝拼接的全景图像。整个代码以面向对象的方式组织，调用OpenCV内封装好的类和方法，以完成图像拼接任务。代码包含大量的处理逻辑分支，以满足不同的命令行参数输入，灵活配置程序的执行过程。