ДИПЛОМ_ИПОВС / Кузьмина В.В. Диплом

Продолжение таблицы 2

ПРИЛОЖЕНИЕ 3

ПРОГРАММНЫЙ МОДУЛЬ ГЕНЕРАЦИИ ИЗОБРАЖЕНИЙ НОМЕРНЫХ ЗНАКОВ АВТОМОБИЛЕЙ (ПМ ГИНЗА)

ТЕКСТ ПРОГРАММЫ

Листов 20

Москва, 2017

122

123

1.Главная функция программы

// @brief Обрабатывает входные параметры и запускает генерацию изображений

int main(int argc, char* argv[])

{

const int kErrorRes = -1; try

{

if (argc != 3)

{

std::cout << "Command line arguments: <path_to_save_images> <number_of_original_pictures_to_generate>" << std::endl; return kErrorRes;

}

const bool kSaveOriginalLpImage = true; boost::filesystem::path output_directory(argv[1]);

int number_of_car_plates = boost::lexical_cast<int>(argv[2]); GenerateImages(number_of_car_plates, output_directory, kSaveOriginalLpImage);

return 0;

}

catch (const std::exception& ex)

{

std::cerr << ex.what() << std::endl; return kErrorRes;

}

catch (...)

{

std::cerr << "Unknown exception" << std::endl; return kErrorRes;

}

}

124

// @brief Генрирует изображения автомобильных номеров void GenerateImages(int number_of_car_plates, const boost::filesystem::path& output_directory, bool save_original_LP_image)

{

NumberGenerator generator;

ImageRotator image_rotator;

for (int j = 0; j < number_of_car_plates; ++j)

{

bool is_ok = generator.GenerateNextNumber(); if (!is_ok)

{

std::cerr << "Error. Failed to generate next number" << std::endl;

return;

}

// Формировании матрицы поворота cv::Mat img =

CreateFlippedCVMat(generator.GetLicensePlateNumber()); if (save_original_LP_image)

{

// Формирование названия изображения

std::wstring filename = boost::str(boost::wformat(L"%d %s.jpg") % j % generator.GetNumberString()).c_str(); SaveImage(img, output_directory / boost::filesystem::path("OriginalImages"), filename);

}

// Генерирует перспективно преобразованные изображения image_rotator.GenerateRotatedImages(img, generator.GetNumberString(), output_directory);

}

}

return;

}

125

2. Модуль перспективного преобразования сгенерированных изображений

//@brief Создаёт перспективно преобразованное изображение class ImageRotator

{

static const int kResultingWidth = 160; static const int kResultingHeight = 80;

public:

ImageRotator();

/*

*@brief Генерирует и сохраняет проективно искажённые изображения

*@param [IN] input_image - исходное изображение для вращения

*@param [IN] number_string - автомобильный номер с входного изображения

*@param [IN] output_dir - директория для сохранения сгенерированных искажённых изображений

*/

void GenerateRotatedImages(const cv::Mat& input_image, const std::wstring& number_string, const boost::filesystem::path& output_dir);

private:

/*

* @brief Заполняет матрицу трансформации для cv::warpPerspective()

*@param [IN] input_image - исходное изображение для поворота

*@param [IN] alpha, beta, gamma - угол поворота в градусах по оси X, Y, Z соответственно

*@param [IN] dx, dy, dz - смещение по оси X, Y, Z соответственно

*/

void FillTransformationMatrix(const cv::Mat& input_image, double

alpha, double beta, double gamma, double dx, double dy, double

dz);

/*

*@brief Поворачивает входное изображение

*@param [IN] input_image - исходное изображение для поворота

126

*@param [IN] output_image - полученное в результате искажения изображение

*@param [IN] alpha, beta, gamma, dx, dy, dz - см. выше

*/

void RotateImage(const cv::Mat &input_image, cv::Mat &output_image, double alpha, double beta, double gamma, double dx, double dy, double dz);

int m_image_index; cv::Mat m_2D_to_3D_matrix;

//Affine transformations in 3D space cv::Mat m_x_axis_rotation_matrix; cv::Mat m_y_axis_rotation_matrix; cv::Mat m_z_axis_rotation_matrix;

// Rotation matrix (m_x_axis_rotation_matrix*m_y_axis_rotation_matrix*m_z_axis_rotat ion_matrix)

cv::Mat m_rotation_matrix; cv::Mat m_translation_matrix; cv::Mat m_3D_to_2D_matrix;

cv::Mat m_resulting_transform_matrix;

};

