加载内参，对一个目录下所有原图进行去畸变处理（c++ code）

#include <gflags/gflags.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <boost/filesystem.hpp>
#include <opencv2/opencv.hpp>

#include "common/utility/file_util.hpp"
#include "common/utility/vehicle_config_util.hpp"

DEFINE_string(image_path, "", "path to image data");
DEFINE_string(camera_sensor_name, "", "camera sensor name");
DEFINE_string(vehicle_config_path, "", "path to vehicle config path");
DEFINE_string(output_dir, "", "path to save data for verify");

static bool ValidateEmpty(const char *flag, const std::string &value) {
    return value.empty() ? false : true;
}

DEFINE_validator(image_path, &ValidateEmpty);
DEFINE_validator(camera_sensor_name, &ValidateEmpty);
DEFINE_validator(vehicle_config_path, &ValidateEmpty);
DEFINE_validator(output_dir, &ValidateEmpty);

bool SaveUndistImage(const cv::Mat &K,
                           const cv::Mat &dist_coeff,
                           const std::vector<std::string> &image_files,
                           const std::string &camera_sensor_name,
                           const std::string &output_dir);
bool GetAllFiles(const std::string &dir, std::vector<std::string> *file_names);

int main(int argc, char *argv[]) {
    if (!image_path_validator_registered ||
        !camera_sensor_name_validator_registered ||
        !vehicle_config_path_validator_registered ||
        !output_dir_validator_registered) {
        return 1;
    }
    gflags::SetUsageMessage(
        "This program is used to calibrate camera intrinsic.");
    gflags::ParseCommandLineFlags(&argc, &argv, true);

    std::vector<std::string> image_files;
    if (GetAllFiles(FLAGS_image_path, &image_files) == false) {
        std::cerr << "read image data failed: " << FLAGS_image_path
                  << std::endl;
        return 1;
    }

    calib::CameraIntrinsic cam_intrin;
    std::string camera_intrinsic_file =
        FLAGS_vehicle_config_path + "/" + FLAGS_camera_sensor_name + "/" +
        FLAGS_camera_sensor_name + "-intrinsic.json";
    if (calib::VehicleConfigUtil::LoadCameraIntrinsic(camera_intrinsic_file,
                                                      &cam_intrin) == false) {
        std::cerr << "read intrinsic failed: " << camera_intrinsic_file
                  << std::endl;
        return -1;
    }

    cv::Mat intrinsic_k =
        (cv::Mat_<double>(3, 3) << cam_intrin.K(0, 0), cam_intrin.K(0, 1),
         cam_intrin.K(0, 2), cam_intrin.K(1, 0), cam_intrin.K(1, 1),
         cam_intrin.K(1, 2), cam_intrin.K(2, 0), cam_intrin.K(2, 1),
         cam_intrin.K(2, 2));
    cv::Mat intrinsic_dist =
        (cv::Mat_<double>(4, 1) << cam_intrin.distortion(0, 0),
         cam_intrin.distortion(1, 0), cam_intrin.distortion(2, 0),
         cam_intrin.distortion(3, 0));

    std::cout << "K:" << std::endl << intrinsic_k << std::endl;
    std::cout << "dist_coeff:" << std::endl << intrinsic_dist << std::endl;

    if (SaveUndistImage(intrinsic_k, intrinsic_dist, image_files,
                              FLAGS_camera_sensor_name,
                              FLAGS_output_dir) == false) {
        std::cerr << " save Verify undist image failed " << std::endl;
        return -1;
    }

    return 0;
}

bool SaveUndistImage(const cv::Mat &K,
                           const cv::Mat &dist_coeff,
                           const std::vector<std::string> &image_files,
                           const std::string &camera_sensor_name,
                           const std::string &output_dir) {
    // save undist image
    std::string undist_img_output_path =
        output_dir + "/" + camera_sensor_name + "_undist";
    if (calib::FileUtil::IsExists(undist_img_output_path)) {
        calib::FileUtil::DeleteFile(undist_img_output_path);
    }
    if (!calib::FileUtil::IsDirectory(undist_img_output_path)) {
        calib::FileUtil::CreateDirectories(undist_img_output_path);
    }

    for (const auto &image_file : image_files) {
        cv::Mat image = cv::imread(image_file, cv::IMREAD_GRAYSCALE);
        if (image.empty()) {
            std::cerr << "read image failed" << std::endl;
            return false;
        }
        cv::Mat undist_img;
        cv::Mat map_x_ori, map_y_ori;
        cv::initUndistortRectifyMap(K, dist_coeff, cv::Mat(), K, image.size(),
                                    CV_32F, map_x_ori, map_y_ori);

        cv::remap(image, undist_img, map_x_ori, map_y_ori, cv::INTER_LINEAR);

        size_t start = image_file.rfind("/");
        size_t end = image_file.rfind(".");

        std::string img_id = image_file.substr(start + 1, end - start - 1);

        std::string image_undist_file =
            undist_img_output_path + "/" + img_id + "_undist.png";
        cv::imwrite(image_undist_file, undist_img);
    }
    return true;
}

bool GetAllFiles(const std::string &dir, std::vector<std::string> *file_names) {
    boost::filesystem::path target_path(dir);
    boost::filesystem::directory_iterator end_iter;
    for (boost::filesystem::directory_iterator iter(target_path);
         iter != end_iter; ++iter) {
        std::string file_name = iter->path().string();
        file_names->push_back(file_name);
    }
    if (file_names->empty()) {
        std::cerr << "empty directory" << std::endl;
        return false;
    }

    return true;
}