【opencv】示例-image_alignment.cpp 利用ECC 算法进行图像对齐

affine

imshow("image", target_image);
imshow("template", template_image);
imshow("warped image", warped_image);
imshow("error (black: no error)", abs(errorImage) * 255 / max_of_error);

homography

这段代码是一个利用ECC (Enhanced Correlation Coefficient) 算法进行图像对齐的示例。代码首先包含了OpenCV库的头文件，并且使用了OpenCV和标准库的命名空间。然后定义了几个函数和宏进行图像变换矩阵的操作，定义了一些用于解析命令行参数的关键字。

main 函数中，首先使用CommandLineParser解析命令行参数，之后加载输入图像和模板图像。如果只给出了输入图像，代码会生成一个随机的模板图像。如果给定了输入变换矩阵，则会使用该矩阵初始化。若变换类型为仿射或相似变换等，会初始化对应的变换矩阵。

代码接着执行findTransformECC函数来计算图像间的几何变换。计算完成后，保存变换矩阵和变换后的图像，并对结果进行显示（根据具体的verbose参数决定是否显示）。

整个过程包括了对图像的读取、几何变换矩阵的初始化与读取、使用ECC算法进行图像对齐、结果的保存与显示。通过这个示例，可以了解到图像处理中图像对齐的基本流程和方法。

/*
* 本示例展示了使用findTransformECC函数实现图像对齐的ECC算法
* 
* Demo加载一个图像（默认为fruits.jpg），并基于给定的运动类型人工创建一个模板图像。
* 当给出两幅图像时，第一幅是输入图像，第二幅定义模板图像。在后一种情况下，
* 您还可以解析warp的初始化。
* 
* 输入和输出的warp文件由原始的warp（变换）元素组成。
* 
* 作者: G. Evangelidis, 法国国家信息与自动化研究所(INRIA), Grenoble,
*       M. Asbach, 德国Fraunhofer IAIS, St. Augustin
*/


// 导入opencv库的各个模块
#include <opencv2/imgcodecs.hpp> // 图像编解码
#include <opencv2/highgui.hpp>   // 图像显示
#include <opencv2/video.hpp>     // 视频处理
#include <opencv2/imgproc.hpp>   // 图像处理
#include <opencv2/core/utility.hpp> // OpenCV实用函数


#include <stdio.h>  // 包含基本输入输出函数
#include <string>   // 包含字符串相关功能
#include <time.h>   // 包含处理时间相关功能
#include <iostream> // 包含输入输出流功能
#include <fstream>  // 包含文件流操作功能


using namespace cv;  // 使用OpenCV命名空间
using namespace std; // 使用标准库命名空间


// 向前声明函数(函数将在下面定义)
static void help(const char** argv);
static int readWarp(string iFilename, Mat& warp, int motionType);
static int saveWarp(string fileName, const Mat& warp, int motionType);
static void draw_warped_roi(Mat& image, const int width, const int height, Mat& W);




// 用于向齐次变换矩阵赋值的宏定义（x和y是坐标，H是变换矩阵）
#define HOMO_VECTOR(H, x, y)\
    H.at<float>(0,0) = (float)(x);\
    H.at<float>(1,0) = (float)(y);\
    H.at<float>(2,0) = 1.;


//  用于从齐次坐标中读取值的宏定义（X是齐次坐标，x和y是提取的坐标）
#define GET_HOMO_VALUES(X, x, y)\
    (x) = static_cast<float> (X.at<float>(0,0)/X.at<float>(2,0));\
    (y) = static_cast<float> (X.at<float>(1,0)/X.at<float>(2,0));