ImageRotator::ImageRotator() : m_image_index(0){}

//@brief Поворачивает входное изображение

void ImageRotator::RotateImage(const cv::Mat &input_image, cv::Mat &output_image, double alpha, double beta, double gamma, double dx, double dy, double dz)

{

FillTransformationMatrix(input_image, alpha, beta, gamma, dx, dy, dz);

cv::Mat s = output_image(cv::Range(40, 270), cv::Range(100, 600));

127

cv::warpPerspective(input_image, output_image, m_resulting_transform_matrix, input_image.size(), cv::INTER_LANCZOS4);

}

// @brief Заполняет матрицу трансформации для

void ImageRotator::FillTransformationMatrix(const cv::Mat &input_image, double alpha, double beta, double gamma, double dx, double dy, double dz)

{

double w_init = input_image.cols; double h_init = input_image.rows;

// f - distance between camera and image double f = input_image.cols / 2.0;

alpha = (alpha)*CV_PI / 180.; beta = (beta)*CV_PI / 180.; gamma = (gamma)*CV_PI / 180.;

m_2D_to_3D_matrix = (cv::Mat_<double>(4, 3) << kResultingWidth / w_init, 0, -kResultingWidth / 2.0, 0, kResultingHeight / h_init, -kResultingHeight / 2.0, 0, 0, 0, 0, 0, 1);

// Affine transformations in 3D space m_x_axis_rotation_matrix = (cv::Mat_<double>(4, 4) <<

1, 0, 0, 0,

0, cos(alpha), -sin(alpha), 0, 0, sin(alpha), cos(alpha), 0, 0, 0, 0, 1);

m_y_axis_rotation_matrix = (cv::Mat_<double>(4, 4) << cos(beta), 0, -sin(beta), 0,

0, 1, 0, 0,

sin(beta), 0, cos(beta), 0, 0, 0, 0, 1);

128

m_z_axis_rotation_matrix = (cv::Mat_<double>(4, 4) << cos(gamma), -sin(gamma), 0, 0,

sin(gamma), cos(gamma), 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);

// Rotation matrix (m_x_axis_rotation_matrix*m_y_axis_rotation_matrix*m_z_axis_rotat ion_matrix)

m_rotation_matrix = m_x_axis_rotation_matrix * m_y_axis_rotation_matrix * m_z_axis_rotation_matrix;

m_translation_matrix = (cv::Mat_<double>(4, 4) << 1, 0, 0, dx,

0, 1, 0, dy, 0, 0, 1, dz, 0, 0, 0, 1);

m_3D_to_2D_matrix = (cv::Mat_<double>(3, 4) << f, 0, w_init / 2, 0,

0, f, h_init / 2, 0, 0, 0, 1, 0);

m_resulting_transform_matrix = m_3D_to_2D_matrix * (m_translation_matrix * (m_rotation_matrix * m_2D_to_3D_matrix));

}

// @brief Генерирует и сохраняет проективно искажённые изображения void ImageRotator::GenerateRotatedImages(const cv::Mat& input_image, const std::wstring& number_string, const boost::filesystem::path& output_dir)

{

cv::Mat output_image(cv::Size(650,300), input_image.type(), cv::Scalar(255., 255., 255., 0));

boost::filesystem::path current_filename = number_string; std::wstring resulting_filename;

129

for (int alpha = kAlphaMinLimit; alpha <= kAlphaMaxLimit; alpha += kAlphaStep)

for (int beta = -kBetaLimit; beta <= kBetaLimit; beta += kBetaStep)

for (int gamma = -kGammaLimit; gamma <= kGammaLimit; gamma += kGammaStep)

for (int dx = -kDxLimit; dx <= kDxLimit; dx += kDxStep)

{

RotateImage(input_image, output_image, alpha, beta, gamma, dx, kDy, kDz);

resulting_filename = boost::str(boost::wformat(L"%d %s.jpg") % m_image_index++ % number_string).c_str();

int bpp = 8 * output_image.elemSize();

// получаем картинку

char* filename = "D:/ResImage/191.jpg"; IplImage* image = cvLoadImage(filename, 1);

// клонируем картинку

IplImage* src = cvCloneImage(image); printf("[i] image: %s\n", filename); assert(src != 0);

// окно для отображения картинки cvNamedWindow("original",CV_WINDOW_AUTOSIZE);

// показываем картинку cvShowImage("original", image);

system("pause");

SaveImage(output_image, output_dir, resulting_filename);

}

}

130