// 定义命令行参数，用于程序运行时接收用户输入或默认值
const std::string keys =
    "{@inputImage    | fruits.jpg    | input image filename }" // 输入图像文件名，默认为fruits.jpg
    "{@templateImage |               | template image filename (optional)}" // 模板图像文件名，可选参数
    "{@inputWarp     |               | input warp (matrix) filename (optional)}" // 输入变换矩阵（文件名），可选参数
    "{n numOfIter    | 50            | ECC's iterations }" // ECC算法迭代次数，默认值为50
    "{e epsilon      | 0.0001        | ECC's convergence epsilon }" // ECC算法收敛阈值，默认为0.0001
    "{o outputWarp   | outWarp.ecc   | output warp (matrix) filename }" // 输出变换矩阵的文件名，默认为outWarp.ecc
    "{m motionType   | affine        | type of motion (translation, euclidean, affine, homography) }" // 变换类型，默认为仿射变换(affine)
    "{v verbose      | 1             | display initial and final images }" // 是否显示处理前后的图像，默认为1（显示）
    "{w warpedImfile | warpedECC.png | warped input image }" // 输出变形后图像的文件名，默认为warpedECC.png
    "{h help | | print help message }" // 显示帮助信息
;


//该文件演示了 ECC 图像对齐算法的使用。 当给定一张图像时，
//模板图像是通过随机扭曲人为形成的。当给出两个图像时，可以
//通过命令行解析来初始化扭曲。如果缺少 inputWarp，则恒等变换
//会初始化算法。
// 提供程序帮助信息和命令行示例的函数
static void help(const char** argv)
{
    // 输出ECC图像对齐算法使用说明
    cout << "\nThis file demonstrates the use of the ECC image alignment algorithm. When one image"
        " is given, the template image is artificially formed by a random warp. When both images"
        " are given, the initialization of the warp by command line parsing is possible. "
        "If inputWarp is missing, the identity transformation initializes the algorithm. \n" << endl;


    // 输出仅用一个输入图像时命令行使用示例
    cout << "\nUsage example (one image): \n" // 使用示例（一个图像）
         << argv[0]  // 程序名
         << " fruits.jpg -o=outWarp.ecc "  // 输入图像，输出变换矩阵文件
            "-m=euclidean -e=1e-6 -N=70 -v=1 \n" << endl; // 运动类型，收敛阈值，迭代次数，是否显示结果


    // 输出用两个图像以及初始变换矩阵时命令行使用示例
    cout << "\nUsage example (two images with initialization): \n" // 使用示例（两个图像，带初始化）
         << argv[0]  // 程序名
         << " yourInput.png yourTemplate.png "  // 输入图像和模板图像
        "yourInitialWarp.ecc -o=outWarp.ecc -m=homography -e=1e-6 -N=70 -v=1 -w=yourFinalImage.png \n" << endl; // 输入变换矩阵，输出变换矩阵文件，变换类型，收敛阈值，迭代次数，是否显示结果，输出对齐后的图像文件
}


// 从文件中读取变换矩阵的函数
static int readWarp(string iFilename, Mat& warp, int motionType){
    // 根据不同的运动类型(motionType)确定需要从文件中读取的元素数量
    // 如果是透视变换(Homography)，读取9个值，否则读取6个值
    CV_Assert(warp.type()==CV_32FC1); // 确保warp矩阵是单通道浮点型
    int numOfElements; // 存储元素的数量
    if (motionType==MOTION_HOMOGRAPHY)
        numOfElements=9; // 透视变换有9个参数
    else
        numOfElements=6; // 其它变换类型只需要6个参数


    int i; // 循环计数变量
    int ret_value; // 返回值，表示是否成功读取文件


    ifstream myfile(iFilename.c_str()); // 打开文件
    if (myfile.is_open()){ // 如果文件成功打开
        float* matPtr = warp.ptr<float>(0); // 获取矩阵的指针
        for(i=0; i<numOfElements; i++){
            myfile >> matPtr[i]; // 从文件读取每个值
        }
        ret_value = 1; // 读取成功，设置返回值为1
    }
    else { // 如果文件打开失败
        cout << "Unable to open file " << iFilename.c_str() << endl; // 输出错误信息
        ret_value = 0; // 设置返回值为0
    }
    return ret_value; // 返回结果
}


// 将变换矩阵保存到文件中的函数
static int saveWarp(string fileName, const Mat& warp, int motionType)
{
    // 确保warp矩阵是单通道浮点型
    CV_Assert(warp.type()==CV_32FC1);


    const float* matPtr = warp.ptr<float>(0); // 获取矩阵的指针
    int ret_value; // 返回值，表示是否成功保存到文件


    ofstream outfile(fileName.c_str()); // 打开或创建文件来写入
    if( !outfile ) { // 如果文件打开失败
        cerr << "error in saving "
            << "Couldn't open file '" << fileName.c_str() << "'!" << endl; // 输出错误信息到错误流
        ret_value = 0; // 设置返回值为0
    }
    else {// 如果文件成功打开, 保存warp矩阵的元素
        outfile << matPtr[0] << " " << matPtr[1] << " " << matPtr[2] << endl;
        outfile << matPtr[3] << " " << matPtr[4] << " " << matPtr[5] << endl;
        if (motionType==MOTION_HOMOGRAPHY){ // 如果是透视变换，需要保存额外3个参数
            outfile << matPtr[6] << " " << matPtr[7] << " " << matPtr[8] << endl;
        }
        ret_value = 1; // 保存成功，设置返回值为1
    }
    return ret_value; // 返回结果
}


// 在图像上绘制变换后区域边界的函数
static void draw_warped_roi(Mat& image, const int width, const int height, Mat& W)
{
    // 定义四个角点
    Point2f top_left, top_right, bottom_left, bottom_right;


    Mat H = Mat(3, 1, CV_32F); // 定义齐次坐标向量
    Mat U = Mat(3, 1, CV_32F); // 存储变换后的坐标值


    Mat warp_mat = Mat::eye(3, 3, CV_32F); // 创建一个单位矩阵


    // 将变换矩阵 W 的值赋给 warp_mat
    for (int y = 0; y < W.rows; y++)
        for (int x = 0; x < W.cols; x++)
            warp_mat.at<float>(y,x) = W.at<float>(y,x);


    // 对矩形的四个角点进行变换


    // 左上角
    HOMO_VECTOR(H, 1, 1); // 将点设置为齐次坐标形式
    gemm(warp_mat, H, 1, 0, 0, U); // 使用矩阵乘法进行变换
    GET_HOMO_VALUES(U, top_left.x, top_left.y); // 获取变换后的值


    // 右上角
    HOMO_VECTOR(H, width, 1);
    gemm(warp_mat, H, 1, 0, 0, U);
    GET_HOMO_VALUES(U, top_right.x, top_right.y);


    // 左下角
    HOMO_VECTOR(H, 1, height);
    gemm(warp_mat, H, 1, 0, 0, U);
    GET_HOMO_VALUES(U, bottom_left.x, bottom_left.y);


    // 右下角
    HOMO_VECTOR(H, width, height);
    gemm(warp_mat, H, 1, 0, 0, U);
    GET_HOMO_VALUES(U, bottom_right.x, bottom_right.y);


    // 在图像上绘制变形后的矩形边界
    line(image, top_left, top_right, Scalar(255));     // 上边界
    line(image, top_right, bottom_right, Scalar(255)); // 右边界
    line(image, bottom_right, bottom_left, Scalar(255)); // 下边界
    line(image, bottom_left, top_left, Scalar(255));  // 左边界
}


// 主函数入口
int main (const int argc, const char * argv[])
{
    // 解析命令行参数
    CommandLineParser parser(argc, argv, keys);
    parser.about("ECC demo"); // 关于本程序


    parser.printMessage(); // 打印解析的信息
    help(argv); // 显示帮助信息


    // 获取命令行参数
    string imgFile = parser.get<string>(0); // 输入图像文件名
    string tempImgFile = parser.get<string>(1); // 模板图像文件名
    string inWarpFile = parser.get<string>(2); // 初始变换矩阵文件名


    // 获取其他参数
    int number_of_iterations = parser.get<int>("n"); // 迭代次数
    double termination_eps = parser.get<double>("e"); // 精度阈值，停止条件
    string warpType = parser.get<string>("m"); // 变换类型
    int verbose = parser.get<int>("v"); // 是否显示详细信息
    string finalWarp = parser.get<string>("o"); // 最终变换矩阵保存文件
    string warpedImFile = parser.get<string>("w"); // 对齐后的图像保存文件
    if (!parser.check()) // 检查解析的参数是否合理
    {
        parser.printErrors();
        return -1; // 参数不合理则返回-1
    }
    // 确保传入的变换类型是有效的 平移、欧几里得、仿射、单应性
    if (!(warpType == "translation" || warpType == "euclidean"
        || warpType == "affine" || warpType == "homography"))
    {
        cerr << "Invalid motion transformation" << endl;
        return -1; // 无效变换类型，返回-1
    }


    // 根据变换类型设定变换模式
    int mode_temp;
    if (warpType == "translation")
        mode_temp = MOTION_TRANSLATION;
    else if (warpType == "euclidean")
        mode_temp = MOTION_EUCLIDEAN;
    else if (warpType == "affine")
        mode_temp = MOTION_AFFINE;
    else
        mode_temp = MOTION_HOMOGRAPHY;


    // 读取输入图像
    Mat inputImage = imread(samples::findFile(imgFile), IMREAD_GRAYSCALE);
    if (inputImage.empty()) // 检查图像是否成功加载
    {
        cerr << "Unable to load the inputImage" <<  endl;
        return -1; // 加载失败，返回-1
    }


    // 初始化目标图像和模板图像
    Mat target_image;
    Mat template_image;


    // 如果提供了模板图像，则读取模板图像
    if (tempImgFile != "") {
        // 将输入图像复制给目标图像
        inputImage.copyTo(target_image);
        // 加载模板图像（灰度图）
        template_image = imread(samples::findFile(tempImgFile), IMREAD_GRAYSCALE);
        // 如果模板图像加载失败，则返回错误
        if (template_image.empty()) {
            cerr << "Unable to load the template image" << endl;
            return -1;
        }
    }
    else { // 如果没有指定模板图像文件名，对输入图像应用随机变换以生成模板
        // 对输入图像进行尺寸调整，新的尺寸为216 x 216像素
        resize(inputImage, target_image, Size(216, 216), 0, 0, INTER_LINEAR_EXACT);
        
        // 声明一个Mat类型变量用于存放变换矩阵
        Mat warpGround;
        
        // 创建一个随机数生成器，种子为当前时间戳
        RNG rng(getTickCount());
        
        // 声明一个double类型变量用于存放计算得到的角度
        double angle;
        
        // 根据mode_temp来决定如何生成变换矩阵并对图像应用变换
        switch (mode_temp) {
            case MOTION_TRANSLATION:
                // 生成一个随机的平移变换矩阵
                warpGround = (Mat_<float>(2, 3) << 1, 0, (rng.uniform(10.f, 20.f)),
                    0, 1, (rng.uniform(10.f, 20.f)));
                // 应用平移变换矩阵到目标图像，获取模板图像
                warpAffine(target_image, template_image, warpGround,
                    Size(200, 200), INTER_LINEAR + WARP_INVERSE_MAP);
                break;
            case MOTION_EUCLIDEAN:
                // 生成一个随机的欧几里得变换矩阵（含旋转和平移）
                angle = CV_PI / 30 + CV_PI * rng.uniform((double)-2.f, (double)2.f) / 180;
                warpGround = (Mat_<float>(2, 3) << cos(angle), -sin(angle), (rng.uniform(10.f, 20.f)),
                    sin(angle), cos(angle), (rng.uniform(10.f, 20.f)));
                // 应用欧几里得变换矩阵到目标图像，获取模板图像
                warpAffine(target_image, template_image, warpGround,
                    Size(200, 200), INTER_LINEAR + WARP_INVERSE_MAP);
                break;
            case MOTION_AFFINE:
                // 生成一个随机的仿射变换矩阵
                warpGround = (Mat_<float>(2, 3) << (1 - rng.uniform(-0.05f, 0.05f)),
                    (rng.uniform(-0.03f, 0.03f)), (rng.uniform(10.f, 20.f)),
                    (rng.uniform(-0.03f, 0.03f)), (1 - rng.uniform(-0.05f, 0.05f)),
                    (rng.uniform(10.f, 20.f)));
                // 应用仿射变换矩阵到目标图像，获取模板图像
                warpAffine(target_image, template_image, warpGround,
                    Size(200, 200), INTER_LINEAR + WARP_INVERSE_MAP);
                break;
            case MOTION_HOMOGRAPHY:
                // 生成一个随机的单应性变换矩阵
                warpGround = (Mat_<float>(3, 3) << (1 - rng.uniform(-0.05f, 0.05f)),
                    (rng.uniform(-0.03f, 0.03f)), (rng.uniform(10.f, 20.f)),
                    (rng.uniform(-0.03f, 0.03f)), (1 - rng.uniform(-0.05f, 0.05f)), (rng.uniform(10.f, 20.f)),
                    (rng.uniform(0.0001f, 0.0003f)), (rng.uniform(0.0001f, 0.0003f)), 1.f);
                // 应用单应性变换矩阵到目标图像，获取模板图像
                warpPerspective(target_image, template_image, warpGround,
                    Size(200, 200), INTER_LINEAR + WARP_INVERSE_MAP);
                break;
        }
    }
    
    // 根据变换类型创建适当大小的warp_matrix
    const int warp_mode = mode_temp;
    
    // 初始化或加载变换矩阵
    Mat warp_matrix;
    if (warpType == "homography")
        // 如果是单应性变换，则warp_matrix为3x3的单位矩阵
        warp_matrix = Mat::eye(3, 3, CV_32F);
    else
        // 如果是其他变换，则warp_matrix为2x3的单位矩阵
        warp_matrix = Mat::eye(2, 3, CV_32F);
    
    // 如果提供了变换矩阵文件名，尝试读取变换矩阵
    if (inWarpFile != ""){
        int readflag = readWarp(inWarpFile, warp_matrix, warp_mode);
        // 如果读取失败，打印错误信息，并退出程序
        if ((!readflag) || warp_matrix.empty())
        {
            cerr << "-> Check warp initialization file" << endl << flush;
            return -1;
        }
    }
    else {
        // 如果没有提供变换矩阵文件，发出警告：假定使用单位矩阵作为初始化可能不佳，
        // 尤其是当图像尺寸不相同时或者形变较大时
        printf("\n ->Performance Warning: Identity warp ideally assumes images of "
            "similar size. If the deformation is strong, the identity warp may not "
            "be a good initialization. \n");
    }
    
    // 检查迭代次数是否过多
    if (number_of_iterations > 200)
        cout << "-> Warning: too many iterations " << endl;
    
    // 如果不是单应性变换，确保变换矩阵仅有两行
    if (warp_mode != MOTION_HOMOGRAPHY)
        warp_matrix.rows = 2;
    
    //开始计时
    const double tic_init = (double) getTickCount();
    // 调用findTransformECC寻找最佳变换矩阵
    double cc = findTransformECC(template_image, target_image, warp_matrix, warp_mode,
        TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, number_of_iterations, termination_eps));
    
    // 如果findTransformECC返回错误（即-1），则打印错误信息
    if (cc == -1)
    {
        cerr << "The execution was interrupted. The correlation value is going to be minimized." << endl;
        cerr << "Check the warp initialization and/or the size of images." << endl << flush;
    }
    
    // 停止计时
    const double toc_final = (double)getTickCount();
    const double total_time = (toc_final - tic_init) / (getTickFrequency());
    //如果设置了verbose，打印对齐时间
    if (verbose) {
        cout << "Alignment time (" << warpType << " transformation): "
            << total_time << " sec" << endl << flush;
        //  cout << "Final correlation: " << cc << endl << flush;
    }
    
    // 保存最终的变换矩阵
    saveWarp(finalWarp, warp_matrix, warp_mode);
    
    if (verbose) {
        //如果设置了verbose，打印保存变换矩阵的文件名
        cout << "\nThe final warp has been saved in the file: " << finalWarp << endl << flush;
    }
    
    // 保存最终的对齐图像
    Mat warped_image = Mat(template_image.rows, template_image.cols, CV_32FC1);
    if (warp_mode != MOTION_HOMOGRAPHY)
        warpAffine(target_image, warped_image, warp_matrix, warped_image.size(),
        INTER_LINEAR + WARP_INVERSE_MAP);
    else
        warpPerspective(target_image, warped_image, warp_matrix, warped_image.size(),
        INTER_LINEAR + WARP_INVERSE_MAP);
    
    imwrite(warpedImFile, warped_image); // 保存变形后的图像
    
    // 如果设置了verbose，显示结果图像
    if (verbose)
    {
        cout << "The warped image has been saved in the file: " << warpedImFile << endl << flush;
    
        //创建可视化窗口
        namedWindow("image", WINDOW_AUTOSIZE);
        namedWindow("template", WINDOW_AUTOSIZE);
        namedWindow("warped image", WINDOW_AUTOSIZE);
        namedWindow("error (black: no error)", WINDOW_AUTOSIZE);
    
        //移动窗口，用于可视化布局
        moveWindow("image", 20, 300);
        moveWindow("template", 300, 300);
        moveWindow("warped image", 600, 300);
        moveWindow("error (black: no error)", 900, 300);
    
        // 绘制变换后的区域边界
        Mat identity_matrix = Mat::eye(3, 3, CV_32F);
    
        draw_warped_roi(target_image, template_image.cols - 2, template_image.rows - 2, warp_matrix);
        draw_warped_roi(template_image, template_image.cols - 2, template_image.rows - 2, identity_matrix);
    
        Mat errorImage;
        subtract(template_image, warped_image, errorImage);
        double max_of_error;
        minMaxLoc(errorImage, NULL, &max_of_error);
    
        // 显示图像
        cout << "Press any key to exit the demo (you might need to click on the images before)." << endl << flush;
    
        imshow("image", target_image);
        waitKey(200);
        imshow("template", template_image);
        waitKey(200);
        imshow("warped image", warped_image);
        waitKey(200);
        imshow("error (black: no error)", abs(errorImage) * 255 / max_of_error);
        waitKey(0);
    }
    
    // 完成程序
    return 0;
}

// 使用resize函数调整inputImage的大小，存入target_image中
resize(
    inputImage,               // 源图像
    target_image,             // 目标图像，输出的大小调整后的图像将被存储在这里
    Size(216, 216),           // 目标图像的新大小，此处指定为宽216像素，高216像素
    0,                        // x方向上的缩放比例，在这里缩放比例由Size参数决定，因此设置为0
    0,                        // y方向上的缩放比例，同上设置为0
    INTER_LINEAR_EXACT        // 插值方式，此处使用精确线性插值算法
);

如果没有指定模板图像文件名，对输入图像应用随机变换以生成模板

warpAffine(target_image, template_image, warpGround,
    Size(200, 200), INTER_LINEAR + WARP_INVERSE_MAP);

// 使用增强的相关系数(ECC)算法，寻找最佳的仿射变换矩阵
double cc = findTransformECC(
    template_image,        // 模板图像
    target_image,          // 需要对齐到模板图像的对象图像
    warp_matrix,           // 可以指定初始估计，函数将优化这个矩阵以获得最佳变换
    warp_mode,             // 规定变换模型的类型，如仿射变换
    TermCriteria(          // 优化时的迭代终止准则，可以是最大迭代次数，变换估计的精确度，或它们的组合
        TermCriteria::COUNT + TermCriteria::EPS, // 使用最大迭代次数和变换估计的精确度两个条件
        number_of_iterations,                     // 迭代的最大次数
        termination_eps                            // 迭代的终止精确度
    )
);

// 对target_image应用透视变换，结果输出到warped_image中
warpPerspective(
    target_image,     // 源图像
    warped_image,     // 目标图像，存储变换后的图像
    warp_matrix,      // 透视变换矩阵，描述了变换的参数
    warped_image.size(), // 最终输出图像的大小
    INTER_LINEAR + WARP_INVERSE_MAP // 插值方式加上变换方向
);

仿射变换和透视变换详细对比

// 使用通用矩阵乘法函数gemm计算变换矩阵和透视矩阵的乘积
gemm(
    warp_mat,   // 第一个矩阵A，这里指的是仿射变换矩阵或相应的变换矩阵
    H,          // 第二个矩阵B，透视变换矩阵
    1,          // alpha系数，用于缩放第一个矩阵A
    Mat(),      // 第三个矩阵C，在这个函数调用中未使用，所以传递一个空矩阵
    0,          // beta系数，由于矩阵C未被使用，beta系数实际不起作用
    U,          // 输出矩阵D，存储A和B(M1和M2)乘积的结果
    0           // 标志位，在此为0，默认表示正常的矩阵乘法
);

The End