Merge branch 'develop' into wuxiuping_branch

# Conflicts:
#	src/src/core/plate_judge.cpp

annCh_train.cpp

@@ -0,0 +1,347 @@
+#include <numeric>//包含了C++标准库中的<numeric>头文件，提供了数值计算的相关函数和模板。
+#include <ctime>//包含了C++标准库中的<ctime>头文件，提供了关于时间和日期的相关函数和类型。
+
+#include "easypr/train/annCh_train.h"//包含了EasyPR库中的annCh_train.h头文件，这个头文件可能包含了用于训练ANN（人工神经网络）字符识别的相关函数和类。
+#include "easypr/config.h"//包含了EasyPR库的config.h头文件，这个头文件可能包含了一些配置EasyPR库的全局变量和宏定义。
+#include "easypr/core/chars_identify.h"//包含了EasyPR库的chars_identify.h头文件，这个头文件可能包含了字符识别的核心功能的声明。
+#include "easypr/core/feature.h"//包含了EasyPR库的feature.h头文件，这个头文件可能包含了特征提取和处理的相关的函数和类。
+#include "easypr/core/core_func.h"//包含了EasyPR库的core_func.h头文件，这个头文件可能包含了一些核心的函数和类。
+#include "easypr/util/util.h"//包含了EasyPR库的util.h头文件，这个头文件可能包含了一些工具函数和类。
+#include "easypr/train/create_data.h"//包含了EasyPR库的create_data.h头文件，这个头文件可能包含了用于创建训练数据的函数和类。
+
+namespace easypr {                                   // 定义命名空间easypr  
+  
+  AnnChTrain::AnnChTrain(const char* chars_folder, const char* xml)  // 定义构造函数，参数为字符文件夹路径和xml文件路径  
+    : chars_folder_(chars_folder), ann_xml_(xml)                     // 初始化chars_folder_和ann_xml_成员变量  
+  {  
+    ann_ = cv::ml::ANN_MLP::create();    // 创建一个MLP（Multilayer Perceptron，多层感知器）对象，用于字符识别  
+    type = 1;                          // 初始化type为1，可能表示某种类型或模式  
+    kv_ = std::shared_ptr<Kv>(new Kv); // 创建一个Kv对象，并使用std::shared_ptr管理内存，实现共享所有权模型  
+    kv_->load("resources/text/province_mapping");  // 加载kv_对象，可能从文件"resources/text/province_mapping"中加载数据  
+    extractFeature = getGrayPlusProject;  // 初始化extractFeature函数指针，指向getGrayPlusProject函数，用于特征提取  
+  }
+void AnnChTrain::train()  
+{  
+    int classNumber = 0; // 类别数量，初始化为0，需要在后续代码中赋值  
+    int input_number = 0; // 输入节点数量，初始化为0，需要在后续代码中赋值  
+    int hidden_number = 0; // 隐藏层节点数量，初始化为0，需要在后续代码中赋值  
+    int output_number = 0; // 输出节点数量，初始化为0，需要在后续代码中赋值  
+  
+    bool useLBP = false; // 是否使用LBP特征，初始化为false  
+    if (useLBP) // 如果使用LBP特征  
+      input_number = kCharLBPPatterns * kCharLBPGridX * kCharLBPGridY; // 则设置输入节点数量为LBP特征的数量  
+    else  
+      input_number = kGrayCharHeight * kGrayCharWidth; // 否则设置输入节点数量为字符图像的高度和宽度的乘积  
+  
+    input_number += 64; // 在输入节点数量基础上加64，可能是为了增加一些额外的输入节点  
+}
+
+classNumber = kChineseNumber; // 类别数量，这里假设 kChineseNumber 是一个定义好的常量  
+hidden_number = kCharHiddenNeurons; // 隐藏层节点数量，这里假设 kCharHiddenNeurons 是一个定义好的常量  
+output_number = classNumber; // 输出节点数量，等于类别数量  
+cv::Mat layers; // 声明一个 OpenCV 的 Mat 对象，用于存储网络层的数据，但在这段代码中没有使用  
+  
+int first_hidden_neurons = 48; // 第一隐藏层节点数量，硬编码为48  
+int second_hidden_neurons = 32; // 第二隐藏层节点数量，硬编码为32  
+  
+int N = input_number; // 输入节点数量，这里假设 input_number 是一个定义好的变量  
+int m = output_number; // 输出节点数量，等于类别数量，这里假设 output_number 是一个定义好的变量  
+  
+// 在这里注释掉了两行代码，它们原先可能是用于计算第一层和第二层隐藏层的节点数量的公式  
+//int first_hidden_neurons = int(std::sqrt((m + 2) * N) + 2 * std::sqrt(N / (m + 2)));  
+//int second_hidden_neurons = int(m * std::sqrt(N / (m + 2)));  
+  
+bool useTLFN = false; // 是否使用TLFN，初始化为false，但在这段代码中没有使用
+
+if (!useTLFN) { // 如果不使用两层神经网络（TLFN）  
+  layers.create(1, 3, CV_32SC1); // 创建一个1行3列的OpenCV Mat对象，数据类型为32位有符号整数  
+  layers.at<int>(0) = input_number; // 设置输入层节点数量  
+  layers.at<int>(1) = hidden_number; // 设置隐藏层节点数量  
+  layers.at<int>(2) = output_number; // 设置输出层节点数量  
+}  
+else { // 如果使用两层神经网络（TLFN）  
+  fprintf(stdout, ">> Use two-layers neural networks,\n"); // 打印信息到标准输出，表示正在使用两层神经网络  
+  fprintf(stdout, ">> First_hidden_neurons: %d \n", first_hidden_neurons); // 打印第一层隐藏层节点数量到标准输出  
+  fprintf(stdout, ">> Second_hidden_neurons: %d \n", second_hidden_neurons); // 打印第二层隐藏层节点数量到标准输出  
+  
+  layers.create(1, 4, CV_32SC1); // 创建一个1行4列的OpenCV Mat对象，数据类型为32位有符号整数  
+  layers.at<int>(0) = input_number; // 设置输入层节点数量  
+  layers.at<int>(1) = first_hidden_neurons; // 设置第一层隐藏层节点数量  
+  layers.at<int>(2) = second_hidden_neurons; // 设置第二层隐藏层节点数量  
+  layers.at<int>(3) = output_number; // 设置输出层节点数量  
+}
+
+// 设置神经网络层的大小  
+ann_->setLayerSizes(layers);  
+  
+// 设置激活函数为Sigmoid函数，其对称性取决于第二个参数，第三个参数是该函数的斜率  
+ann_->setActivationFunction(cv::ml::ANN_MLP::SIGMOID_SYM, 1, 1);  
+  
+// 设置训练方法为反向传播法  
+ann_->setTrainMethod(cv::ml::ANN_MLP::TrainingMethods::BACKPROP);  
+  
+// 设置训练终止条件为最大迭代次数30000次，或当误差小于0.0001时终止  
+ann_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 30000, 0.0001));  
+  
+// 设置权重的更新比例因子为0.1  
+ann_->setBackpropWeightScale(0.1);  
+  
+// 设置权重的动量更新比例因子为0.1  
+ann_->setBackpropMomentumScale(0.1);  
+  
+// 获取文件夹中的文件列表，如果文件列表为空，则打印错误信息并给出建议  
+auto files = Utils::getFiles(chars_folder_);  
+if (files.size() == 0) {  
+  fprintf(stdout, "No file found in the train folder!\n");  
+  fprintf(stdout, "You should create a folder named \"tmp\" in EasyPR main folder.\n");  
+  fprintf(stdout, "Copy train data folder(like \"annCh\") under \"tmp\". \n");  
+  return;  
+}  
+  
+// 使用原始数据或原始数据 + 合成的数据进行训练和验证，具体数量由 m_number_for_count 决定  
+trainVal(m_number_for_count);
+
+// 定义一个方法，用于识别汉字  
+// 参数：输入图像  
+// 返回值：一个由汉字字符串和对应的省份字符串组成的pair  
+std::pair<std::string, std::string> AnnChTrain::identifyGrayChinese(cv::Mat input) {  
+  // 定义特征向量  
+  Mat feature;  
+  // 从输入图像中提取特征  
+  extractFeature(input, feature);  
+  // 初始化最大值为-2  
+  float maxVal = -2;  
+  // 初始化结果为0  
+  int result = 0;  
+  
+  // 定义输出矩阵，大小为1行，kChineseNumber列，数据类型为CV_32FC1（32位浮点型）  
+  cv::Mat output(1, kChineseNumber, CV_32FC1);  
+  // 使用神经网络模型进行预测，输入特征向量，输出结果到output矩阵中  
+  ann_->predict(feature, output);  
+  
+  // 遍历输出矩阵中的每一个值  
+  for (int j = 0; j < kChineseNumber; j++) {  
+    // 获取当前位置的值  
+    float val = output.at<float>(j);  
+    // 如果当前值大于maxVal，则更新maxVal和result的值  
+    //std::cout << "j:" << j << "val:" << val << std::endl;  
+    if (val > maxVal) {  
+      maxVal = val;  
+      result = j;  
+    }  
+  }  
+  
+  // 根据result的值计算索引index，注意这里进行了偏移操作，可能是因为字符集的索引与输出结果的索引之间存在偏移  
+  auto index = result + kCharsTotalNumber - kChineseNumber;  
+  // 根据索引获取对应的字符key  
+  const char* key = kChars[index];  
+  // 将字符key转换为字符串s  
+  std::string s = key;  
+  // 通过kv_（应该是某个键值对容器）获取与s对应的省份字符串，存储到province变量中  
+  std::string province = kv_->get(s);  
+  
+  // 返回一个由字符s和省份province组成的pair对象  
+  return std::make_pair(s, province);  
+}  
+  
+// 定义一个方法，用于测试模型性能（目前为空）  
+void AnnChTrain::test() {  
+  // TODO: 需要实现测试代码，评估模型的性能指标，如准确率、召回率等。  
+}  
+  
+// 定义一个方法，用于训练验证集（目前为空）  
+void AnnChTrain::trainVal(size_t number_for_count) {  
+  // 断言chars_folder_不为空，否则会抛出异常（TODO: 需要实现断言失败的处理逻辑）  
+  assert(chars_folder_);  
+  // 定义训练样本的存储容器train_samples（TODO: 这里需要解释这个变量名和变量的具体含义）  
+  cv::Mat train_samples;  
+  // 定义训练图像、验证图像的存储容器（TODO: 这里需要解释这些变量名和变量的具体含义）  
+  std::vector<cv::Mat>  train_images, val_images;  
+  std::vector<int> train_label, val_labels;  
+  // 设置训练验证集分割比例为0.7（70%用于训练，30%用于验证）  
+  float percentage = 0.7f;  
+  // 设置类别数为kChineseNumber（TODO: 需要解释这个变量的具体含义）直接把代码改成评注形式
+
+// 循环遍历每个字符类别  
+for (int i = 0; i < classNumber; ++i) {   
+  // 从kChars数组中获取当前字符的键  
+  auto char_key = kChars[i + kCharsTotalNumber - classNumber];  
+  // 定义一个字符数组sub_folder，用于存储子文件夹的路径，并初始化为0  
+  char sub_folder[512] = { 0 };  
+  // 使用sprintf函数将字符键和字符文件夹路径拼接，存入sub_folder  
+  sprintf(sub_folder, "%s/%s", chars_folder_, char_key);  
+  // 将字符键转化为字符串类型，方便后续操作  
+  std::string test_char(char_key);  
+  // 如果test_char不等于"zh_yun"，则跳过当前循环  
+  // if (test_char != "zh_yun") continue;  
+  fprintf(stdout, ">> Testing characters %s in %s \n", char_key, sub_folder);  
+  // 调用utils::getFiles函数获取子文件夹下的所有文件，存入chars_files  
+  auto chars_files = utils::getFiles(sub_folder);  
+  // 获取子文件夹下的文件数量  
+  size_t char_size = chars_files.size();  
+  fprintf(stdout, ">> Characters count: %d \n", (int)char_size);  
+  
+  // 定义一个向量matVec，用于存储处理过的图像  
+  std::vector<cv::Mat> matVec;  
+  // 为matVec预留空间，提高性能  
+  matVec.reserve(number_for_count);  
+  // 内层循环，遍历子文件夹下的每一个文件  
+  for (auto file : chars_files) {  
+    std::cout << file << std::endl;  
+    // 使用OpenCV的imread函数读取图像，并将其转化为灰度图像  
+    auto img = cv::imread(file, IMREAD_GRAYSCALE);  // a grayscale image   
+    Mat img_resize;  
+    // 为img_resize分配空间，并设置其大小和数据类型  
+    img_resize.create(kGrayCharHeight, kGrayCharWidth, CV_8UC1);  
+    // 使用OpenCV的resize函数调整图像大小  
+    resize(img, img_resize, img_resize.size(), 0, 0, INTER_LINEAR);  
+    // 将调整大小后的图像存入matVec  
+    matVec.push_back(img_resize);  
+  }  
+}
+// 生成合成图像  
+// genrate the synthetic images  
+for (int t = 0; t < (int)number_for_count - (int)char_size; t++) {  
+  // 确定随机数的范围  
+  int rand_range = char_size + t;  
+  // 生成一个随机数  
+  int ran_num = rand() % rand_range;  
+  // 从matVec中获取一个图像  
+  auto img = matVec.at(ran_num);  
+  // 显示该图像  
+  SHOW_IMAGE(img, 0);  
+  // 生成合成图像  
+  auto simg = generateSyntheticImage(img);  
+  // 显示合成图像  
+  SHOW_IMAGE(simg, 0);  
+  // 将合成图像添加到matVec中  
+  matVec.push_back(simg);  
+}  
+// 输出matVec的大小  
+fprintf(stdout, ">> Characters count: %d \n", (int)matVec.size());  
+  
+// 对matVec进行随机排序  
+// random sort the mat;  
+srand(unsigned(time(NULL)));  
+random_shuffle(matVec.begin(), matVec.end());  
+  
+// 获取matVec的大小  
+int mat_size = (int)matVec.size();  
+// 计算分割索引  
+int split_index = int((float)mat_size * percentage);  
+// 从后往前遍历matVec  
+for (int j = mat_size - 1; j >= 0; j--) {  
+  // 从matVec中获取图像  
+  Mat img = matVec.at(j);  
+  // 此处代码可能有误，因为该判断语句始终为真，无法起到分割训练集和验证集的作用  
+  // 应该根据split_index来分割训练集和验证集  
+  if (1) {  
+    Mat feature;  
+    // 提取图像特征  
+    extractFeature(img, feature);  
+    if (j <= split_index) {  
+      // 将特征和图像添加到训练样本和训练图像中  
+      train_samples.push_back(feature);  
+      train_images.push_back(img);  
+      train_label.push_back(i);  
+    }  
+    else {  
+      // 将图像添加到验证图像中，将标签添加到验证标签中  
+      val_images.push_back(img);  
+      val_labels.push_back(i);  
+    }  
+  }  
+}
+  // generate train data
+  train_samples.convertTo(train_samples, CV_32F);
+  cv::Mat train_classes = cv::Mat::zeros((int)train_label.size(), classNumber, CV_32F);
+  for (int i = 0; i < train_classes.rows; ++i)
+    train_classes.at<float>(i, train_label[i]) = 1.f;
+  auto train_data = cv::ml::TrainData::create(train_samples, cv::ml::SampleTypes::ROW_SAMPLE, train_classes);
+
+  // train the data, calculate the cost time
+  std::cout << "Training ANN chinese model, please wait..." << std::endl;
+  long start = utils::getTimestamp();
+  ann_->train(train_data);
+  long end = utils::getTimestamp();
+  ann_->save(ann_xml_);
+  std::cout << "Your ANN Model was saved to " << ann_xml_ << std::endl;
+  std::cout << "Training done. Time elapse: " << (end - start) / (1000 * 60) << "minute" << std::endl;
+
+  // test the accuracy_rate in train
+  if (1) {
+    int corrects_all = 0, sum_all = train_images.size();
+    std::cout << "train_images size: " << sum_all << std::endl;
+    for (size_t i = 0; i < train_images.size(); ++i) {
+      cv::Mat img = train_images.at(i);
+      int label = train_label.at(i);
+      auto char_key = kChars[label + kCharsTotalNumber - classNumber];
+      std::pair<std::string, std::string> ch = identifyGrayChinese(img);
+      if (ch.first == char_key)
+        corrects_all++;
+    }
+    float accuracy_rate = (float)corrects_all / (float)sum_all;
+    std::cout << "Train error_rate: " << (1.f - accuracy_rate) * 100.f << "% "<< std::endl;
+  }
+
+  // test the accuracy_rate in val
+  if (1) {
+    int corrects_all = 0, sum_all = val_images.size();
+    std::cout << "val_images: " << sum_all << std::endl;
+    for (size_t i = 0; i < val_images.size(); ++i) {
+      cv::Mat img = val_images.at(i);
+      int label = val_labels.at(i);
+      auto char_key = kChars[label + kCharsTotalNumber - classNumber];
+      std::pair<std::string, std::string> ch = identifyGrayChinese(img);
+      if (ch.first == char_key)
+        corrects_all++;
+    }
+    float accuracy_rate = (float)corrects_all / (float)sum_all;
+    std::cout << "Test error_rate: " << (1.f - accuracy_rate) * 100.f << "% "<< std::endl;
+  }
+
+}
+
+cv::Ptr<cv::ml::TrainData> AnnChTrain::tdata() {
+  assert(chars_folder_);
+
+  cv::Mat samples;
+  std::vector<int> labels;
+
+  std::cout << "Collecting chars in " << chars_folder_ << std::endl;
+
+  int classNumber = 0;
+  if (type == 0) classNumber = kCharsTotalNumber;
+  if (type == 1) classNumber = kChineseNumber;
+
+  for (int i = 0; i < classNumber; ++i) {
+    auto char_key = kChars[i + kCharsTotalNumber - classNumber];
+    char sub_folder[512] = {0};
+
+    sprintf(sub_folder, "%s/%s", chars_folder_, char_key);
+    std::cout << "  >> Featuring characters " << char_key << " in "
+              << sub_folder << std::endl;
+
+    auto chars_files = utils::getFiles(sub_folder);
+    for (auto file : chars_files) {
+      auto img = cv::imread(file, 0);  // a grayscale image
+      auto fps = charFeatures2(img, kPredictSize);
+
+      samples.push_back(fps);
+      labels.push_back(i);
+    }
+  }
+
+  cv::Mat samples_;
+  samples.convertTo(samples_, CV_32F);
+  cv::Mat train_classes =
+    cv::Mat::zeros((int)labels.size(), classNumber, CV_32F);
+
+  for (int i = 0; i < train_classes.rows; ++i) {
+    train_classes.at<float>(i, labels[i]) = 1.f;
+  }
+
+  return cv::ml::TrainData::create(samples_, cv::ml::SampleTypes::ROW_SAMPLE,
+                                   train_classes);
+}
+}

src/core/chars_identify.cpp

@@ -0,0 +1,454 @@
+#include "easypr/core/chars_identify.h"
+#include "easypr/core/character.hpp"
+#include "easypr/core/core_func.h"
+#include "easypr/core/feature.h"
+#include "easypr/core/params.h"
+#include "easypr/config.h"
+
+using namespace cv;
+
+namespace easypr {
+
+CharsIdentify* CharsIdentify::instance_ = nullptr;
+
+CharsIdentify* CharsIdentify::instance() {
+  if (!instance_) {
+    instance_ = new CharsIdentify;
+  }
+  return instance_;
+}
+
+CharsIdentify::CharsIdentify() {
+  LOAD_ANN_MODEL(ann_, kDefaultAnnPath);
+  LOAD_ANN_MODEL(annChinese_, kChineseAnnPath);
+  LOAD_ANN_MODEL(annGray_, kGrayAnnPath);
+
+  kv_ = std::shared_ptr<Kv>(new Kv);
+  kv_->load(kChineseMappingPath);
+
+  extractFeature = getGrayPlusProject;
+}
+
+void CharsIdentify::LoadModel(std::string path) {
+  if (path != std::string(kDefaultAnnPath)) {
+    if (!ann_->empty())
+      ann_->clear();
+    LOAD_ANN_MODEL(ann_, path);
+  }
+}
+
+void CharsIdentify::LoadChineseModel(std::string path) {
+  if (path != std::string(kChineseAnnPath)) {
+    if (!annChinese_->empty())
+      annChinese_->clear();
+    LOAD_ANN_MODEL(annChinese_, path);
+  }
+}
+
+void CharsIdentify::LoadGrayChANN(std::string path) {
+  if (path != std::string(kGrayAnnPath)) {
+    if (!annGray_->empty())
+      annGray_->clear();
+    LOAD_ANN_MODEL(annGray_, path);
+  }
+}
+
+void CharsIdentify::LoadChineseMapping(std::string path) {
+  kv_->clear();
+  kv_->load(path);
+}
+
+void CharsIdentify::classify(cv::Mat featureRows, std::vector<int>& out_maxIndexs,
+                             std::vector<float>& out_maxVals, std::vector<bool> isChineseVec){
+  int rowNum = featureRows.rows;
+
+  cv::Mat output(rowNum, kCharsTotalNumber, CV_32FC1);
+  ann_->predict(featureRows, output);
+
+  for (int output_index = 0; output_index < rowNum; output_index++) {
+    Mat output_row = output.row(output_index);
+    int result = 0;
+    float maxVal = -2.f;
+    bool isChinses = isChineseVec[output_index];
+    if (!isChinses) {
+      result = 0;
+      for (int j = 0; j < kCharactersNumber; j++) {
+        float val = output_row.at<float>(j);
+        // std::cout << "j:" << j << "val:" << val << std::endl;
+        if (val > maxVal) {
+          maxVal = val;
+          result = j;
+        }
+      }
+    }
+    else {
+      result = kCharactersNumber;
+      for (int j = kCharactersNumber; j < kCharsTotalNumber; j++) {
+        float val = output_row.at<float>(j);
+        //std::cout << "j:" << j << "val:" << val << std::endl;
+        if (val > maxVal) {
+          maxVal = val;
+          result = j;
+        }
+      }
+    }
+    out_maxIndexs[output_index] = result;
+    out_maxVals[output_index] = maxVal;
+  }
+}
+
+
+void CharsIdentify::classify(std::vector<CCharacter>& charVec){
+  size_t charVecSize = charVec.size();
+
+  if (charVecSize == 0)
+    return;
+
+  Mat featureRows;
+  for (size_t index = 0; index < charVecSize; index++) {
+    Mat charInput = charVec[index].getCharacterMat();
+    Mat feature = charFeatures(charInput, kPredictSize);
+    featureRows.push_back(feature);
+  }
+
+  cv::Mat output(charVecSize, kCharsTotalNumber, CV_32FC1);
+  ann_->predict(featureRows, output);
+
+  for (size_t output_index = 0; output_index < charVecSize; output_index++) {
+    CCharacter& character = charVec[output_index];
+    Mat output_row = output.row(output_index);
+
+    int result = 0;
+    float maxVal = -2.f;
+    std::string label = "";
+
+    bool isChinses = character.getIsChinese();
+    if (!isChinses) {
+      result = 0;
+      for (int j = 0; j < kCharactersNumber; j++) {
+        float val = output_row.at<float>(j);
+        //std::cout << "j:" << j << "val:" << val << std::endl;
+        if (val > maxVal) {
+          maxVal = val;
+          result = j;
+        }
+      }
+      label = std::make_pair(kChars[result], kChars[result]).second;
+    }
+    else {
+      result = kCharactersNumber;
+      for (int j = kCharactersNumber; j < kCharsTotalNumber; j++) {
+        float val = output_row.at<float>(j);
+        //std::cout << "j:" << j << "val:" << val << std::endl;
+        if (val > maxVal) {
+          maxVal = val;
+          result = j;
+        }
+      }
+      const char* key = kChars[result];
+      std::string s = key;
+      std::string province = kv_->get(s);
+      label = std::make_pair(s, province).second;
+    }
+    /*std::cout << "result:" << result << std::endl;
+    std::cout << "maxVal:" << maxVal << std::endl;*/
+    character.setCharacterScore(maxVal);
+    character.setCharacterStr(label);
+  }
+}
+
+
+void CharsIdentify::classifyChineseGray(std::vector<CCharacter>& charVec){
+  size_t charVecSize = charVec.size();
+  if (charVecSize == 0)
+    return;
+
+  Mat featureRows;
+  for (size_t index = 0; index < charVecSize; index++) {
+    Mat charInput = charVec[index].getCharacterMat();
+    cv::Mat feature;
+    extractFeature(charInput, feature);
+    featureRows.push_back(feature);
+  }
+
+  cv::Mat output(charVecSize, kChineseNumber, CV_32FC1);
+  annGray_->predict(featureRows, output);
+
+  for (size_t output_index = 0; output_index < charVecSize; output_index++) {
+    CCharacter& character = charVec[output_index];
+    Mat output_row = output.row(output_index);
+    bool isChinese = true;
+
+    float maxVal = -2;
+    int result = 0;
+
+    for (int j = 0; j < kChineseNumber; j++) {
+      float val = output_row.at<float>(j);
+      //std::cout << "j:" << j << "val:" << val << std::endl;
+      if (val > maxVal) {
+        maxVal = val;
+        result = j;
+      }
+    }
+
+    // no match
+    if (-1 == result) {
+      result = 0;
+      maxVal = 0;
+      isChinese = false;
+    }
+
+    auto index = result + kCharsTotalNumber - kChineseNumber;
+    const char* key = kChars[index];
+    std::string s = key;
+    std::string province = kv_->get(s);
+
+    /*std::cout << "result:" << result << std::endl;
+    std::cout << "maxVal:" << maxVal << std::endl;*/
+
+    character.setCharacterScore(maxVal);
+    character.setCharacterStr(province);
+    character.setIsChinese(isChinese);
+  }
+}
+
+void CharsIdentify::classifyChinese(std::vector<CCharacter>& charVec){
+  size_t charVecSize = charVec.size();
+
+  if (charVecSize == 0)
+    return;
+
+  Mat featureRows;
+  for (size_t index = 0; index < charVecSize; index++) {
+    Mat charInput = charVec[index].getCharacterMat();
+    Mat feature = charFeatures(charInput, kChineseSize);
+    featureRows.push_back(feature);
+  }
+
+  cv::Mat output(charVecSize, kChineseNumber, CV_32FC1);
+  annChinese_->predict(featureRows, output);
+
+  for (size_t output_index = 0; output_index < charVecSize; output_index++) {
+    CCharacter& character = charVec[output_index];
+    Mat output_row = output.row(output_index);
+    bool isChinese = true;
+
+    float maxVal = -2;
+    int result = 0;
+
+    for (int j = 0; j < kChineseNumber; j++) {
+      float val = output_row.at<float>(j);
+      //std::cout << "j:" << j << "val:" << val << std::endl;
+      if (val > maxVal) {
+        maxVal = val;
+        result = j;
+      }
+    }
+
+    // no match
+    if (-1 == result) {
+      result = 0;
+      maxVal = 0;
+      isChinese = false;
+    }
+
+    auto index = result + kCharsTotalNumber - kChineseNumber;
+    const char* key = kChars[index];
+    std::string s = key;
+    std::string province = kv_->get(s);
+
+    /*std::cout << "result:" << result << std::endl;
+    std::cout << "maxVal:" << maxVal << std::endl;*/
+
+    character.setCharacterScore(maxVal);
+    character.setCharacterStr(province);
+    character.setIsChinese(isChinese);
+  }
+}
+
+int CharsIdentify::classify(cv::Mat f, float& maxVal, bool isChinses, bool isAlphabet){
+  int result = 0;
+
+  cv::Mat output(1, kCharsTotalNumber, CV_32FC1);
+  ann_->predict(f, output);
+
+  maxVal = -2.f;
+  if (!isChinses) {
+    if (!isAlphabet) {
+      result = 0;
+      for (int j = 0; j < kCharactersNumber; j++) {
+        float val = output.at<float>(j);
+        // std::cout << "j:" << j << "val:" << val << std::endl;
+        if (val > maxVal) {
+          maxVal = val;
+          result = j;
+        }
+      }
+    }
+    else {
+      result = 0;
+      // begin with 11th char, which is 'A'
+      for (int j = 10; j < kCharactersNumber; j++) {
+        float val = output.at<float>(j);
+        // std::cout << "j:" << j << "val:" << val << std::endl;
+        if (val > maxVal) {
+          maxVal = val;
+          result = j;
+        }
+      }
+    }
+  }
+  else {
+    result = kCharactersNumber;
+    for (int j = kCharactersNumber; j < kCharsTotalNumber; j++) {
+      float val = output.at<float>(j);
+      //std::cout << "j:" << j << "val:" << val << std::endl;
+      if (val > maxVal) {
+        maxVal = val;
+        result = j;
+      }
+    }
+  }
+  //std::cout << "maxVal:" << maxVal << std::endl;
+  return result;
+}
+
+bool CharsIdentify::isCharacter(cv::Mat input, std::string& label, float& maxVal, bool isChinese) {
+  cv::Mat feature = charFeatures(input, kPredictSize);
+  auto index = static_cast<int>(classify(feature, maxVal, isChinese));
+
+  if (isChinese) {
+    //std::cout << "maxVal:" << maxVal << std::endl;
+  }
+
+  float chineseMaxThresh = 0.2f;
+
+  if (maxVal >= 0.9 || (isChinese && maxVal >= chineseMaxThresh)) {
+    if (index < kCharactersNumber) {
+      label = std::make_pair(kChars[index], kChars[index]).second;
+    }
+    else {
+      const char* key = kChars[index];
+      std::string s = key;
+      std::string province = kv_->get(s);
+      label = std::make_pair(s, province).second;
+    }
+    return true;
+  }
+  else
+    return false;
+}
+
+std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input, float& out, bool& isChinese) {
+  cv::Mat feature = charFeatures(input, kChineseSize);
+  float maxVal = -2;
+  int result = 0;
+
+  cv::Mat output(1, kChineseNumber, CV_32FC1);
+  annChinese_->predict(feature, output);
+
+  for (int j = 0; j < kChineseNumber; j++) {
+    float val = output.at<float>(j);
+    //std::cout << "j:" << j << "val:" << val << std::endl;
+    if (val > maxVal) {
+      maxVal = val;
+      result = j;
+    }
+  }
+
+  // no match
+  if (-1 == result) {
+    result = 0;
+    maxVal = 0;
+    isChinese = false;
+  }
+  else if (maxVal > 0.9){
+    isChinese = true;
+  }
+
+  auto index = result + kCharsTotalNumber - kChineseNumber;
+  const char* key = kChars[index];
+  std::string s = key;
+  std::string province = kv_->get(s);
+  out = maxVal;
+
+  return std::make_pair(s, province);
+}
+
+std::pair<std::string, std::string> CharsIdentify::identifyChineseGray(cv::Mat input, float& out, bool& isChinese) {
+  cv::Mat feature;
+  extractFeature(input, feature);
+  float maxVal = -2;
+  int result = 0;
+  cv::Mat output(1, kChineseNumber, CV_32FC1);
+  annGray_->predict(feature, output);
+
+  for (int j = 0; j < kChineseNumber; j++) {
+    float val = output.at<float>(j);
+    //std::cout << "j:" << j << "val:" << val << std::endl;
+    if (val > maxVal) {
+      maxVal = val;
+      result = j;
+    }
+  }
+  // no match
+  if (-1 == result) {
+    result = 0;
+    maxVal = 0;
+    isChinese = false;
+  } else if (maxVal > 0.9){
+    isChinese = true;
+  }
+  auto index = result + kCharsTotalNumber - kChineseNumber;
+  const char* key = kChars[index];
+  std::string s = key;
+  std::string province = kv_->get(s);
+  out = maxVal;
+  return std::make_pair(s, province);
+}
+
+
+std::pair<std::string, std::string> CharsIdentify::identify(cv::Mat input, bool isChinese, bool isAlphabet) {
+  cv::Mat feature = charFeatures(input, kPredictSize);
+  float maxVal = -2;
+  auto index = static_cast<int>(classify(feature, maxVal, isChinese, isAlphabet));
+  if (index < kCharactersNumber) {
+    return std::make_pair(kChars[index], kChars[index]);
+  }
+  else {
+    const char* key = kChars[index];
+    std::string s = key;
+    std::string province = kv_->get(s);
+    return std::make_pair(s, province);
+  }
+}
+
+int CharsIdentify::identify(std::vector<cv::Mat> inputs, std::vector<std::pair<std::string, std::string>>& outputs,
+                            std::vector<bool> isChineseVec) {
+  Mat featureRows;
+  size_t input_size = inputs.size();
+  for (size_t i = 0; i < input_size; i++) {
+    Mat input = inputs[i];
+    cv::Mat feature = charFeatures(input, kPredictSize);
+    featureRows.push_back(feature);
+  }
+
+  std::vector<int> maxIndexs;
+  std::vector<float> maxVals;
+  classify(featureRows, maxIndexs, maxVals, isChineseVec);
+
+  for (size_t row_index = 0; row_index < input_size; row_index++) {
+    int index = maxIndexs[row_index];
+    if (index < kCharactersNumber) {
+      outputs[row_index] = std::make_pair(kChars[index], kChars[index]);
+    }
+    else {
+      const char* key = kChars[index];
+      std::string s = key;
+      std::string province = kv_->get(s);
+      outputs[row_index] = std::make_pair(s, province);
+    }
+  }
+  return 0;
+}
+}

src/core/chars_recognise.cpp

@@ -0,0 +1,117 @@
+#include "easypr/core/chars_recognise.h"
+#include "easypr/core/character.hpp"
+#include "easypr/util/util.h"
+#include <ctime>
+
+namespace easypr {
+
+CCharsRecognise::CCharsRecognise() { m_charsSegment = new CCharsSegment(); }
+
+CCharsRecognise::~CCharsRecognise() { SAFE_RELEASE(m_charsSegment); }
+
+int CCharsRecognise::charsRecognise(Mat plate, std::string& plateLicense) {
+  std::vector<Mat> matChars;
+  int result = m_charsSegment->charsSegment(plate, matChars);
+  if (result == 0) {
+    int num = matChars.size();
+    for (int j = 0; j < num; j++)
+    {
+      Mat charMat = matChars.at(j);
+      bool isChinses = false;
+      float maxVal = 0;
+      if (j == 0) {
+        bool judge = true;
+        isChinses = true;
+        auto character = CharsIdentify::instance()->identifyChinese(charMat, maxVal, judge);
+        plateLicense.append(character.second);
+      }
+      else {
+        isChinses = false;
+        auto character = CharsIdentify::instance()->identify(charMat, isChinses);
+        plateLicense.append(character.second);
+      }
+    }
+
+  }
+  if (plateLicense.size() < 7) {
+    return -1;
+  }
+
+  return result;
+}
+
+
+int CCharsRecognise::charsRecognise(CPlate& plate, std::string& plateLicense) {
+  std::vector<Mat> matChars;
+  std::vector<Mat> grayChars;
+  Mat plateMat = plate.getPlateMat();
+  if (0) writeTempImage(plateMat, "plateMat/plate");
+  Color color;
+  if (plate.getPlateLocateType() == CMSER) {
+    color = plate.getPlateColor();
+  }
+  else {
+    int w = plateMat.cols;
+    int h = plateMat.rows;
+    Mat tmpMat = plateMat(Rect_<double>(w * 0.1, h * 0.1, w * 0.8, h * 0.8));
+    color = getPlateType(tmpMat, true);
+  }
+
+  int result = m_charsSegment->charsSegmentUsingOSTU(plateMat, matChars, grayChars, color);
+
+  if (result == 0) {
+    int num = matChars.size();
+    for (int j = 0; j < num; j++)
+    {
+      Mat charMat = matChars.at(j);
+      Mat grayChar = grayChars.at(j);
+      if (color != Color::BLUE)
+        grayChar = 255 - grayChar;
+
+      bool isChinses = false;
+      std::pair<std::string, std::string> character;
+      float maxVal;
+      if (0 == j) {
+        isChinses = true;
+        bool judge = true;
+        character = CharsIdentify::instance()->identifyChineseGray(grayChar, maxVal, judge);
+        plateLicense.append(character.second);
+
+        // set plate chinese mat and str
+        plate.setChineseMat(grayChar);
+        plate.setChineseKey(character.first);
+        if (0) writeTempImage(grayChar, "char_data/" + character.first + "/chars_");
+      }
+      else if (1 == j) {
+        isChinses = false;
+        bool isAbc = true;
+        character = CharsIdentify::instance()->identify(charMat, isChinses, isAbc);
+        plateLicense.append(character.second);
+      }
+      else {
+        isChinses = false;
+        SHOW_IMAGE(charMat, 0);
+        character = CharsIdentify::instance()->identify(charMat, isChinses);
+        plateLicense.append(character.second);
+      }
+
+      CCharacter charResult;
+      charResult.setCharacterMat(charMat);
+      charResult.setCharacterGrayMat(grayChar);
+      if (isChinses)
+        charResult.setCharacterStr(character.first);
+      else
+        charResult.setCharacterStr(character.second);
+
+      plate.addReutCharacter(charResult);
+    }
+    if (plateLicense.size() < 7) {
+      return -1;
+    }
+  }
+
+  return result;
+}
+
+
+}

src/core/feature.cpp

@@ -0,0 +1,466 @@
+#include "easypr/core/feature.h"
+#include "easypr/core/core_func.h"
+#include "thirdparty/LBP/lbp.hpp"
+
+namespace easypr {
+
+
+Mat getHistogram(Mat in) {
+  const int VERTICAL = 0;
+  const int HORIZONTAL = 1;
+
+  // Histogram features
+  Mat vhist = ProjectedHistogram(in, VERTICAL);
+  Mat hhist = ProjectedHistogram(in, HORIZONTAL);
+
+  // Last 10 is the number of moments components
+  int numCols = vhist.cols + hhist.cols;
+
+  Mat out = Mat::zeros(1, numCols, CV_32F);
+
+  int j = 0;
+  for (int i = 0; i < vhist.cols; i++) {
+    out.at<float>(j) = vhist.at<float>(i);
+    j++;
+  }
+  for (int i = 0; i < hhist.cols; i++) {
+    out.at<float>(j) = hhist.at<float>(i);
+    j++;
+  }
+
+  return out;
+}
+
+void getHistogramFeatures(const Mat& image, Mat& features) {
+  Mat grayImage;
+  cvtColor(image, grayImage, CV_RGB2GRAY);
+
+  //grayImage = histeq(grayImage);
+
+  Mat img_threshold;
+  threshold(grayImage, img_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
+  //Mat img_threshold = grayImage.clone();
+  //spatial_ostu(img_threshold, 8, 2, getPlateType(image, false));
+
+  features = getHistogram(img_threshold);
+}
+
+// compute color histom
+void getColorFeatures(const Mat& src, Mat& features) {
+  Mat src_hsv;
+
+  //grayImage = histeq(grayImage);
+  cvtColor(src, src_hsv, CV_BGR2HSV);
+  int channels = src_hsv.channels();
+  int nRows = src_hsv.rows;
+
+  // consider multi channel image
+  int nCols = src_hsv.cols * channels;
+  if (src_hsv.isContinuous()) {
+    nCols *= nRows;
+    nRows = 1;
+  }
+
+  const int sz = 180;
+  int h[sz] = { 0 };
+
+  uchar* p;
+  for (int i = 0; i < nRows; ++i) {
+    p = src_hsv.ptr<uchar>(i);
+    for (int j = 0; j < nCols; j += 3) {
+      int H = int(p[j]);      // 0-180
+      if (H > sz - 1) H = sz - 1;
+      if (H < 0) H = 0;
+      h[H]++;
+    }
+  }
+
+  Mat mhist = Mat::zeros(1, sz, CV_32F);
+  for (int j = 0; j < sz; j++) {
+    mhist.at<float>(j) = (float)h[j];
+  }
+
+  // Normalize histogram
+  double min, max;
+  minMaxLoc(mhist, &min, &max);
+
+  if (max > 0)
+    mhist.convertTo(mhist, -1, 1.0f / max, 0);
+
+  features = mhist;
+}
+
+
+void getHistomPlusColoFeatures(const Mat& image, Mat& features) {
+  // TODO
+  Mat feature1, feature2;
+  getHistogramFeatures(image, feature1);
+  getColorFeatures(image, feature2);
+  hconcat(feature1.reshape(1, 1), feature2.reshape(1, 1), features);
+}
+
+
+void getSIFTFeatures(const Mat& image, Mat& features) {
+  // TODO
+}
+
+
+//HOG Features
+void getHOGFeatures(const Mat& image, Mat& features) {
+  //HOG descripter
+  HOGDescriptor hog(cvSize(128, 64), cvSize(16, 16), cvSize(8, 8), cvSize(8, 8), 3); //these parameters work well
+	std::vector<float> descriptor;
+
+  // resize input image to (128,64) for compute
+	Size dsize = Size(128,64);
+	Mat trainImg = Mat(dsize, CV_32S);
+	resize(image, trainImg, dsize);
+
+  // compute descripter
+	hog.compute(trainImg, descriptor, Size(8, 8));
+
+  // copy the result
+	Mat mat_featrue(descriptor);
+	mat_featrue.copyTo(features);
+}
+
+
+void getHSVHistFeatures(const Mat& image, Mat& features) {
+  // TODO
+}
+
+//! LBP feature
+void getLBPFeatures(const Mat& image, Mat& features) {
+
+  Mat grayImage;
+  cvtColor(image, grayImage, CV_RGB2GRAY);
+
+  Mat lbpimage;
+  lbpimage = libfacerec::olbp(grayImage);
+  Mat lbp_hist = libfacerec::spatial_histogram(lbpimage, 32, 4, 4);
+
+  features = lbp_hist;
+}
+
+Mat charFeatures(Mat in, int sizeData) {
+  const int VERTICAL = 0;
+  const int HORIZONTAL = 1;
+
+  // cut the cetner, will afect 5% perices.
+  Rect _rect = GetCenterRect(in);
+  Mat tmpIn = CutTheRect(in, _rect);
+  //Mat tmpIn = in.clone();
+
+  // Low data feature
+  Mat lowData;
+  resize(tmpIn, lowData, Size(sizeData, sizeData));
+
+  // Histogram features
+  Mat vhist = ProjectedHistogram(lowData, VERTICAL);
+  Mat hhist = ProjectedHistogram(lowData, HORIZONTAL);
+
+  // Last 10 is the number of moments components
+  int numCols = vhist.cols + hhist.cols + lowData.cols * lowData.cols;
+
+  Mat out = Mat::zeros(1, numCols, CV_32F);
+  // Asign values to
+
+  int j = 0;
+  for (int i = 0; i < vhist.cols; i++) {
+    out.at<float>(j) = vhist.at<float>(i);
+    j++;
+  }
+  for (int i = 0; i < hhist.cols; i++) {
+    out.at<float>(j) = hhist.at<float>(i);
+    j++;
+  }
+  for (int x = 0; x < lowData.cols; x++) {
+    for (int y = 0; y < lowData.rows; y++) {
+      out.at<float>(j) += (float)lowData.at <unsigned char>(x, y);
+      j++;
+    }
+  }
+
+  //std::cout << out << std::endl;
+
+  return out;
+}
+
+
+Mat charFeatures2(Mat in, int sizeData) {
+  const int VERTICAL = 0;
+  const int HORIZONTAL = 1;
+
+  // cut the cetner, will afect 5% perices.
+  Rect _rect = GetCenterRect(in);
+  Mat tmpIn = CutTheRect(in, _rect);
+  //Mat tmpIn = in.clone();
+
+  // Low data feature
+  Mat lowData;
+  resize(tmpIn, lowData, Size(sizeData, sizeData));
+
+  // Histogram features
+  Mat vhist = ProjectedHistogram(lowData, VERTICAL);
+  Mat hhist = ProjectedHistogram(lowData, HORIZONTAL);
+
+  // Last 10 is the number of moments components
+  int numCols = vhist.cols + hhist.cols + lowData.cols * lowData.cols;
+
+  Mat out = Mat::zeros(1, numCols, CV_32F);
+
+  int j = 0;
+  for (int i = 0; i < vhist.cols; i++) {
+    out.at<float>(j) = vhist.at<float>(i);
+    j++;
+  }
+  for (int i = 0; i < hhist.cols; i++) {
+    out.at<float>(j) = hhist.at<float>(i);
+    j++;
+  }
+  for (int x = 0; x < lowData.cols; x++) {
+    for (int y = 0; y < lowData.rows; y++) {
+      out.at<float>(j) += (float)lowData.at <unsigned char>(x, y);
+      j++;
+    }
+  }
+
+  //std::cout << out << std::endl;
+
+  return out;
+}
+
+Mat charProjectFeatures(const Mat& in, int sizeData) {
+  const int VERTICAL = 0;
+  const int HORIZONTAL = 1;
+
+  SHOW_IMAGE(in, 0);
+  // cut the cetner, will afect 5% perices.
+
+  Mat lowData;
+  resize(in, lowData, Size(sizeData, sizeData));
+
+  SHOW_IMAGE(lowData, 0);
+  // Histogram features
+  Mat vhist = ProjectedHistogram(lowData, VERTICAL);
+  Mat hhist = ProjectedHistogram(lowData, HORIZONTAL);
+
+  // Last 10 is the number of moments components
+  int numCols = vhist.cols + hhist.cols;
+
+  Mat out = Mat::zeros(1, numCols, CV_32F);
+
+  int j = 0;
+  for (int i = 0; i < vhist.cols; i++) {
+    out.at<float>(j) = vhist.at<float>(i);
+    j++;
+  }
+  for (int i = 0; i < hhist.cols; i++) {
+    out.at<float>(j) = hhist.at<float>(i);
+    j++;
+  }
+  //std::cout << out << std::endl;
+
+  return out;
+}
+
+void getGrayCharFeatures(const Mat& grayChar, Mat& features) {
+  // TODO: check channnels == 1
+  SHOW_IMAGE(grayChar, 0);
+  SHOW_IMAGE(255 - grayChar, 0);
+
+  // resize to uniform size, like 20x32
+  bool useResize = false;
+  bool useConvert = true;
+  bool useMean = true;
+  bool useLBP = false;
+
+  Mat char_mat;
+  if (useResize) {
+    char_mat.create(kGrayCharHeight, kGrayCharWidth, CV_8UC1);
+    resize(grayChar, char_mat, char_mat.size(), 0, 0, INTER_LINEAR);
+  } else {
+    char_mat = grayChar;
+  }
+  SHOW_IMAGE(char_mat, 0);
+
+  // convert to float
+  Mat float_img;
+  if (useConvert) {
+    float scale = 1.f / 255;
+    char_mat.convertTo(float_img, CV_32FC1, scale, 0);
+  } else {
+    float_img = char_mat;
+  }
+  SHOW_IMAGE(float_img, 0);
+
+  // cut from mean, it can be optional
+
+  Mat mean_img;
+  if (useMean) {
+    float_img -= mean(float_img);
+    mean_img = float_img;
+  } else {
+    mean_img = float_img;
+  }
+  SHOW_IMAGE(mean_img, 0);
+
+  // use lbp to get features, it can be changed to other
+  Mat feautreImg;
+  if (useLBP) {
+    Mat lbpimage = libfacerec::olbp(char_mat);
+    SHOW_IMAGE(lbpimage, 0);
+    feautreImg = libfacerec::spatial_histogram(lbpimage, kCharLBPPatterns, kCharLBPGridX, kCharLBPGridY);
+  } else {
+    feautreImg = mean_img.reshape(1, 1);
+  }
+
+  // return back
+  features = feautreImg;
+}
+
+
+void getGrayPlusProject(const Mat& grayChar, Mat& features)
+{
+  // TODO: check channnels == 1
+  SHOW_IMAGE(grayChar, 0);
+  SHOW_IMAGE(255 - grayChar, 0);
+
+  // resize to uniform size, like 20x32
+  bool useResize = false;
+  bool useConvert = true;
+  bool useMean = true;
+  bool useLBP = false;
+
+  Mat char_mat;
+  if (useResize) {
+    char_mat.create(kGrayCharHeight, kGrayCharWidth, CV_8UC1);
+    resize(grayChar, char_mat, char_mat.size(), 0, 0, INTER_LINEAR);
+  }
+  else {
+    char_mat = grayChar;
+  }
+  SHOW_IMAGE(char_mat, 0);
+
+  // convert to float
+  Mat float_img;
+  if (useConvert) {
+    float scale = 1.f / 255;
+    char_mat.convertTo(float_img, CV_32FC1, scale, 0);
+  }
+  else {
+    float_img = char_mat;
+  }
+  SHOW_IMAGE(float_img, 0);
+
+  // cut from mean, it can be optional
+
+  Mat mean_img;
+  if (useMean) {
+    float_img -= mean(float_img);
+    mean_img = float_img;
+  }
+  else {
+    mean_img = float_img;
+  }
+  SHOW_IMAGE(mean_img, 0);
+
+  // use lbp to get features, it can be changed to other
+  Mat feautreImg;
+  if (useLBP) {
+    Mat lbpimage = libfacerec::olbp(char_mat);
+    SHOW_IMAGE(lbpimage, 0);
+    feautreImg = libfacerec::spatial_histogram(lbpimage, kCharLBPPatterns, kCharLBPGridX, kCharLBPGridY);
+  }
+  else {
+    feautreImg = mean_img.reshape(1, 1);
+  }
+  SHOW_IMAGE(grayChar, 0);
+  Mat binaryChar;
+  threshold(grayChar, binaryChar, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
+  SHOW_IMAGE(binaryChar, 0);
+  Mat projectFeature = charProjectFeatures(binaryChar, 32);
+
+  hconcat(feautreImg.reshape(1, 1), projectFeature.reshape(1, 1), features);
+}
+
+
+void getGrayPlusLBP(const Mat& grayChar, Mat& features)
+{
+  // TODO: check channnels == 1
+  SHOW_IMAGE(grayChar, 0);
+  SHOW_IMAGE(255 - grayChar, 0);
+
+  // resize to uniform size, like 20x32
+  bool useResize = false;
+  bool useConvert = true;
+  bool useMean = true;
+  bool useLBP = true;
+
+  Mat char_mat;
+  if (useResize) {
+    char_mat.create(kGrayCharHeight, kGrayCharWidth, CV_8UC1);
+    resize(grayChar, char_mat, char_mat.size(), 0, 0, INTER_LINEAR);
+  }
+  else {
+    char_mat = grayChar;
+  }
+  SHOW_IMAGE(char_mat, 0);
+
+  // convert to float
+  Mat float_img;
+  if (useConvert) {
+    float scale = 1.f / 255;
+    char_mat.convertTo(float_img, CV_32FC1, scale, 0);
+  }
+  else {
+    float_img = char_mat;
+  }
+  SHOW_IMAGE(float_img, 0);
+
+  // cut from mean, it can be optional
+
+  Mat mean_img;
+  if (useMean) {
+    float_img -= mean(float_img);
+    mean_img = float_img;
+  }
+  else {
+    mean_img = float_img;
+  }
+  SHOW_IMAGE(mean_img, 0);
+
+  // use lbp to get features, it can be changed to other
+  Mat originImage = mean_img.clone();
+  Mat lbpimage = libfacerec::olbp(mean_img);
+  SHOW_IMAGE(lbpimage, 0);
+  lbpimage = libfacerec::spatial_histogram(lbpimage, kCharLBPPatterns, kCharLBPGridX, kCharLBPGridY);
+
+  // 32x20 + 16x16
+  hconcat(mean_img.reshape(1, 1), lbpimage.reshape(1, 1), features);
+}
+
+void getLBPplusHistFeatures(const Mat& image, Mat& features) {
+  Mat grayImage;
+  cvtColor(image, grayImage, CV_RGB2GRAY);
+
+  Mat lbpimage;
+  lbpimage = libfacerec::olbp(grayImage);
+  Mat lbp_hist = libfacerec::spatial_histogram(lbpimage, 64, 8, 4);
+  //features = lbp_hist.reshape(1, 1);
+
+  Mat greyImage;
+  cvtColor(image, greyImage, CV_RGB2GRAY);
+
+  //grayImage = histeq(grayImage);
+  Mat img_threshold;
+  threshold(greyImage, img_threshold, 0, 255,
+    CV_THRESH_OTSU + CV_THRESH_BINARY);
+  Mat histomFeatures = getHistogram(img_threshold);
+
+  hconcat(lbp_hist.reshape(1, 1), histomFeatures.reshape(1, 1), features);
+  //std::cout << features << std::endl;
+  //features = histomFeatures;
+}
+
+}

src/core/params.cpp

@@ -0,0 +1,12 @@
+#include "easypr/core/params.h"
+
+namespace easypr {
+  CParams* CParams::instance_ = nullptr;
+
+  CParams* CParams::instance() {
+    if (!instance_) {
+      instance_ = new CParams;
+    }
+    return instance_;
+  }
+}/*! \namespace easypr*/

src/core/plate_detect.cpp

@@ -0,0 +1,77 @@
+#include "easypr/core/plate_detect.h"
+#include "easypr/util/util.h"
+#include "easypr/core/core_func.h"
+#include "easypr/config.h"
+
+namespace easypr {
+
+  CPlateDetect::CPlateDetect() {
+    m_plateLocate = new CPlateLocate();
+    m_maxPlates = 3;
+    m_type = 0;
+    m_showDetect = false;
+  }
+
+  CPlateDetect::~CPlateDetect() { SAFE_RELEASE(m_plateLocate); }
+
+  int CPlateDetect::plateDetect(Mat src, std::vector<CPlate> &resultVec, int type,
+    bool showDetectArea, int img_index) {
+    std::vector<CPlate> sobel_Plates;
+    sobel_Plates.reserve(16);
+    std::vector<CPlate> color_Plates;
+    color_Plates.reserve(16);
+    std::vector<CPlate> mser_Plates;
+    mser_Plates.reserve(16);
+    std::vector<CPlate> all_result_Plates;
+    all_result_Plates.reserve(64);
+#pragma omp parallel sections
+    {
+#pragma omp section
+      {
+        if (!type || type & PR_DETECT_SOBEL) {
+          m_plateLocate->plateSobelLocate(src, sobel_Plates, img_index);
+        }
+      }
+#pragma omp section
+      {
+        if (!type || type & PR_DETECT_COLOR) {
+          m_plateLocate->plateColorLocate(src, color_Plates, img_index);
+        }
+      }
+#pragma omp section
+      {
+        if (!type || type & PR_DETECT_CMSER) {
+          m_plateLocate->plateMserLocate(src, mser_Plates, img_index);
+        }
+      }
+    }
+    for (auto plate : sobel_Plates) {
+      plate.setPlateLocateType(SOBEL);
+      all_result_Plates.push_back(plate);
+    }
+    for (auto plate : color_Plates) {
+      plate.setPlateLocateType(COLOR);
+      all_result_Plates.push_back(plate);
+    }
+    for (auto plate : mser_Plates) {
+      plate.setPlateLocateType(CMSER);
+      all_result_Plates.push_back(plate);
+    }
+    // use nms to judge plate
+    PlateJudge::instance()->plateJudgeUsingNMS(all_result_Plates, resultVec, m_maxPlates);
+
+    if (0)
+      showDectectResults(src, resultVec, m_maxPlates);
+    return 0;
+  }
+
+  int CPlateDetect::plateDetect(Mat src, std::vector<CPlate> &resultVec, int img_index) {
+    int result = plateDetect(src, resultVec, m_type, false, img_index);
+    return result;
+  }
+
+  void CPlateDetect::LoadSVM(std::string path) {
+    PlateJudge::instance()->LoadModel(path);
+  }
+
+}

src/core/plate_judge.cpp

@@ -0,0 +1,193 @@
+#include "easypr/core/plate_judge.h"
+#include "easypr/config.h"
+#include "easypr/core/core_func.h"
+#include "easypr/core/params.h"
+
+namespace easypr {
+
+  PlateJudge* PlateJudge::instance_ = nullptr;
+
+  PlateJudge* PlateJudge::instance() {
+    if (!instance_) {
+      instance_ = new PlateJudge;
+    }
+    return instance_;
+  }
+
+  PlateJudge::PlateJudge() { 
+    bool useLBP = false;
+    if (useLBP) {
+      LOAD_SVM_MODEL(svm_, kLBPSvmPath);
+      extractFeature = getLBPFeatures;
+    }
+    else {
+      LOAD_SVM_MODEL(svm_, kHistSvmPath);
+      extractFeature = getHistomPlusColoFeatures;
+    }
+  }
+
+  void PlateJudge::LoadModel(std::string path) {
+    if (path != std::string(kDefaultSvmPath)) {
+      if (!svm_->empty())
+        svm_->clear();
+      LOAD_SVM_MODEL(svm_, path);
+    }
+  }
+
+  // set the score of plate
+  // 0 is plate, -1 is not.
+  int PlateJudge::plateSetScore(CPlate& plate) {
+    Mat features;
+    extractFeature(plate.getPlateMat(), features);
+    float score = svm_->predict(features, noArray(), cv::ml::StatModel::Flags::RAW_OUTPUT);
+    //std::cout << "score:" << score << std::endl;
+    if (0) {
+      imshow("plate", plate.getPlateMat());
+      waitKey(0);
+      destroyWindow("plate");
+    }
+    // score is the distance of margin，below zero is plate, up is not
+    // when score is below zero, the samll the value, the more possibliy to be a plate.
+    plate.setPlateScore(score);
+    if (score < 0.5) return 0;
+    else return -1;      
+  }
+
+  int PlateJudge::plateJudge(const Mat& plateMat) {
+    CPlate plate;
+    plate.setPlateMat(plateMat);
+    return plateSetScore(plate);
+  }
+
+  int PlateJudge::plateJudge(const std::vector<Mat> &inVec,
+    std::vector<Mat> &resultVec) {
+    int num = inVec.size();
+    for (int j = 0; j < num; j++) {
+      Mat inMat = inVec[j];
+
+      int response = -1;
+      response = plateJudge(inMat);
+
+      if (response == 0) resultVec.push_back(inMat);
+    }
+    return 0;
+  }
+
+  int PlateJudge::plateJudge(const std::vector<CPlate> &inVec,
+    std::vector<CPlate> &resultVec) {
+    int num = inVec.size();
+    for (int j = 0; j < num; j++) {
+      CPlate inPlate = inVec[j];
+      Mat inMat = inPlate.getPlateMat();
+      int response = -1;
+      response = plateJudge(inMat);
+
+      if (response == 0)
+        resultVec.push_back(inPlate);
+      else {
+        int w = inMat.cols;
+        int h = inMat.rows;
+        Mat tmpmat = inMat(Rect_<double>(w * 0.05, h * 0.1, w * 0.9, h * 0.8));
+        Mat tmpDes = inMat.clone();
+        resize(tmpmat, tmpDes, Size(inMat.size()));
+
+        response = plateJudge(tmpDes);
+        if (response == 0) resultVec.push_back(inPlate);
+      }
+    }
+    return 0;
+  }
+
+  // non-maximum suppression
+  void NMS(std::vector<CPlate> &inVec, std::vector<CPlate> &resultVec, double overlap) {
+    std::sort(inVec.begin(), inVec.end());
+    std::vector<CPlate>::iterator it = inVec.begin();
+    for (; it != inVec.end(); ++it) {
+      CPlate plateSrc = *it;
+      //std::cout << "plateScore:" << plateSrc.getPlateScore() << std::endl;
+      Rect rectSrc = plateSrc.getPlatePos().boundingRect();
+      std::vector<CPlate>::iterator itc = it + 1;
+      for (; itc != inVec.end();) {
+        CPlate plateComp = *itc;
+        Rect rectComp = plateComp.getPlatePos().boundingRect();
+        float iou = computeIOU(rectSrc, rectComp);
+        if (iou > overlap) {
+          itc = inVec.erase(itc);
+        }
+        else {
+          ++itc;
+        }
+      }
+    }
+    resultVec = inVec;
+  }
+
+  // judge plate using nms
+  int PlateJudge::plateJudgeUsingNMS(const std::vector<CPlate> &inVec, std::vector<CPlate> &resultVec, int maxPlates) {
+    std::vector<CPlate> plateVec;
+    int num = inVec.size();
+    bool useCascadeJudge = true;
+
+    for (int j = 0; j < num; j++) {
+      CPlate plate = inVec[j];
+      Mat inMat = plate.getPlateMat();
+      int result = plateSetScore(plate);
+      if (0 == result) {
+        if (0) {
+          imshow("inMat", inMat);
+          waitKey(0);
+          destroyWindow("inMat");
+        }
+
+        if (plate.getPlateLocateType() == CMSER) {
+          int w = inMat.cols;
+          int h = inMat.rows;
+          Mat tmpmat = inMat(Rect_<double>(w * 0.05, h * 0.1, w * 0.9, h * 0.8));
+          Mat tmpDes = inMat.clone();
+          resize(tmpmat, tmpDes, Size(inMat.size()));
+          plate.setPlateMat(tmpDes);
+          if (useCascadeJudge) {
+            int resultCascade = plateSetScore(plate);
+            if (plate.getPlateLocateType() != CMSER)
+              plate.setPlateMat(inMat);
+            if (resultCascade == 0) {
+              if (0) {
+                imshow("tmpDes", tmpDes);
+                waitKey(0);
+                destroyWindow("tmpDes");
+              }
+              plateVec.push_back(plate);
+            }
+          }
+          else 
+            plateVec.push_back(plate);
+        }
+        else 
+          plateVec.push_back(plate);                  
+      }
+    }
+
+    std::vector<CPlate> reDupPlateVec;
+    double overlap = 0.5;
+    // double overlap = CParams::instance()->getParam1f();
+    // use NMS to get the result plates
+    NMS(plateVec, reDupPlateVec, overlap);
+    // sort the plates due to their scores
+    std::sort(reDupPlateVec.begin(), reDupPlateVec.end());
+    // output the plate judge plates
+    std::vector<CPlate>::iterator it = reDupPlateVec.begin();
+    int count = 0;
+    for (; it != reDupPlateVec.end(); ++it) {
+      resultVec.push_back(*it);
+      if (0) {
+        imshow("plateMat", it->getPlateMat());
+        waitKey(0);
+        destroyWindow("plateMat");
+      }
+      count++;
+      if (count >= maxPlates)
+        break;
+    }
+    return 0;
+  }
+}

src/core/plate_locate.cpp

@@ -0,0 +1,999 @@
+#include "easypr/core/plate_locate.h"
+#include "easypr/core/core_func.h"
+#include "easypr/util/util.h"
+#include "easypr/core/params.h"
+
+using namespace std;
+
+namespace easypr {
+
+const float DEFAULT_ERROR = 0.9f;    // 0.6
+const float DEFAULT_ASPECT = 3.75f;  // 3.75
+
+CPlateLocate::CPlateLocate() {
+  m_GaussianBlurSize = DEFAULT_GAUSSIANBLUR_SIZE;
+  m_MorphSizeWidth = DEFAULT_MORPH_SIZE_WIDTH;
+  m_MorphSizeHeight = DEFAULT_MORPH_SIZE_HEIGHT;
+
+  m_error = DEFAULT_ERROR;
+  m_aspect = DEFAULT_ASPECT;
+  m_verifyMin = DEFAULT_VERIFY_MIN;
+  m_verifyMax = DEFAULT_VERIFY_MAX;
+
+  m_angle = DEFAULT_ANGLE;
+
+  m_debug = DEFAULT_DEBUG;
+}
+
+void CPlateLocate::setLifemode(bool param) {
+  if (param) {
+    setGaussianBlurSize(5);
+    setMorphSizeWidth(10);
+    setMorphSizeHeight(3);
+    setVerifyError(0.75);
+    setVerifyAspect(4.0);
+    setVerifyMin(1);
+    setVerifyMax(200);
+  } else {
+    setGaussianBlurSize(DEFAULT_GAUSSIANBLUR_SIZE);
+    setMorphSizeWidth(DEFAULT_MORPH_SIZE_WIDTH);
+    setMorphSizeHeight(DEFAULT_MORPH_SIZE_HEIGHT);
+    setVerifyError(DEFAULT_ERROR);
+    setVerifyAspect(DEFAULT_ASPECT);
+    setVerifyMin(DEFAULT_VERIFY_MIN);
+    setVerifyMax(DEFAULT_VERIFY_MAX);
+  }
+}
+
+bool CPlateLocate::verifySizes(RotatedRect mr) {
+  float error = m_error;
+  // Spain car plate size: 52x11 aspect 4,7272
+  // China car plate size: 440mm*140mm，aspect 3.142857
+
+  // Real car plate size: 136 * 32, aspect 4
+  float aspect = m_aspect;
+
+  // Set a min and max area. All other patchs are discarded
+  // int min= 1*aspect*1; // minimum area
+  // int max= 2000*aspect*2000; // maximum area
+  int min = 34 * 8 * m_verifyMin;  // minimum area
+  int max = 34 * 8 * m_verifyMax;  // maximum area
+
+  // Get only patchs that match to a respect ratio.
+  float rmin = aspect - aspect * error;
+  float rmax = aspect + aspect * error;
+
+  float area = mr.size.height * mr.size.width;
+  float r = (float) mr.size.width / (float) mr.size.height;
+  if (r < 1) r = (float) mr.size.height / (float) mr.size.width;
+
+  // cout << "area:" << area << endl;
+  // cout << "r:" << r << endl;
+
+  if ((area < min || area > max) || (r < rmin || r > rmax))
+    return false;
+  else
+    return true;
+}
+
+//! mser search method
+int CPlateLocate::mserSearch(const Mat &src,  vector<Mat> &out,
+  vector<vector<CPlate>>& out_plateVec, bool usePlateMser, vector<vector<RotatedRect>>& out_plateRRect,
+  int img_index, bool showDebug) {
+  vector<Mat> match_grey;
+
+  vector<CPlate> plateVec_blue;
+  plateVec_blue.reserve(16);
+  vector<RotatedRect> plateRRect_blue;
+  plateRRect_blue.reserve(16);
+
+  vector<CPlate> plateVec_yellow;
+  plateVec_yellow.reserve(16);
+
+  vector<RotatedRect> plateRRect_yellow;
+  plateRRect_yellow.reserve(16);
+
+  mserCharMatch(src, match_grey, plateVec_blue, plateVec_yellow, usePlateMser, plateRRect_blue, plateRRect_yellow, img_index, showDebug);
+
+  out_plateVec.push_back(plateVec_blue);
+  out_plateVec.push_back(plateVec_yellow);
+
+  out_plateRRect.push_back(plateRRect_blue);
+  out_plateRRect.push_back(plateRRect_yellow);
+
+  out = match_grey;
+
+  return 0;
+}
+
+
+int CPlateLocate::colorSearch(const Mat &src, const Color r, Mat &out,
+                              vector<RotatedRect> &outRects) {
+  Mat match_grey;
+
+  // width is important to the final results;
+  const int color_morph_width = 10;
+  const int color_morph_height = 2;
+
+  colorMatch(src, match_grey, r, false);
+  SHOW_IMAGE(match_grey, 0);
+
+  Mat src_threshold;
+  threshold(match_grey, src_threshold, 0, 255,
+            CV_THRESH_OTSU + CV_THRESH_BINARY);
+
+  Mat element = getStructuringElement(
+      MORPH_RECT, Size(color_morph_width, color_morph_height));
+  morphologyEx(src_threshold, src_threshold, MORPH_CLOSE, element);
+
+  //if (m_debug) {
+  //  utils::imwrite("resources/image/tmp/color.jpg", src_threshold);
+  //}
+
+  src_threshold.copyTo(out);
+
+
+  vector<vector<Point>> contours;
+
+  findContours(src_threshold,
+               contours,               // a vector of contours
+               CV_RETR_EXTERNAL,
+               CV_CHAIN_APPROX_NONE);  // all pixels of each contours
+
+  vector<vector<Point>>::iterator itc = contours.begin();
+  while (itc != contours.end()) {
+    RotatedRect mr = minAreaRect(Mat(*itc));
+
+    if (!verifySizes(mr))
+      itc = contours.erase(itc);
+    else {
+      ++itc;
+      outRects.push_back(mr);
+    }
+  }
+
+  return 0;
+}
+
+
+int CPlateLocate::sobelFrtSearch(const Mat &src,
+                                 vector<Rect_<float>> &outRects) {
+  Mat src_threshold;
+
+  sobelOper(src, src_threshold, m_GaussianBlurSize, m_MorphSizeWidth,
+            m_MorphSizeHeight);
+
+  vector<vector<Point>> contours;
+  findContours(src_threshold,
+               contours,               // a vector of contours
+               CV_RETR_EXTERNAL,
+               CV_CHAIN_APPROX_NONE);  // all pixels of each contours
+
+  vector<vector<Point>>::iterator itc = contours.begin();
+
+  vector<RotatedRect> first_rects;
+
+  while (itc != contours.end()) {
+    RotatedRect mr = minAreaRect(Mat(*itc));
+
+
+    if (verifySizes(mr)) {
+      first_rects.push_back(mr);
+
+      float area = mr.size.height * mr.size.width;
+      float r = (float) mr.size.width / (float) mr.size.height;
+      if (r < 1) r = (float) mr.size.height / (float) mr.size.width;
+    }
+
+    ++itc;
+  }
+
+  for (size_t i = 0; i < first_rects.size(); i++) {
+    RotatedRect roi_rect = first_rects[i];
+
+    Rect_<float> safeBoundRect;
+    if (!calcSafeRect(roi_rect, src, safeBoundRect)) continue;
+
+    outRects.push_back(safeBoundRect);
+  }
+  return 0;
+}
+
+
+int CPlateLocate::sobelSecSearchPart(Mat &bound, Point2f refpoint,
+                                     vector<RotatedRect> &outRects) {
+  Mat bound_threshold;
+
+  sobelOperT(bound, bound_threshold, 3, 6, 2);
+
+  Mat tempBoundThread = bound_threshold.clone();
+
+  clearLiuDingOnly(tempBoundThread);
+
+  int posLeft = 0, posRight = 0;
+  if (bFindLeftRightBound(tempBoundThread, posLeft, posRight)) {
+
+    // find left and right bounds to repair
+
+    if (posRight != 0 && posLeft != 0 && posLeft < posRight) {
+      int posY = int(bound_threshold.rows * 0.5);
+      for (int i = posLeft + (int) (bound_threshold.rows * 0.1);
+           i < posRight - 4; i++) {
+        bound_threshold.data[posY * bound_threshold.cols + i] = 255;
+      }
+    }
+
+    utils::imwrite("resources/image/tmp/repaireimg1.jpg", bound_threshold);
+
+    // remove the left and right boundaries
+
+    for (int i = 0; i < bound_threshold.rows; i++) {
+      bound_threshold.data[i * bound_threshold.cols + posLeft] = 0;
+      bound_threshold.data[i * bound_threshold.cols + posRight] = 0;
+    }
+    utils::imwrite("resources/image/tmp/repaireimg2.jpg", bound_threshold);
+  }
+
+  vector<vector<Point>> contours;
+  findContours(bound_threshold,
+               contours,               // a vector of contours
+               CV_RETR_EXTERNAL,
+               CV_CHAIN_APPROX_NONE);  // all pixels of each contours
+
+  vector<vector<Point>>::iterator itc = contours.begin();
+
+  vector<RotatedRect> second_rects;
+  while (itc != contours.end()) {
+    RotatedRect mr = minAreaRect(Mat(*itc));
+    second_rects.push_back(mr);
+    ++itc;
+  }
+
+  for (size_t i = 0; i < second_rects.size(); i++) {
+    RotatedRect roi = second_rects[i];
+    if (verifySizes(roi)) {
+      Point2f refcenter = roi.center + refpoint;
+      Size2f size = roi.size;
+      float angle = roi.angle;
+
+      RotatedRect refroi(refcenter, size, angle);
+      outRects.push_back(refroi);
+    }
+  }
+
+  return 0;
+}
+
+
+int CPlateLocate::sobelSecSearch(Mat &bound, Point2f refpoint,
+                                 vector<RotatedRect> &outRects) {
+  Mat bound_threshold;
+
+
+  sobelOper(bound, bound_threshold, 3, 10, 3);
+
+  utils::imwrite("resources/image/tmp/sobelSecSearch.jpg", bound_threshold);
+
+  vector<vector<Point>> contours;
+  findContours(bound_threshold,
+               contours,               // a vector of contours
+               CV_RETR_EXTERNAL,
+               CV_CHAIN_APPROX_NONE);  // all pixels of each contours
+
+  vector<vector<Point>>::iterator itc = contours.begin();
+
+  vector<RotatedRect> second_rects;
+  while (itc != contours.end()) {
+    RotatedRect mr = minAreaRect(Mat(*itc));
+    second_rects.push_back(mr);
+    ++itc;
+  }
+
+  for (size_t i = 0; i < second_rects.size(); i++) {
+    RotatedRect roi = second_rects[i];
+    if (verifySizes(roi)) {
+      Point2f refcenter = roi.center + refpoint;
+      Size2f size = roi.size;
+      float angle = roi.angle;
+
+      RotatedRect refroi(refcenter, size, angle);
+      outRects.push_back(refroi);
+    }
+  }
+
+  return 0;
+}
+
+
+int CPlateLocate::sobelOper(const Mat &in, Mat &out, int blurSize, int morphW,
+                            int morphH) {
+  Mat mat_blur;
+  mat_blur = in.clone();
+  GaussianBlur(in, mat_blur, Size(blurSize, blurSize), 0, 0, BORDER_DEFAULT);
+
+  Mat mat_gray;
+  if (mat_blur.channels() == 3)
+    cvtColor(mat_blur, mat_gray, CV_RGB2GRAY);
+  else
+    mat_gray = mat_blur;
+
+  int scale = SOBEL_SCALE;
+  int delta = SOBEL_DELTA;
+  int ddepth = SOBEL_DDEPTH;
+
+  Mat grad_x, grad_y;
+  Mat abs_grad_x, abs_grad_y;
+
+
+  Sobel(mat_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
+  convertScaleAbs(grad_x, abs_grad_x);
+
+  Mat grad;
+  addWeighted(abs_grad_x, SOBEL_X_WEIGHT, 0, 0, 0, grad);
+
+  Mat mat_threshold;
+  double otsu_thresh_val =
+      threshold(grad, mat_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
+
+
+  Mat element = getStructuringElement(MORPH_RECT, Size(morphW, morphH));
+  morphologyEx(mat_threshold, mat_threshold, MORPH_CLOSE, element);
+
+  out = mat_threshold;
+
+  return 0;
+}
+
+void deleteNotArea(Mat &inmat, Color color = UNKNOWN) {
+  Mat input_grey;
+  cvtColor(inmat, input_grey, CV_BGR2GRAY);
+
+  int w = inmat.cols;
+  int h = inmat.rows;
+
+  Mat tmpMat = inmat(Rect_<double>(w * 0.15, h * 0.1, w * 0.7, h * 0.7));
+
+  Color plateType;
+  if (UNKNOWN == color) {
+    plateType = getPlateType(tmpMat, true);
+  }
+  else {
+    plateType = color;
+  }
+
+  Mat img_threshold;
+
+  if (BLUE == plateType) {
+    img_threshold = input_grey.clone();
+    Mat tmp = input_grey(Rect_<double>(w * 0.15, h * 0.15, w * 0.7, h * 0.7));
+    int threadHoldV = ThresholdOtsu(tmp);
+
+    threshold(input_grey, img_threshold, threadHoldV, 255, CV_THRESH_BINARY);
+    // threshold(input_grey, img_threshold, 5, 255, CV_THRESH_OTSU +
+    // CV_THRESH_BINARY);
+
+    utils::imwrite("resources/image/tmp/inputgray2.jpg", img_threshold);
+
+  } else if (YELLOW == plateType) {
+    img_threshold = input_grey.clone();
+    Mat tmp = input_grey(Rect_<double>(w * 0.1, h * 0.1, w * 0.8, h * 0.8));
+    int threadHoldV = ThresholdOtsu(tmp);
+
+    threshold(input_grey, img_threshold, threadHoldV, 255,
+              CV_THRESH_BINARY_INV);
+
+    utils::imwrite("resources/image/tmp/inputgray2.jpg", img_threshold);
+
+    // threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU +
+    // CV_THRESH_BINARY_INV);
+  } else
+    threshold(input_grey, img_threshold, 10, 255,
+              CV_THRESH_OTSU + CV_THRESH_BINARY);
+
+  //img_threshold = input_grey.clone();
+  //spatial_ostu(img_threshold, 8, 2, plateType);
+
+  int posLeft = 0;
+  int posRight = 0;
+
+  int top = 0;
+  int bottom = img_threshold.rows - 1;
+  clearLiuDing(img_threshold, top, bottom);
+
+  if (0) {
+    imshow("inmat", inmat);
+    waitKey(0);
+    destroyWindow("inmat");
+  }
+
+  if (bFindLeftRightBound1(img_threshold, posLeft, posRight)) {
+    inmat = inmat(Rect(posLeft, top, w - posLeft, bottom - top));
+    if (0) {
+      imshow("inmat", inmat);
+      waitKey(0);
+      destroyWindow("inmat");
+    }
+  }
+}
+
+
+int CPlateLocate::deskew(const Mat &src, const Mat &src_b,
+                         vector<RotatedRect> &inRects,
+                         vector<CPlate> &outPlates, bool useDeteleArea, Color color) {
+  Mat mat_debug;
+  src.copyTo(mat_debug);
+
+  for (size_t i = 0; i < inRects.size(); i++) {
+    RotatedRect roi_rect = inRects[i];
+
+    float r = (float) roi_rect.size.width / (float) roi_rect.size.height;
+    float roi_angle = roi_rect.angle;
+
+    Size roi_rect_size = roi_rect.size;
+    if (r < 1) {
+      roi_angle = 90 + roi_angle;
+      swap(roi_rect_size.width, roi_rect_size.height);
+    }
+
+    if (m_debug) {
+      Point2f rect_points[4];
+      roi_rect.points(rect_points);
+      for (int j = 0; j < 4; j++)
+        line(mat_debug, rect_points[j], rect_points[(j + 1) % 4],
+             Scalar(0, 255, 255), 1, 8);
+    }
+
+    // changed
+    // rotation = 90 - abs(roi_angle);
+    // rotation < m_angel;
+
+    // m_angle=60
+    if (roi_angle - m_angle < 0 && roi_angle + m_angle > 0) {
+      Rect_<float> safeBoundRect;
+      bool isFormRect = calcSafeRect(roi_rect, src, safeBoundRect);
+      if (!isFormRect) continue;
+
+      Mat bound_mat = src(safeBoundRect);
+      Mat bound_mat_b = src_b(safeBoundRect);
+
+      if (0) {
+        imshow("bound_mat_b", bound_mat_b);
+        waitKey(0);
+        destroyWindow("bound_mat_b");
+      }
+
+      Point2f roi_ref_center = roi_rect.center - safeBoundRect.tl();
+
+      Mat deskew_mat;
+      if ((roi_angle - 5 < 0 && roi_angle + 5 > 0) || 90.0 == roi_angle ||
+          -90.0 == roi_angle) {
+        deskew_mat = bound_mat;
+      } else {
+        Mat rotated_mat;
+        Mat rotated_mat_b;
+
+        if (!rotation(bound_mat, rotated_mat, roi_rect_size, roi_ref_center, roi_angle))
+          continue;
+
+        if (!rotation(bound_mat_b, rotated_mat_b, roi_rect_size, roi_ref_center, roi_angle))
+          continue;
+
+        // we need affine for rotatioed image
+        double roi_slope = 0;
+        // imshow("1roated_mat",rotated_mat);
+        // imshow("rotated_mat_b",rotated_mat_b);
+        if (isdeflection(rotated_mat_b, roi_angle, roi_slope)) {
+          affine(rotated_mat, deskew_mat, roi_slope);
+        } else
+          deskew_mat = rotated_mat;
+      }
+
+      Mat plate_mat;
+      plate_mat.create(HEIGHT, WIDTH, TYPE);
+
+      // haitungaga add，affect 25% to full recognition.
+      if (useDeteleArea)
+        deleteNotArea(deskew_mat, color);
+
+      if (deskew_mat.cols * 1.0 / deskew_mat.rows > 2.3 && deskew_mat.cols * 1.0 / deskew_mat.rows < 6) {
+        if (deskew_mat.cols >= WIDTH || deskew_mat.rows >= HEIGHT)
+          resize(deskew_mat, plate_mat, plate_mat.size(), 0, 0, INTER_AREA);
+        else
+          resize(deskew_mat, plate_mat, plate_mat.size(), 0, 0, INTER_CUBIC);
+
+        CPlate plate;
+        plate.setPlatePos(roi_rect);
+        plate.setPlateMat(plate_mat);
+        if (color != UNKNOWN) plate.setPlateColor(color);
+        outPlates.push_back(plate);
+      }
+    }
+  }
+  return 0;
+}
+
+
+bool CPlateLocate::rotation(Mat &in, Mat &out, const Size rect_size,
+                            const Point2f center, const double angle) {
+  if (0) {
+    imshow("in", in);
+    waitKey(0);
+    destroyWindow("in");
+  }
+
+  Mat in_large;
+  in_large.create(int(in.rows * 1.5), int(in.cols * 1.5), in.type());
+
+  float x = in_large.cols / 2 - center.x > 0 ? in_large.cols / 2 - center.x : 0;
+  float y = in_large.rows / 2 - center.y > 0 ? in_large.rows / 2 - center.y : 0;
+
+  float width = x + in.cols < in_large.cols ? in.cols : in_large.cols - x;
+  float height = y + in.rows < in_large.rows ? in.rows : in_large.rows - y;
+
+  /*assert(width == in.cols);
+  assert(height == in.rows);*/
+
+  if (width != in.cols || height != in.rows) return false;
+
+  Mat imageRoi = in_large(Rect_<float>(x, y, width, height));
+  addWeighted(imageRoi, 0, in, 1, 0, imageRoi);
+
+  Point2f center_diff(in.cols / 2.f, in.rows / 2.f);
+  Point2f new_center(in_large.cols / 2.f, in_large.rows / 2.f);
+
+  Mat rot_mat = getRotationMatrix2D(new_center, angle, 1);
+
+  /*imshow("in_copy", in_large);
+  waitKey(0);*/
+
+  Mat mat_rotated;
+  warpAffine(in_large, mat_rotated, rot_mat, Size(in_large.cols, in_large.rows),
+             CV_INTER_CUBIC);
+
+  /*imshow("mat_rotated", mat_rotated);
+  waitKey(0);*/
+
+  Mat img_crop;
+  getRectSubPix(mat_rotated, Size(rect_size.width, rect_size.height),
+                new_center, img_crop);
+
+  out = img_crop;
+
+  if (0) {
+    imshow("out", out);
+    waitKey(0);
+    destroyWindow("out");
+  }
+
+  /*imshow("img_crop", img_crop);
+  waitKey(0);*/
+
+  return true;
+}
+
+bool CPlateLocate::isdeflection(const Mat &in, const double angle,
+                                double &slope) { /*imshow("in",in);
+                                                waitKey(0);*/
+  if (0) {
+    imshow("in", in);
+    waitKey(0);
+    destroyWindow("in");
+  }
+  
+  int nRows = in.rows;
+  int nCols = in.cols;
+
+  assert(in.channels() == 1);
+
+  int comp_index[3];
+  int len[3];
+
+  comp_index[0] = nRows / 4;
+  comp_index[1] = nRows / 4 * 2;
+  comp_index[2] = nRows / 4 * 3;
+
+  const uchar* p;
+
+  for (int i = 0; i < 3; i++) {
+    int index = comp_index[i];
+    p = in.ptr<uchar>(index);
+
+    int j = 0;
+    int value = 0;
+    while (0 == value && j < nCols) value = int(p[j++]);
+
+    len[i] = j;
+  }
+
+  // cout << "len[0]:" << len[0] << endl;
+  // cout << "len[1]:" << len[1] << endl;
+  // cout << "len[2]:" << len[2] << endl;
+
+  // len[0]/len[1]/len[2] are used to calc the slope
+
+  double maxlen = max(len[2], len[0]);
+  double minlen = min(len[2], len[0]);
+  double difflen = abs(len[2] - len[0]);
+
+  double PI = 3.14159265;
+
+  double g = tan(angle * PI / 180.0);
+
+  if (maxlen - len[1] > nCols / 32 || len[1] - minlen > nCols / 32) {
+
+    double slope_can_1 =
+        double(len[2] - len[0]) / double(comp_index[1]);
+    double slope_can_2 = double(len[1] - len[0]) / double(comp_index[0]);
+    double slope_can_3 = double(len[2] - len[1]) / double(comp_index[0]);
+    // cout<<"angle:"<<angle<<endl;
+    // cout<<"g:"<<g<<endl;
+    // cout << "slope_can_1:" << slope_can_1 << endl;
+    // cout << "slope_can_2:" << slope_can_2 << endl;
+    // cout << "slope_can_3:" << slope_can_3 << endl;
+    // if(g>=0)
+    slope = abs(slope_can_1 - g) <= abs(slope_can_2 - g) ? slope_can_1
+                                                         : slope_can_2;
+    // cout << "slope:" << slope << endl;
+    return true;
+  } else {
+    slope = 0;
+  }
+
+  return false;
+}
+
+
+void CPlateLocate::affine(const Mat &in, Mat &out, const double slope) {
+  // imshow("in", in);
+  // waitKey(0);
+
+  Point2f dstTri[3];
+  Point2f plTri[3];
+
+  float height = (float) in.rows;
+  float width = (float) in.cols;
+  float xiff = (float) abs(slope) * height;
+
+  if (slope > 0) {
+
+    // right, new position is xiff/2
+
+    plTri[0] = Point2f(0, 0);
+    plTri[1] = Point2f(width - xiff - 1, 0);
+    plTri[2] = Point2f(0 + xiff, height - 1);
+
+    dstTri[0] = Point2f(xiff / 2, 0);
+    dstTri[1] = Point2f(width - 1 - xiff / 2, 0);
+    dstTri[2] = Point2f(xiff / 2, height - 1);
+  } else {
+
+    // left, new position is -xiff/2
+
+    plTri[0] = Point2f(0 + xiff, 0);
+    plTri[1] = Point2f(width - 1, 0);
+    plTri[2] = Point2f(0, height - 1);
+
+    dstTri[0] = Point2f(xiff / 2, 0);
+    dstTri[1] = Point2f(width - 1 - xiff + xiff / 2, 0);
+    dstTri[2] = Point2f(xiff / 2, height - 1);
+  }
+
+  Mat warp_mat = getAffineTransform(plTri, dstTri);
+
+  Mat affine_mat;
+  affine_mat.create((int) height, (int) width, TYPE);
+
+  if (in.rows > HEIGHT || in.cols > WIDTH)
+
+    warpAffine(in, affine_mat, warp_mat, affine_mat.size(),
+               CV_INTER_AREA);
+  else
+    warpAffine(in, affine_mat, warp_mat, affine_mat.size(), CV_INTER_CUBIC);
+
+  out = affine_mat;
+}
+
+int CPlateLocate::plateColorLocate(Mat src, vector<CPlate> &candPlates,
+                                   int index) {
+  vector<RotatedRect> rects_color_blue;
+  rects_color_blue.reserve(64);
+  vector<RotatedRect> rects_color_yellow;
+  rects_color_yellow.reserve(64);
+
+  vector<CPlate> plates_blue;
+  plates_blue.reserve(64);
+  vector<CPlate> plates_yellow;
+  plates_yellow.reserve(64);
+
+  Mat src_clone = src.clone();
+
+  Mat src_b_blue;
+  Mat src_b_yellow;
+#pragma omp parallel sections
+  {
+#pragma omp section
+    {
+      colorSearch(src, BLUE, src_b_blue, rects_color_blue);
+      deskew(src, src_b_blue, rects_color_blue, plates_blue, true, BLUE);
+    }
+#pragma omp section
+    {
+      colorSearch(src_clone, YELLOW, src_b_yellow, rects_color_yellow);
+      deskew(src_clone, src_b_yellow, rects_color_yellow, plates_yellow, true, YELLOW);
+    }
+  }
+
+  candPlates.insert(candPlates.end(), plates_blue.begin(), plates_blue.end());
+  candPlates.insert(candPlates.end(), plates_yellow.begin(), plates_yellow.end());
+
+  return 0;
+}
+
+
+//! MSER plate locate
+int CPlateLocate::plateMserLocate(Mat src, vector<CPlate> &candPlates, int img_index) {
+  std::vector<Mat> channelImages;
+  std::vector<Color> flags;
+  flags.push_back(BLUE);
+  flags.push_back(YELLOW);
+
+  bool usePlateMser = false;
+  int scale_size = 1000;
+  //int scale_size = CParams::instance()->getParam1i();
+  double scale_ratio = 1;
+
+  // only conside blue plate
+  if (1) {
+    Mat grayImage;
+    cvtColor(src, grayImage, COLOR_BGR2GRAY);
+    channelImages.push_back(grayImage);
+  }
+
+  for (size_t i = 0; i < channelImages.size(); ++i) {
+    vector<vector<RotatedRect>> plateRRectsVec;
+    vector<vector<CPlate>> platesVec;
+    vector<Mat> src_b_vec;
+
+    Mat channelImage = channelImages.at(i);   
+    Mat image = scaleImage(channelImage, Size(scale_size, scale_size), scale_ratio);
+
+    // vector<RotatedRect> rects;
+    mserSearch(image, src_b_vec, platesVec, usePlateMser, plateRRectsVec, img_index, false);
+
+    for (size_t j = 0; j < flags.size(); j++) {
+      vector<CPlate>& plates = platesVec.at(j);
+      Mat& src_b = src_b_vec.at(j);
+      Color color = flags.at(j);
+
+      vector<RotatedRect> rects_mser;
+      rects_mser.reserve(64);
+      std::vector<CPlate> deskewPlate;
+      deskewPlate.reserve(64);
+      std::vector<CPlate> mserPlate;
+      mserPlate.reserve(64);
+
+      // deskew for rotation and slope image
+      for (auto plate : plates) {
+        RotatedRect rrect = plate.getPlatePos();
+        RotatedRect scaleRect = scaleBackRRect(rrect, (float)scale_ratio);
+        plate.setPlatePos(scaleRect);
+        plate.setPlateColor(color);
+
+        rects_mser.push_back(scaleRect);
+        mserPlate.push_back(plate);
+      }
+
+      Mat resize_src_b;
+      resize(src_b, resize_src_b, Size(channelImage.cols, channelImage.rows));
+
+      deskew(src, resize_src_b, rects_mser, deskewPlate, false, color);
+
+      for (auto dplate : deskewPlate) {
+        RotatedRect drect = dplate.getPlatePos();
+        Mat dmat = dplate.getPlateMat();
+
+        for (auto splate : mserPlate) {
+          RotatedRect srect = splate.getPlatePos();
+          float iou = 0.f;
+          bool isSimilar = computeIOU(drect, srect, src.cols, src.rows, 0.95f, iou);
+          if (isSimilar) {
+            splate.setPlateMat(dmat);
+            candPlates.push_back(splate);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  if (0) {
+    imshow("src", src);
+    waitKey(0);
+    destroyWindow("src");
+  }
+
+  return 0;
+}
+
+int CPlateLocate::sobelOperT(const Mat &in, Mat &out, int blurSize, int morphW,
+                             int morphH) {
+  Mat mat_blur;
+  mat_blur = in.clone();
+  GaussianBlur(in, mat_blur, Size(blurSize, blurSize), 0, 0, BORDER_DEFAULT);
+
+  Mat mat_gray;
+  if (mat_blur.channels() == 3)
+    cvtColor(mat_blur, mat_gray, CV_BGR2GRAY);
+  else
+    mat_gray = mat_blur;
+
+  utils::imwrite("resources/image/tmp/grayblure.jpg", mat_gray);
+
+  // equalizeHist(mat_gray, mat_gray);
+
+  int scale = SOBEL_SCALE;
+  int delta = SOBEL_DELTA;
+  int ddepth = SOBEL_DDEPTH;
+
+  Mat grad_x, grad_y;
+  Mat abs_grad_x, abs_grad_y;
+
+  Sobel(mat_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
+  convertScaleAbs(grad_x, abs_grad_x);
+
+  Mat grad;
+  addWeighted(abs_grad_x, 1, 0, 0, 0, grad);
+
+  utils::imwrite("resources/image/tmp/graygrad.jpg", grad);
+
+  Mat mat_threshold;
+  double otsu_thresh_val =
+      threshold(grad, mat_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
+
+  utils::imwrite("resources/image/tmp/grayBINARY.jpg", mat_threshold);
+
+  Mat element = getStructuringElement(MORPH_RECT, Size(morphW, morphH));
+  morphologyEx(mat_threshold, mat_threshold, MORPH_CLOSE, element);
+
+  utils::imwrite("resources/image/tmp/phologyEx.jpg", mat_threshold);
+
+  out = mat_threshold;
+
+  return 0;
+}
+
+int CPlateLocate::plateSobelLocate(Mat src, vector<CPlate> &candPlates,
+                                   int index) {
+  vector<RotatedRect> rects_sobel_all;
+  rects_sobel_all.reserve(256);
+
+  vector<CPlate> plates;
+  plates.reserve(32);
+
+  vector<Rect_<float>> bound_rects;
+  bound_rects.reserve(256);
+
+  sobelFrtSearch(src, bound_rects);
+
+  vector<Rect_<float>> bound_rects_part;
+  bound_rects_part.reserve(256);
+
+  // enlarge area 
+  for (size_t i = 0; i < bound_rects.size(); i++) {
+    float fRatio = bound_rects[i].width * 1.0f / bound_rects[i].height;
+    if (fRatio < 3.0 && fRatio > 1.0 && bound_rects[i].height < 120) {
+      Rect_<float> itemRect = bound_rects[i];
+
+      itemRect.x = itemRect.x - itemRect.height * (4 - fRatio);
+      if (itemRect.x < 0) {
+        itemRect.x = 0;
+      }
+      itemRect.width = itemRect.width + itemRect.height * 2 * (4 - fRatio);
+      if (itemRect.width + itemRect.x >= src.cols) {
+        itemRect.width = src.cols - itemRect.x;
+      }
+
+      itemRect.y = itemRect.y - itemRect.height * 0.08f;
+      itemRect.height = itemRect.height * 1.16f;
+
+      bound_rects_part.push_back(itemRect);
+    }
+  }
+
+  // second processing to split one
+#pragma omp parallel for
+  for (int i = 0; i < (int)bound_rects_part.size(); i++) {
+    Rect_<float> bound_rect = bound_rects_part[i];
+    Point2f refpoint(bound_rect.x, bound_rect.y);
+
+    float x = bound_rect.x > 0 ? bound_rect.x : 0;
+    float y = bound_rect.y > 0 ? bound_rect.y : 0;
+
+    float width =
+        x + bound_rect.width < src.cols ? bound_rect.width : src.cols - x;
+    float height =
+        y + bound_rect.height < src.rows ? bound_rect.height : src.rows - y;
+
+    Rect_<float> safe_bound_rect(x, y, width, height);
+    Mat bound_mat = src(safe_bound_rect);
+
+    vector<RotatedRect> rects_sobel;
+    rects_sobel.reserve(128);
+    sobelSecSearchPart(bound_mat, refpoint, rects_sobel);
+
+#pragma omp critical
+    {
+      rects_sobel_all.insert(rects_sobel_all.end(), rects_sobel.begin(), rects_sobel.end());
+    }
+  }
+
+#pragma omp parallel for
+  for (int i = 0; i < (int)bound_rects.size(); i++) {
+    Rect_<float> bound_rect = bound_rects[i];
+    Point2f refpoint(bound_rect.x, bound_rect.y);
+
+    float x = bound_rect.x > 0 ? bound_rect.x : 0;
+    float y = bound_rect.y > 0 ? bound_rect.y : 0;
+
+    float width =
+        x + bound_rect.width < src.cols ? bound_rect.width : src.cols - x;
+    float height =
+        y + bound_rect.height < src.rows ? bound_rect.height : src.rows - y;
+
+    Rect_<float> safe_bound_rect(x, y, width, height);
+    Mat bound_mat = src(safe_bound_rect);
+
+    vector<RotatedRect> rects_sobel;
+    rects_sobel.reserve(128);
+    sobelSecSearch(bound_mat, refpoint, rects_sobel);
+
+#pragma omp critical
+    {
+      rects_sobel_all.insert(rects_sobel_all.end(), rects_sobel.begin(), rects_sobel.end());
+    }
+  }
+
+  Mat src_b;
+  sobelOper(src, src_b, 3, 10, 3);
+
+  deskew(src, src_b, rects_sobel_all, plates);
+
+  //for (size_t i = 0; i < plates.size(); i++) 
+  //  candPlates.push_back(plates[i]);
+
+  candPlates.insert(candPlates.end(), plates.begin(), plates.end());
+
+  return 0;
+}
+
+
+int CPlateLocate::plateLocate(Mat src, vector<Mat> &resultVec, int index) {
+  vector<CPlate> all_result_Plates;
+
+  plateColorLocate(src, all_result_Plates, index);
+  plateSobelLocate(src, all_result_Plates, index);
+  plateMserLocate(src, all_result_Plates, index);
+
+  for (size_t i = 0; i < all_result_Plates.size(); i++) {
+    CPlate plate = all_result_Plates[i];
+    resultVec.push_back(plate.getPlateMat());
+  }
+
+  return 0;
+}
+
+int CPlateLocate::plateLocate(Mat src, vector<CPlate> &resultVec, int index) {
+  vector<CPlate> all_result_Plates;
+
+  plateColorLocate(src, all_result_Plates, index);
+  plateSobelLocate(src, all_result_Plates, index);
+  plateMserLocate(src, all_result_Plates, index);
+
+  for (size_t i = 0; i < all_result_Plates.size(); i++) {
+    resultVec.push_back(all_result_Plates[i]);
+  }
+
+  return 0;
+}
+
+}

src/core/plate_recognize.cpp

@@ -0,0 +1,105 @@
+#include "easypr/core/plate_recognize.h"
+#include "easypr/config.h"
+#include "thirdparty/textDetect/erfilter.hpp"
+
+namespace easypr {
+
+CPlateRecognize::CPlateRecognize() { 
+  m_showResult = false;
+}
+
+
+// main method, plate recognize, contain two parts
+// 1. plate detect
+// 2. chars recognize
+int CPlateRecognize::plateRecognize(const Mat& src, std::vector<CPlate> &plateVecOut, int img_index) {
+  // resize to uniform sizes
+  float scale = 1.f;
+  Mat img = uniformResize(src, scale);
+
+  // 1. plate detect
+  std::vector<CPlate> plateVec;
+  int resultPD = plateDetect(img, plateVec, img_index);
+  if (resultPD == 0) {
+    size_t num = plateVec.size();
+    for (size_t j = 0; j < num; j++) {
+      CPlate& item = plateVec.at(j);
+      Mat plateMat = item.getPlateMat();
+      SHOW_IMAGE(plateMat, 0);
+
+      // scale the rect to src;
+      item.setPlateScale(scale);
+      RotatedRect rect = item.getPlatePos();
+      item.setPlatePos(scaleBackRRect(rect, 1.f / scale));
+
+      // get plate color
+      Color color = item.getPlateColor();
+      if (color == UNKNOWN) {
+        color = getPlateType(plateMat, true);
+        item.setPlateColor(color);
+      }
+      std::string plateColor = getPlateColor(color);
+      if (0) {
+        std::cout << "plateColor:" << plateColor << std::endl;
+      }
+
+      // 2. chars recognize
+      std::string plateIdentify = "";
+      int resultCR = charsRecognise(item, plateIdentify);
+      if (resultCR == 0) {
+        std::string license = plateColor + ":" + plateIdentify;
+        item.setPlateStr(license);
+        plateVecOut.push_back(item);
+        if (0) std::cout << "resultCR:" << resultCR << std::endl;
+      }
+      else {
+        std::string license = plateColor;
+        item.setPlateStr(license);
+        plateVecOut.push_back(item);
+        if (0) std::cout << "resultCR:" << resultCR << std::endl;
+      }
+    }
+    if (getResultShow()) {
+      // param type: 0 detect, 1 recognize;
+      int showType = 1;
+      if (0 == showType)
+        showDectectResults(img, plateVec, num);
+      else
+        showDectectResults(img, plateVecOut, num);
+    }
+  }
+  return resultPD;
+}
+
+void CPlateRecognize::LoadSVM(std::string path) {
+  PlateJudge::instance()->LoadModel(path);
+}
+
+void CPlateRecognize::LoadANN(std::string path) {
+  CharsIdentify::instance()->LoadModel(path);
+}
+
+void CPlateRecognize::LoadChineseANN(std::string path) {
+  CharsIdentify::instance()->LoadChineseModel(path);
+}
+
+void CPlateRecognize::LoadGrayChANN(std::string path) {
+  CharsIdentify::instance()->LoadGrayChANN(path);
+}
+
+void CPlateRecognize::LoadChineseMapping(std::string path) {
+  CharsIdentify::instance()->LoadChineseMapping(path);
+}
+
+// deprected
+int CPlateRecognize::plateRecognize(const Mat& src, std::vector<std::string> &licenseVec) {
+  vector<CPlate> plates;
+  int resultPR = plateRecognize(src, plates, 0);
+
+  for (auto plate : plates) {
+    licenseVec.push_back(plate.getPlateStr());
+  }
+  return resultPR;
+}
+
+}

src/src/core/chars_identify.cpp

@@ -18,6 +18,7 @@ CharsIdentify* CharsIdentify::instance() {
   return instance_;
 }
 
+// 主要用于加载和管理预训练的神经网络模型，用于字符识别
 CharsIdentify::CharsIdentify() {
   LOAD_ANN_MODEL(ann_, kDefaultAnnPath);
   LOAD_ANN_MODEL(annChinese_, kChineseAnnPath);
@@ -58,18 +59,24 @@ void CharsIdentify::LoadChineseMapping(std::string path) {
   kv_->load(path);
 }
 
+// 对输入的特征行进行预测，并识别出最可能的字符。
 void CharsIdentify::classify(cv::Mat featureRows, std::vector<int>& out_maxIndexs,
                              std::vector<float>& out_maxVals, std::vector<bool> isChineseVec){
+  // 获取特征行的行数。
   int rowNum = featureRows.rows;
-
+  // 创建一个新的矩阵output，大小为特征行的行数（rowNum）乘以总的字符数量
   cv::Mat output(rowNum, kCharsTotalNumber, CV_32FC1);
+  // 使用预先训练好的模型（ann_）对输入的特征行进行预测，结果保存在output矩阵中
   ann_->predict(featureRows, output);
-
+  // 循环遍历每一行输出：
+  // 对于每一行，首先获取该行的预测结果
   for (int output_index = 0; output_index < rowNum; output_index++) {
     Mat output_row = output.row(output_index);
     int result = 0;
     float maxVal = -2.f;
     bool isChinses = isChineseVec[output_index];
+    // 如果该行不是中文字符（由isChineseVec向量确定），
+    // 则遍历前kCharactersNumber个预测结果，找出值最大的那个，并记录其索引和值。
     if (!isChinses) {
       result = 0;
       for (int j = 0; j < kCharactersNumber; j++) {
@@ -81,6 +88,8 @@ void CharsIdentify::classify(cv::Mat featureRows, std::vector<int>& out_maxIndex
         }
       }
     }
+    // 如果该行是中文字符，
+    // 则从kCharactersNumber开始遍历后面的预测结果，找出值最大的那个，并记录其索引和值。
     else {
       result = kCharactersNumber;
       for (int j = kCharactersNumber; j < kCharsTotalNumber; j++) {
@@ -92,18 +101,20 @@ void CharsIdentify::classify(cv::Mat featureRows, std::vector<int>& out_maxIndex
         }
       }
     }
+    // 将记录的最大索引和最大值分别赋值给out_maxIndexs和out_maxVals的相应位置
     out_maxIndexs[output_index] = result;
     out_maxVals[output_index] = maxVal;
   }
 }
 
-
+// 接受一个CCharacter类型的向量（charVec），并对每个字符进行分类。
 void CharsIdentify::classify(std::vector<CCharacter>& charVec){
   size_t charVecSize = charVec.size();
 
   if (charVecSize == 0)
     return;
-
+  
+  // 创建一个名为featureRows的Mat对象，并通过循环将每个字符的特征提取出来并添加到featureRows中。
   Mat featureRows;
   for (size_t index = 0; index < charVecSize; index++) {
     Mat charInput = charVec[index].getCharacterMat();
@@ -111,9 +122,14 @@ void CharsIdentify::classify(std::vector<CCharacter>& charVec){
     featureRows.push_back(feature);
   }
 
+  // 创建一个输出矩阵output，并使用预先训练好的模型（ann_）对特征进行预测。
   cv::Mat output(charVecSize, kCharsTotalNumber, CV_32FC1);
   ann_->predict(featureRows, output);
 
+  // 遍历每个输出，对于每个输出，首先获取对应的字符（通过索引），
+  // 然后获取该字符的预测结果行（通过索引）。然后，函数检查该字符是否为中文字符，
+  // 如果不是，它就在循环中找出值最大的预测结果，并记录其索引和值。
+  // 最后，函数根据这个最大值和索引确定预测的字符，并将其作为标签。
   for (size_t output_index = 0; output_index < charVecSize; output_index++) {
     CCharacter& character = charVec[output_index];
     Mat output_row = output.row(output_index);
@@ -135,6 +151,8 @@ void CharsIdentify::classify(std::vector<CCharacter>& charVec){
       }
       label = std::make_pair(kChars[result], kChars[result]).second;
     }
+    // 如果字符是中文字符，函数则从预测结果的后面部分开始查找最大值，并记录其索引和值。
+    // 然后，函数根据这个最大值和索引确定预测的字符，并通过键值对（kv_）查找对应的省份，将字符和省份作为标签。
     else {
       result = kCharactersNumber;
       for (int j = kCharactersNumber; j < kCharsTotalNumber; j++) {
@@ -152,28 +170,33 @@ void CharsIdentify::classify(std::vector<CCharacter>& charVec){
     }
     /*std::cout << "result:" << result << std::endl;
     std::cout << "maxVal:" << maxVal << std::endl;*/
+
+    // 函数将预测的最大值和标签分别设置到对应字符对象的得分和字符串属性中。
     character.setCharacterScore(maxVal);
     character.setCharacterStr(label);
   }
 }
 
-
+// 对输入的中文字符进行分类
 void CharsIdentify::classifyChineseGray(std::vector<CCharacter>& charVec){
   size_t charVecSize = charVec.size();
   if (charVecSize == 0)
     return;
 
   Mat featureRows;
+  // 通过循环提取每个字符的特征，并存储在featureRows中
   for (size_t index = 0; index < charVecSize; index++) {
     Mat charInput = charVec[index].getCharacterMat();
     cv::Mat feature;
     extractFeature(charInput, feature);
     featureRows.push_back(feature);
   }
-
+  // 创建一个输出矩阵（output），然后使用预先训练好的模型（annGray_）对特征进行预测，并将结果存储在output中
   cv::Mat output(charVecSize, kChineseNumber, CV_32FC1);
   annGray_->predict(featureRows, output);
 
+  // 对于输出矩阵中的每一行（每个字符的预测结果），
+  // 如果该字符是中文字符，函数会从预测结果的后面部分开始查找最大值，并记录其索引和值。
   for (size_t output_index = 0; output_index < charVecSize; output_index++) {
     CCharacter& character = charVec[output_index];
     Mat output_row = output.row(output_index);
@@ -198,6 +221,8 @@ void CharsIdentify::classifyChineseGray(std::vector<CCharacter>& charVec){
       isChinese = false;
     }
 
+    // 根据这个最大值和索引确定预测的字符。
+    // 这是通过查找kChars数组实现的，其中kChars可能是一个预定义的字符集。
     auto index = result + kCharsTotalNumber - kChineseNumber;
     const char* key = kChars[index];
     std::string s = key;
@@ -206,12 +231,15 @@ void CharsIdentify::classifyChineseGray(std::vector<CCharacter>& charVec){
     /*std::cout << "result:" << result << std::endl;
     std::cout << "maxVal:" << maxVal << std::endl;*/
 
+    // 将预测的最大值、预测的字符以及对应的省份作为标签，
+    // 分别设置到对应字符对象的得分、字符串属性和是否为中文字符属性中
     character.setCharacterScore(maxVal);
     character.setCharacterStr(province);
     character.setIsChinese(isChinese);
   }
 }
 
+// 使用OpenCV库和神经网络进行中文字符识别
 void CharsIdentify::classifyChinese(std::vector<CCharacter>& charVec){
   size_t charVecSize = charVec.size();
 
@@ -219,15 +247,20 @@ void CharsIdentify::classifyChinese(std::vector<CCharacter>& charVec){
     return;
 
   Mat featureRows;
+  // 通过循环遍历每个字符，提取其特征并将其存储在featureRows中。
+  // 这里，charFeatures函数被用于提取每个字符的特性，kChineseSize可能是一个预定义的特性大小。
   for (size_t index = 0; index < charVecSize; index++) {
     Mat charInput = charVec[index].getCharacterMat();
     Mat feature = charFeatures(charInput, kChineseSize);
     featureRows.push_back(feature);
   }
 
+  // 创建一个输出矩阵（output），并使用预先训练好的模型（annChinese_）对特征进行预测。预测结果存储在output中。
   cv::Mat output(charVecSize, kChineseNumber, CV_32FC1);
   annChinese_->predict(featureRows, output);
 
+  // 遍历每个预测结果，并对每个结果进行处理。对于每个预测结果，函数查找最大值及其索引。
+  // 如果最大值小于或等于-1，则将最大值设置为0，并将result设置为0，同时将isChinese设置为false。
   for (size_t output_index = 0; output_index < charVecSize; output_index++) {
     CCharacter& character = charVec[output_index];
     Mat output_row = output.row(output_index);
@@ -252,6 +285,8 @@ void CharsIdentify::classifyChinese(std::vector<CCharacter>& charVec){
       isChinese = false;
     }
 
+    // 计算索引值，并使用该索引从kChars数组中获取对应的字符。
+    // 同时，通过键值对（kv_）查找与该字符对应的省份。
     auto index = result + kCharsTotalNumber - kChineseNumber;
     const char* key = kChars[index];
     std::string s = key;
@@ -260,18 +295,24 @@ void CharsIdentify::classifyChinese(std::vector<CCharacter>& charVec){
     /*std::cout << "result:" << result << std::endl;
     std::cout << "maxVal:" << maxVal << std::endl;*/
 
+    // 将最大值、省份和isChinese作为标签，分别设置到对应字符对象的得分、字符串属性和是否为中文字符属性中。
     character.setCharacterScore(maxVal);
     character.setCharacterStr(province);
     character.setIsChinese(isChinese);
   }
 }
 
+
+// 对输入的图像数据进行分类
 int CharsIdentify::classify(cv::Mat f, float& maxVal, bool isChinses, bool isAlphabet){
   int result = 0;
-
+  // 调用预先训练好的模型（ann_）进行预测，并将预测结果存储在output变量中。
   cv::Mat output(1, kCharsTotalNumber, CV_32FC1);
   ann_->predict(f, output);
 
+  // 查找最大值及其索引。如果图像数据不是中文，则会检查它是否是字母。
+  // 如果它是字母，那么函数将只查找字母范围内的值（从10开始，对应于'A'）。
+  // 否则，它将查找所有字符范围内的值。如果图像数据是中文，则函数将查找中文字符范围内的值
   maxVal = -2.f;
   if (!isChinses) {
     if (!isAlphabet) {
@@ -309,20 +350,27 @@ int CharsIdentify::classify(cv::Mat f, float& maxVal, bool isChinses, bool isAlp
       }
     }
   }
+  // 返回索引值result，该值是预测的字符在预先定义的字符集kChars中的索引。
+  // 同时，它也将最大值maxVal和对应的索引result设置到输入的float引用maxVal中，以便调用者可以访问这些值。
   //std::cout << "maxVal:" << maxVal << std::endl;
   return result;
 }
-
+// 根据输入的图像数据判断它是否是一个字符（特别是中文字符）
 bool CharsIdentify::isCharacter(cv::Mat input, std::string& label, float& maxVal, bool isChinese) {
+  // 调用charFeatures函数提取输入图像的特征，并存储在feature变量中。
+  // 然后，它调用classify函数对特征进行分类，得到一个索引值index
   cv::Mat feature = charFeatures(input, kPredictSize);
   auto index = static_cast<int>(classify(feature, maxVal, isChinese));
-
+  
   if (isChinese) {
     //std::cout << "maxVal:" << maxVal << std::endl;
   }
 
   float chineseMaxThresh = 0.2f;
-
+  // 检查预测的最大值maxVal是否大于等于0.9，或者如果输入的字符是中文且最大值大于等于chineseMaxThresh（这个阈值被设置为0.2）。
+  // 如果满足这些条件之一，函数将检查索引index是否小于kCharactersNumber（这可能是一个预定义的字符集大小）。
+  // 如果是，则将索引对应的字符作为标签；否则，使用键值对kv_查找索引对应的省份，并将该索引对应的字符和省份作为标签。
+  // 最后，函数返回true表示输入的图像是一个字符，否则返回false
   if (maxVal >= 0.9 || (isChinese && maxVal >= chineseMaxThresh)) {
     if (index < kCharactersNumber) {
       label = std::make_pair(kChars[index], kChars[index]).second;
@@ -338,8 +386,10 @@ bool CharsIdentify::isCharacter(cv::Mat input, std::string& label, float& maxVal
   else
     return false;
 }
-
+// 用于识别输入的图像数据是否是一个中文字符。
 std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input, float& out, bool& isChinese) {
+  // 调用charFeatures函数提取输入图像的特征，并存储在feature变量中。
+  // 然后，它调用预先训练好的模型annChinese_进行预测，并将预测结果存储在output变量中。
   cv::Mat feature = charFeatures(input, kChineseSize);
   float maxVal = -2;
   int result = 0;
@@ -347,6 +397,8 @@ std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input
   cv::Mat output(1, kChineseNumber, CV_32FC1);
   annChinese_->predict(feature, output);
 
+  // 遍历输出数组，找到最大的值及其索引。
+  // 如果最大值大于0.9，则将isChinese设置为true，表示输入的字符可能是中文。
   for (int j = 0; j < kChineseNumber; j++) {
     float val = output.at<float>(j);
     //std::cout << "j:" << j << "val:" << val << std::endl;
@@ -357,6 +409,8 @@ std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input
   }
 
   // no match
+  // 如果索引值为-1（即没有匹配的字符），
+  // 则将result设置为0，maxVal设置为0，并将isChinese设置为false，表示输入的字符不是中文。
   if (-1 == result) {
     result = 0;
     maxVal = 0;
@@ -365,7 +419,7 @@ std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input
   else if (maxVal > 0.9){
     isChinese = true;
   }
-
+  // 通过索引值获取字符的标签和省份，并将最大值保存到out中。函数返回一个由字符标签和省份组成的pair。
   auto index = result + kCharsTotalNumber - kChineseNumber;
   const char* key = kChars[index];
   std::string s = key;
@@ -374,15 +428,18 @@ std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input
 
   return std::make_pair(s, province);
 }
-
+// 从输入的图像（可能是一个灰度图像）中识别出可能的中文字符。
 std::pair<std::string, std::string> CharsIdentify::identifyChineseGray(cv::Mat input, float& out, bool& isChinese) {
   cv::Mat feature;
+  // 通过extractFeature函数提取输入图像的特征，并将特征保存在feature变量中。
+  // 然后，它使用预先训练好的模型annGray_进行预测，并将预测结果存储在output变量中。
   extractFeature(input, feature);
   float maxVal = -2;
   int result = 0;
   cv::Mat output(1, kChineseNumber, CV_32FC1);
   annGray_->predict(feature, output);
-
+  // 遍历输出数组，找到最大的值及其索引。
+  // 如果最大值大于0.9，则将isChinese设置为true，表示输入的字符可能是中文。
   for (int j = 0; j < kChineseNumber; j++) {
     float val = output.at<float>(j);
     //std::cout << "j:" << j << "val:" << val << std::endl;
@@ -392,6 +449,8 @@ std::pair<std::string, std::string> CharsIdentify::identifyChineseGray(cv::Mat i
     }
   }
   // no match
+  // 如果索引值为-1（即没有匹配的字符），
+  // 则将result设置为0，maxVal设置为0，并将isChinese设置为false，表示输入的字符不是中文
   if (-1 == result) {
     result = 0;
     maxVal = 0;
@@ -399,6 +458,7 @@ std::pair<std::string, std::string> CharsIdentify::identifyChineseGray(cv::Mat i
   } else if (maxVal > 0.9){
     isChinese = true;
   }
+  // 通过索引值获取字符的标签和省份，并将最大值保存到out中。函数返回一个由字符标签和省份组成的pair。
   auto index = result + kCharsTotalNumber - kChineseNumber;
   const char* key = kChars[index];
   std::string s = key;
@@ -407,11 +467,15 @@ std::pair<std::string, std::string> CharsIdentify::identifyChineseGray(cv::Mat i
   return std::make_pair(s, province);
 }
 
-
+// 用于识别输入的图像数据是否是一个字符。
 std::pair<std::string, std::string> CharsIdentify::identify(cv::Mat input, bool isChinese, bool isAlphabet) {
+  // 过调用charFeatures函数提取输入图像的特征，并存储在feature变量中。
+  // 然后，它调用预先训练好的模型classify进行预测，并将预测结果存储在index变量中。
   cv::Mat feature = charFeatures(input, kPredictSize);
   float maxVal = -2;
   auto index = static_cast<int>(classify(feature, maxVal, isChinese, isAlphabet));
+  // 检查索引值index是否小于字符集大小kCharactersNumber。如果是，则返回由相同字符组成的pair；
+  // 否则，获取索引对应的字符作为键，并使用键值对kv_查找对应的省份。
   if (index < kCharactersNumber) {
     return std::make_pair(kChars[index], kChars[index]);
   }
@@ -423,10 +487,14 @@ std::pair<std::string, std::string> CharsIdentify::identify(cv::Mat input, bool
   }
 }
 
+// 用于处理一组输入的图像数据并识别出对应的字符和省份。
+// 函数参数包括输入图像数据（inputs），输出结果（outputs）以及一个布尔值向量（isChineseVec）
 int CharsIdentify::identify(std::vector<cv::Mat> inputs, std::vector<std::pair<std::string, std::string>>& outputs,
                             std::vector<bool> isChineseVec) {
+  // featureRows创建一个空的Mat对象。它将被用于存储所有输入图像的特征。
   Mat featureRows;
   size_t input_size = inputs.size();
+  // 每一张图像提取特征，并将这些特征添加到featureRows中。
   for (size_t i = 0; i < input_size; i++) {
     Mat input = inputs[i];
     cv::Mat feature = charFeatures(input, kPredictSize);
@@ -435,8 +503,13 @@ int CharsIdentify::identify(std::vector<cv::Mat> inputs, std::vector<std::pair<s
 
   std::vector<int> maxIndexs;
   std::vector<float> maxVals;
+  // 调用classify函数，输入特征矩阵featureRows，并返回最大值的索引（maxIndexs）和最大值（maxVals）。
+  // 同时，根据这些最大值，更新isChineseVec中的对应元素。
   classify(featureRows, maxIndexs, maxVals, isChineseVec);
-
+  // 遍历所有的输入图像，对于每一张图像，根据其对应的最大值索引，构造一个输出对，并存储在outputs中。
+  // 如果索引小于字符集大小kCharactersNumber，则输出对由相同字符组成；
+  // 否则，获取索引对应的字符作为键，并使用键值对kv_查找对应的省份。
+  
   for (size_t row_index = 0; row_index < input_size; row_index++) {
     int index = maxIndexs[row_index];
     if (index < kCharactersNumber) {

src/src/core/chars_recognise.cpp

@@ -6,29 +6,43 @@
 namespace easypr {
 
 CCharsRecognise::CCharsRecognise() { m_charsSegment = new CCharsSegment(); }
+//定义了CCharsRecognise类的构造函数，创建一个新的CCharsSegment类的实例，并将其地址赋值给成员变量m_charsSegment
 
 CCharsRecognise::~CCharsRecognise() { SAFE_RELEASE(m_charsSegment); }
+//定义了CCharsRecognise类的析构函数，
+//调用了SAFE_RELEASE宏来释放（即删除并置空）m_charsSegment指针指向的CCharsSegment对象
 
 int CCharsRecognise::charsRecognise(Mat plate, std::string& plateLicense) {
+    //车牌字符识别函数，接收两个参数，一个是Mat类型的plate，它是需要进行识别的车牌图像；
+    //另一个是std::string&类型的plateLicense，它是一个引用，用于存储识别出来的车牌号码。
   std::vector<Mat> matChars;
+  //matChars，用于存储经过字符分割后的单个字符图像。
   int result = m_charsSegment->charsSegment(plate, matChars);
+  //调用m_charsSegment对象的charsSegment函数进行字符分割，
+  //将分割后的字符存储在matChars中。charsSegment函数的返回值存储在result变量中。
   if (result == 0) {
+      //result = 0则表示字符分割成功，接着进行车牌号码的识别
     int num = matChars.size();
     for (int j = 0; j < num; j++)
     {
       Mat charMat = matChars.at(j);
+      //循环遍历matChars中的每个字符图像
       bool isChinses = false;
       float maxVal = 0;
       if (j == 0) {
         bool judge = true;
         isChinses = true;
+        //第一个字符，则认为是中文汉字
         auto character = CharsIdentify::instance()->identifyChinese(charMat, maxVal, judge);
         plateLicense.append(character.second);
+        //调用CharsIdentify::instance()->identifyChinese函数进行识别，并将识别结果追加到plateLicense中
       }
       else {
         isChinses = false;
+        //如果不是第一个字符，则认为不是中文汉字，
         auto character = CharsIdentify::instance()->identify(charMat, isChinses);
         plateLicense.append(character.second);
+        //调用CharsIdentify::instance()->identify函数进行识别，并将识别结果追加到plateLicense中。
       }
     }
 
@@ -36,20 +50,27 @@ int CCharsRecognise::charsRecognise(Mat plate, std::string& plateLicense) {
   if (plateLicense.size() < 7) {
     return -1;
   }
+ // 检查plateLicense的长度是否小于7，如果小于7，则返回 - 1，表示车牌号码识别失败。否则，返回result，表示车牌号码识别成功。
 
   return result;
 }
 
 
 int CCharsRecognise::charsRecognise(CPlate& plate, std::string& plateLicense) {
+//同样是用来识别车牌的函数，数接收两个参数，一个是CPlate&类型的plate，它是需要进行识别的车牌对象；
+// 另一个是std::string&类型的plateLicense，它是一个引用，用于存储识别出来的车牌号码
   std::vector<Mat> matChars;
   std::vector<Mat> grayChars;
+  //matChars用于存储经过字符分割后的单个字符图像，grayChars用于存储灰度图像。
   Mat plateMat = plate.getPlateMat();
+  //调用plate.getPlateMat()获取车牌图像，并将其存储在plateMat中。
   if (0) writeTempImage(plateMat, "plateMat/plate");
   Color color;
   if (plate.getPlateLocateType() == CMSER) {
     color = plate.getPlateColor();
   }
+  //选择不同的方式来获取车牌颜色。如果车牌定位类型为CMSER，则直接使用plate.getPlateColor()获取车牌颜色；
+  //否则，从车牌图像中截取一部分区域，并调用getPlateType()函数获取车牌类型。
   else {
     int w = plateMat.cols;
     int h = plateMat.rows;
@@ -58,35 +79,42 @@ int CCharsRecognise::charsRecognise(CPlate& plate, std::string& plateLicense) {
   }
 
   int result = m_charsSegment->charsSegmentUsingOSTU(plateMat, matChars, grayChars, color);
-
+  //调用charsSegmentUsingOSTU方法对输入的车牌图像进行字符分割
   if (result == 0) {
     int num = matChars.size();
     for (int j = 0; j < num; j++)
     {
+        //for循环遍历每一个字符图像
       Mat charMat = matChars.at(j);
       Mat grayChar = grayChars.at(j);
+      //通过matChars.at(j)和grayChars.at(j)获取第j个字符图像和其灰度图像
       if (color != Color::BLUE)
         grayChar = 255 - grayChar;
-
+      //如果车牌颜色不是蓝色，则对灰度图像进行操作
       bool isChinses = false;
       std::pair<std::string, std::string> character;
       float maxVal;
       if (0 == j) {
         isChinses = true;
         bool judge = true;
+        //设定第一个字符为中文字符
         character = CharsIdentify::instance()->identifyChineseGray(grayChar, maxVal, judge);
         plateLicense.append(character.second);
-
+        //使用CharsIdentify::instance()->identifyChineseGray方法识别灰度图像grayChar，
+        // 并将结果存储在character对中。
         // set plate chinese mat and str
         plate.setChineseMat(grayChar);
         plate.setChineseKey(character.first);
+        //设置车牌的中文图像和字符串。
         if (0) writeTempImage(grayChar, "char_data/" + character.first + "/chars_");
       }
       else if (1 == j) {
         isChinses = false;
         bool isAbc = true;
         character = CharsIdentify::instance()->identify(charMat, isChinses, isAbc);
+        //使用CharsIdentify::instance()->identify方法识别字符图像charMat
         plateLicense.append(character.second);
+        //将识别的第二个字符串添加到plateLicense
       }
       else {
         isChinses = false;
@@ -96,17 +124,21 @@ int CCharsRecognise::charsRecognise(CPlate& plate, std::string& plateLicense) {
       }
 
       CCharacter charResult;
+      //创建CCharacter对象并设置其图像和字符串。
       charResult.setCharacterMat(charMat);
       charResult.setCharacterGrayMat(grayChar);
       if (isChinses)
         charResult.setCharacterStr(character.first);
       else
         charResult.setCharacterStr(character.second);
-
+      
+      //如果isChinses为true，则使用识别的第一个字符串作为字符的字符串；否则，使用识别的第二个字符串。
       plate.addReutCharacter(charResult);
+      //字符结果添加到车牌对象中。
     }
     if (plateLicense.size() < 7) {
       return -1;
+      //最后，如果识别的字符数量少于7个，函数返回 - 1；否则返回result
     }
   }
 

src/src/train/ann_train.cpp

@@ -354,3 +354,22 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::tdata() {
                                    train_classes);
 }
 }
+/*这段代码是一个开源项目EasyPR中的一个类AnnTrain的实现。
+
+AnnTrain类用于训练一个基于人工神经网络（ANN）的字符识别模型。它接受一个包含字符图像的文件夹路径和一个输出的XML文件路径作为参数。
+
+在构造函数中，它创建了一个ANN_MLP类对象ann_。type变量用于指定训练类型，0表示所有字符，1表示只有中文字符。kv_是一个Kv类的对象，用于加载一个映射文件。
+
+train()函数是训练模型的核心函数。它根据type的值，确定输入层、隐藏层和输出层的节点数量，以及神经网络的层数和结构。然后设置神经网络的各种参数，如激活函数、训练方法、停止条件等。接着，它加载训练数据并开始训练模型。训练完成后，将模型保存到指定的XML文件中，并调用test()函数评估模型的准确率。
+
+identifyChinese()函数和identify()函数分别用于识别中文字符和非中文字符。它们接受一个字符图像作为输入，提取特征并使用训练好的模型进行预测，返回一个包含字符和所属省份信息的pair。
+
+test()函数用于评估模型的准确率。它遍历每个字符类别，读取所有字符图像文件，使用训练好的模型进行识别，并统计预测正确的数量。最后计算整体的准确率。
+
+getSyntheticImage()函数用于生成合成图像，通过随机平移和旋转原字符图像来增加训练数据的多样性。
+
+sdata()函数用于生成训练数据，读取字符图像文件夹中的所有图像，对于每个字符，根据指定数量生成一些合成图像，并提取特征。
+
+tdata()函数和sdata()函数类似，用于生成训练数据，只是不生成合成图像。
+
+该类还依赖其他一些辅助函数和常量定义，没有在这段代码中给出。*/

src/train/annCh_train.cpp

@@ -0,0 +1,277 @@
+#include <numeric>
+#include <ctime>
+
+#include "easypr/train/annCh_train.h"
+#include "easypr/config.h"
+#include "easypr/core/chars_identify.h"
+#include "easypr/core/feature.h"
+#include "easypr/core/core_func.h"
+#include "easypr/util/util.h"
+#include "easypr/train/create_data.h"
+
+namespace easypr {
+
+  AnnChTrain::AnnChTrain(const char* chars_folder, const char* xml)
+    : chars_folder_(chars_folder), ann_xml_(xml)
+  {
+  ann_ = cv::ml::ANN_MLP::create();
+  type = 1;
+  kv_ = std::shared_ptr<Kv>(new Kv);
+  kv_->load("resources/text/province_mapping");
+  extractFeature = getGrayPlusProject;
+}
+
+  void AnnChTrain::train()
+  {
+    int classNumber = 0;
+    int input_number = 0;
+    int hidden_number = 0;
+    int output_number = 0;
+
+    bool useLBP = false;
+    if (useLBP)
+      input_number = kCharLBPPatterns * kCharLBPGridX * kCharLBPGridY;
+    else
+      input_number = kGrayCharHeight * kGrayCharWidth;
+
+    input_number += 64;
+
+  classNumber = kChineseNumber;
+  hidden_number = kCharHiddenNeurans;
+  output_number = classNumber;
+  cv::Mat layers;
+
+    int first_hidden_neurons = 48;
+    int second_hidden_neurons = 32;
+
+    int N = input_number;
+    int m = output_number;
+    //int first_hidden_neurons = int(std::sqrt((m + 2) * N) + 2 * std::sqrt(N / (m + 2)));
+    //int second_hidden_neurons = int(m * std::sqrt(N / (m + 2)));
+
+    bool useTLFN = false;
+    if (!useTLFN) {
+      layers.create(1, 3, CV_32SC1);
+      layers.at<int>(0) = input_number;
+      layers.at<int>(1) = hidden_number;
+      layers.at<int>(2) = output_number;
+    }
+    else {
+      fprintf(stdout, ">> Use two-layers neural networks,\n");
+      fprintf(stdout, ">> First_hidden_neurons: %d \n", first_hidden_neurons);
+      fprintf(stdout, ">> Second_hidden_neurons: %d \n", second_hidden_neurons);
+
+      layers.create(1, 4, CV_32SC1);
+      layers.at<int>(0) = input_number;
+      layers.at<int>(1) = first_hidden_neurons;
+      layers.at<int>(2) = second_hidden_neurons;
+      layers.at<int>(3) = output_number;
+    }
+
+  ann_->setLayerSizes(layers);
+  ann_->setActivationFunction(cv::ml::ANN_MLP::SIGMOID_SYM, 1, 1);
+  ann_->setTrainMethod(cv::ml::ANN_MLP::TrainingMethods::BACKPROP);
+  ann_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 30000, 0.0001));
+  ann_->setBackpropWeightScale(0.1);
+  ann_->setBackpropMomentumScale(0.1);
+
+  auto files = Utils::getFiles(chars_folder_);
+  if (files.size() == 0) {
+    fprintf(stdout, "No file found in the train folder!\n");
+    fprintf(stdout, "You should create a folder named \"tmp\" in EasyPR main folder.\n");
+    fprintf(stdout, "Copy train data folder(like \"annCh\") under \"tmp\". \n");
+    return;
+  }
+
+  // using raw data or raw + synthic data.
+  trainVal(m_number_for_count);
+}
+
+std::pair<std::string, std::string> AnnChTrain::identifyGrayChinese(cv::Mat input) {
+  Mat feature;
+  extractFeature(input, feature);
+  float maxVal = -2;
+  int result = 0;
+
+  cv::Mat output(1, kChineseNumber, CV_32FC1);
+  ann_->predict(feature, output);
+
+  for (int j = 0; j < kChineseNumber; j++) {
+    float val = output.at<float>(j);
+    //std::cout << "j:" << j << "val:" << val << std::endl;
+    if (val > maxVal) {
+      maxVal = val;
+      result = j;
+    }
+  }
+
+  auto index = result + kCharsTotalNumber - kChineseNumber;
+  const char* key = kChars[index];
+  std::string s = key;
+  std::string province = kv_->get(s);
+
+  return std::make_pair(s, province);
+}
+
+  void AnnChTrain::test() {
+    //TODO
+}
+
+void AnnChTrain::trainVal(size_t number_for_count) {
+  assert(chars_folder_);
+  cv::Mat train_samples;
+  std::vector<cv::Mat>  train_images, val_images;
+  std::vector<int> train_label, val_labels;
+  float percentage = 0.7f;
+  int classNumber = kChineseNumber;
+
+  for (int i = 0; i < classNumber; ++i) { 
+    auto char_key = kChars[i + kCharsTotalNumber - classNumber];
+    char sub_folder[512] = { 0 };
+    sprintf(sub_folder, "%s/%s", chars_folder_, char_key);
+    std::string test_char(char_key);
+    // if (test_char != "zh_yun") continue;
+
+    fprintf(stdout, ">> Testing characters %s in %s \n", char_key, sub_folder);
+    auto chars_files = utils::getFiles(sub_folder);
+    size_t char_size = chars_files.size();
+    fprintf(stdout, ">> Characters count: %d \n", (int)char_size);
+
+    std::vector<cv::Mat> matVec;
+    matVec.reserve(number_for_count);
+    for (auto file : chars_files) {
+      std::cout << file << std::endl;
+      auto img = cv::imread(file, IMREAD_GRAYSCALE);  // a grayscale image 
+      Mat img_resize;
+      img_resize.create(kGrayCharHeight, kGrayCharWidth, CV_8UC1);
+      resize(img, img_resize, img_resize.size(), 0, 0, INTER_LINEAR);
+      matVec.push_back(img_resize);
+    }
+    // genrate the synthetic images
+    for (int t = 0; t < (int)number_for_count - (int)char_size; t++) {
+      int rand_range = char_size + t;
+      int ran_num = rand() % rand_range;
+      auto img = matVec.at(ran_num);
+      SHOW_IMAGE(img, 0);
+      auto simg = generateSyntheticImage(img);
+      SHOW_IMAGE(simg, 0);
+      matVec.push_back(simg);
+    }
+    fprintf(stdout, ">> Characters count: %d \n", (int)matVec.size());
+
+    // random sort the mat;
+    srand(unsigned(time(NULL)));
+    random_shuffle(matVec.begin(), matVec.end());
+
+    int mat_size = (int)matVec.size();
+    int split_index = int((float)mat_size * percentage);
+    for (int j = mat_size - 1; j >= 0; j--) {
+      Mat img = matVec.at(j);
+      if (1) {
+        Mat feature;
+        extractFeature(img, feature);
+        if (j <= split_index) {
+          train_samples.push_back(feature);
+          train_images.push_back(img);
+          train_label.push_back(i);
+        }
+        else {
+          val_images.push_back(img);
+          val_labels.push_back(i);
+        }
+      }
+    }
+  } 
+  // generate train data
+  train_samples.convertTo(train_samples, CV_32F);
+  cv::Mat train_classes = cv::Mat::zeros((int)train_label.size(), classNumber, CV_32F);
+  for (int i = 0; i < train_classes.rows; ++i)
+    train_classes.at<float>(i, train_label[i]) = 1.f;
+  auto train_data = cv::ml::TrainData::create(train_samples, cv::ml::SampleTypes::ROW_SAMPLE, train_classes);
+
+  // train the data, calculate the cost time
+  std::cout << "Training ANN chinese model, please wait..." << std::endl;
+  long start = utils::getTimestamp();
+  ann_->train(train_data);
+  long end = utils::getTimestamp();
+  ann_->save(ann_xml_);
+  std::cout << "Your ANN Model was saved to " << ann_xml_ << std::endl;
+  std::cout << "Training done. Time elapse: " << (end - start) / (1000 * 60) << "minute" << std::endl;
+
+  // test the accuracy_rate in train
+  if (1) {
+    int corrects_all = 0, sum_all = train_images.size();
+    std::cout << "train_images size: " << sum_all << std::endl;
+    for (size_t i = 0; i < train_images.size(); ++i) {
+      cv::Mat img = train_images.at(i);
+      int label = train_label.at(i);
+      auto char_key = kChars[label + kCharsTotalNumber - classNumber];
+      std::pair<std::string, std::string> ch = identifyGrayChinese(img);
+      if (ch.first == char_key)
+        corrects_all++;
+    }
+    float accuracy_rate = (float)corrects_all / (float)sum_all;
+    std::cout << "Train error_rate: " << (1.f - accuracy_rate) * 100.f << "% "<< std::endl;
+  }
+
+  // test the accuracy_rate in val
+  if (1) {
+    int corrects_all = 0, sum_all = val_images.size();
+    std::cout << "val_images: " << sum_all << std::endl;
+    for (size_t i = 0; i < val_images.size(); ++i) {
+      cv::Mat img = val_images.at(i);
+      int label = val_labels.at(i);
+      auto char_key = kChars[label + kCharsTotalNumber - classNumber];
+      std::pair<std::string, std::string> ch = identifyGrayChinese(img);
+      if (ch.first == char_key)
+        corrects_all++;
+    }
+    float accuracy_rate = (float)corrects_all / (float)sum_all;
+    std::cout << "Test error_rate: " << (1.f - accuracy_rate) * 100.f << "% "<< std::endl;
+  }
+
+}
+
+cv::Ptr<cv::ml::TrainData> AnnChTrain::tdata() {
+  assert(chars_folder_);
+
+  cv::Mat samples;
+  std::vector<int> labels;
+
+  std::cout << "Collecting chars in " << chars_folder_ << std::endl;
+
+  int classNumber = 0;
+  if (type == 0) classNumber = kCharsTotalNumber;
+  if (type == 1) classNumber = kChineseNumber;
+
+  for (int i = 0; i < classNumber; ++i) {
+    auto char_key = kChars[i + kCharsTotalNumber - classNumber];
+    char sub_folder[512] = {0};
+
+    sprintf(sub_folder, "%s/%s", chars_folder_, char_key);
+    std::cout << "  >> Featuring characters " << char_key << " in "
+              << sub_folder << std::endl;
+
+    auto chars_files = utils::getFiles(sub_folder);
+    for (auto file : chars_files) {
+      auto img = cv::imread(file, 0);  // a grayscale image
+      auto fps = charFeatures2(img, kPredictSize);
+
+      samples.push_back(fps);
+      labels.push_back(i);
+    }
+  }
+
+  cv::Mat samples_;
+  samples.convertTo(samples_, CV_32F);
+  cv::Mat train_classes =
+    cv::Mat::zeros((int)labels.size(), classNumber, CV_32F);
+
+  for (int i = 0; i < train_classes.rows; ++i) {
+    train_classes.at<float>(i, labels[i]) = 1.f;
+  }
+
+  return cv::ml::TrainData::create(samples_, cv::ml::SampleTypes::ROW_SAMPLE,
+                                   train_classes);
+}
+}

src/train/ann_train.cpp

@@ -0,0 +1,356 @@
+#include <numeric>
+#include <ctime>
+
+#include "easypr/train/ann_train.h"
+#include "easypr/config.h"
+#include "easypr/core/chars_identify.h"
+#include "easypr/core/feature.h"
+#include "easypr/core/core_func.h"
+#include "easypr/train/create_data.h"
+#include "easypr/util/util.h"
+
+namespace easypr {
+
+AnnTrain::AnnTrain(const char* chars_folder, const char* xml)
+    : chars_folder_(chars_folder), ann_xml_(xml) {
+  ann_ = cv::ml::ANN_MLP::create();
+  // type=0, all characters
+  // type=1, only chinese
+  type = 0;
+  kv_ = std::shared_ptr<Kv>(new Kv);
+  kv_->load("resources/text/province_mapping");
+}
+
+void AnnTrain::train() {
+  
+  int classNumber = 0;
+
+  cv::Mat layers;
+
+  int input_number = 0;
+  int hidden_number = 0;
+  int output_number = 0;
+
+  if (type == 0) {
+    classNumber = kCharsTotalNumber;
+
+    input_number = kAnnInput;
+    hidden_number = kNeurons;
+    output_number = classNumber;
+  }
+  else if (type == 1) {
+    classNumber = kChineseNumber;
+
+    input_number = kAnnInput;
+    hidden_number = kNeurons;
+    output_number = classNumber;
+  }
+
+  int N = input_number;
+  int m = output_number;
+  int first_hidden_neurons = int(std::sqrt((m + 2) * N) + 2 * std::sqrt(N / (m + 2)));
+  int second_hidden_neurons = int(m * std::sqrt(N / (m + 2)));
+
+  bool useTLFN = false;
+  if (!useTLFN) {
+    layers.create(1, 3, CV_32SC1);
+    layers.at<int>(0) = input_number;
+    layers.at<int>(1) = hidden_number;
+    layers.at<int>(2) = output_number;
+  }
+  else {
+    // Two-layers neural networks is hard to train, So do not try it
+    fprintf(stdout, ">> Use two-layers neural networks,\n");
+    fprintf(stdout, ">> First_hidden_neurons: %d \n", first_hidden_neurons);
+    fprintf(stdout, ">> Second_hidden_neurons: %d \n", second_hidden_neurons);
+
+    layers.create(1, 4, CV_32SC1);
+    layers.at<int>(0) = input_number;
+    layers.at<int>(1) = first_hidden_neurons;
+    layers.at<int>(2) = second_hidden_neurons;
+    layers.at<int>(3) = output_number;
+  }
+
+  ann_->setLayerSizes(layers);
+  ann_->setActivationFunction(cv::ml::ANN_MLP::SIGMOID_SYM, 1, 1);
+  ann_->setTrainMethod(cv::ml::ANN_MLP::TrainingMethods::BACKPROP);
+  ann_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 30000, 0.0001));
+  ann_->setBackpropWeightScale(0.1);
+  ann_->setBackpropMomentumScale(0.1);
+
+  auto files = Utils::getFiles(chars_folder_);
+  if (files.size() == 0) {
+    fprintf(stdout, "No file found in the train folder!\n");
+    fprintf(stdout, "You should create a folder named \"tmp\" in EasyPR main folder.\n");
+    fprintf(stdout, "Copy train data folder(like \"ann\") under \"tmp\". \n");
+    return;
+  }
+
+  //using raw data or raw + synthic data.
+  auto traindata = sdata(350);
+
+  std::cout << "Training ANN model, please wait..." << std::endl;
+  long start = utils::getTimestamp();
+  ann_->train(traindata);
+  long end = utils::getTimestamp();
+  ann_->save(ann_xml_);
+  
+  test();
+  std::cout << "Your ANN Model was saved to " << ann_xml_ << std::endl;
+  std::cout << "Training done. Time elapse: " << (end - start) / (1000 * 60) << "minute" << std::endl;
+}
+
+std::pair<std::string, std::string> AnnTrain::identifyChinese(cv::Mat input) {
+  cv::Mat feature = charFeatures2(input, kPredictSize);
+  float maxVal = -2;
+  int result = 0;
+
+  cv::Mat output(1, kChineseNumber, CV_32FC1);
+  ann_->predict(feature, output);
+
+  for (int j = 0; j < kChineseNumber; j++) {
+    float val = output.at<float>(j);
+    // std::cout << "j:" << j << "val:" << val << std::endl;
+    if (val > maxVal) {
+      maxVal = val;
+      result = j;
+    }
+  }
+
+  auto index = result + kCharsTotalNumber - kChineseNumber;
+  const char* key = kChars[index];
+  std::string s = key;
+  std::string province = kv_->get(s);
+
+  return std::make_pair(s, province);
+}
+
+
+std::pair<std::string, std::string> AnnTrain::identify(cv::Mat input) {
+  cv::Mat feature = charFeatures2(input, kPredictSize);
+  float maxVal = -2;
+  int result = 0;
+
+  //std::cout << feature << std::endl;
+  cv::Mat output(1, kCharsTotalNumber, CV_32FC1);
+  ann_->predict(feature, output);
+  //std::cout << output << std::endl;
+  for (int j = 0; j < kCharsTotalNumber; j++) {
+    float val = output.at<float>(j);
+    //std::cout << "j:" << j << "val:" << val << std::endl;
+    if (val > maxVal) {
+      maxVal = val;
+      result = j;
+    }
+  }
+
+  auto index = result;
+  if (index < kCharactersNumber) {
+    return std::make_pair(kChars[index], kChars[index]);
+  }
+  else {
+    const char* key = kChars[index];
+    std::string s = key;
+    std::string province = kv_->get(s);
+    return std::make_pair(s, province);
+  }
+}
+
+void AnnTrain::test() {
+  assert(chars_folder_);
+
+  int classNumber = 0;
+  if (type == 0) classNumber = kCharsTotalNumber;
+  if (type == 1) classNumber = kChineseNumber;
+
+  int corrects_all = 0, sum_all = 0;
+  std::vector<float> rate_list;
+  for (int i = 0; i < classNumber; ++i) {
+    auto char_key = kChars[i + kCharsTotalNumber - classNumber];
+    char sub_folder[512] = { 0 };
+
+    sprintf(sub_folder, "%s/%s", chars_folder_, char_key);
+    fprintf(stdout, ">> Testing characters %s in %s \n", char_key, sub_folder);
+
+    auto chars_files = utils::getFiles(sub_folder);
+    int corrects = 0, sum = 0;
+    std::vector<std::pair<std::string, std::string>> error_files;
+
+    for (auto file : chars_files) {
+      auto img = cv::imread(file, 0);  // a grayscale image
+      if (!img.data) {
+        //cout << "Null pointer!" << endl;
+        continue;
+      }
+      std::pair<std::string, std::string> ch;
+
+      if (type == 0) ch = identify(img);
+      if (type == 1) ch = identifyChinese(img);
+
+      if (ch.first == char_key) {
+        ++corrects;
+        ++corrects_all;
+      } else {
+        error_files.push_back(std::make_pair(utils::getFileName(file), ch.second));
+      }
+      ++sum;
+      ++sum_all;
+    }
+    float rate = (float)corrects / (sum == 0 ? 1 : sum);
+    fprintf(stdout, ">>   [sum: %d, correct: %d, rate: %.2f]\n", sum, corrects, rate);
+    rate_list.push_back(rate);
+
+    std::string error_string;
+    auto end = error_files.end();
+    if (error_files.size() >= 10) {
+      end -= static_cast<size_t>(error_files.size() * (1 - 0.1));
+    }
+    for (auto k = error_files.begin(); k != end; ++k) {
+      auto kv = *k;
+      error_string.append("       ").append(kv.first).append(": ").append(
+          kv.second);
+      if (k != end - 1) {
+        error_string.append(",\n");
+      } else {
+        error_string.append("\n       ...");
+      }
+    }
+    fprintf(stdout, ">>   [\n%s\n     ]\n", error_string.c_str());
+  }
+  fprintf(stdout, ">>   [sum_all: %d, correct_all: %d, rate: %.4f]\n", sum_all, corrects_all,
+    (float)corrects_all / (sum_all == 0 ? 1 : sum_all));
+
+  double rate_sum = std::accumulate(rate_list.begin(), rate_list.end(), 0.0);
+  double rate_mean = rate_sum / (rate_list.size() == 0 ? 1 : rate_list.size());
+
+  fprintf(stdout, ">>   [classNumber: %d, avg_rate: %.4f]\n", classNumber, rate_mean);
+}
+
+cv::Mat getSyntheticImage(const Mat& image) {
+  int rand_type = rand();
+  Mat result = image.clone();
+
+  if (rand_type % 2 == 0) {
+    int ran_x = rand() % 5 - 2;
+    int ran_y = rand() % 5 - 2;
+
+    result = translateImg(result, ran_x, ran_y);
+  }
+  else if (rand_type % 2 != 0) {
+    float angle = float(rand() % 15 - 7);
+
+    result = rotateImg(result, angle);
+  }
+  
+  return result;
+}
+
+cv::Ptr<cv::ml::TrainData> AnnTrain::sdata(size_t number_for_count) {
+  assert(chars_folder_);
+
+  cv::Mat samples;
+  std::vector<int> labels;
+
+  int classNumber = 0;
+  if (type == 0) classNumber = kCharsTotalNumber;
+  if (type == 1) classNumber = kChineseNumber;
+  
+  srand((unsigned)time(0));
+  for (int i = 0; i < classNumber; ++i) {
+   
+    auto char_key = kChars[i + kCharsTotalNumber - classNumber];
+    char sub_folder[512] = { 0 };
+
+    sprintf(sub_folder, "%s/%s", chars_folder_, char_key);
+    fprintf(stdout, ">> Testing characters %s in %s \n", char_key, sub_folder);
+
+    auto chars_files = utils::getFiles(sub_folder);
+    size_t char_size = chars_files.size();
+    fprintf(stdout, ">> Characters count: %d \n", int(char_size));
+
+    std::vector<cv::Mat> matVec;
+    matVec.reserve(number_for_count);
+    for (auto file : chars_files) {
+      auto img = cv::imread(file, 0);  // a grayscale image
+      matVec.push_back(img);
+    }
+
+    for (int t = 0; t < (int)number_for_count - (int)char_size; t++) {
+      int rand_range = char_size + t;
+      int ran_num = rand() % rand_range;
+      auto img = matVec.at(ran_num);
+      auto simg = getSyntheticImage(img);
+      matVec.push_back(simg);
+      if (1) {
+        std::stringstream ss(std::stringstream::in | std::stringstream::out);
+        ss << sub_folder << "/" << i << "_" << t << "_" << ran_num << ".jpg";
+        imwrite(ss.str(), simg);
+      }
+    }
+
+    fprintf(stdout, ">> Characters count: %d \n", (int)matVec.size());
+
+    for (auto img : matVec) {
+      auto fps = charFeatures2(img, kPredictSize);
+
+      samples.push_back(fps);
+      labels.push_back(i);
+    }
+  } 
+
+  cv::Mat samples_;
+  samples.convertTo(samples_, CV_32F);
+  cv::Mat train_classes =
+    cv::Mat::zeros((int)labels.size(), classNumber, CV_32F);
+
+  for (int i = 0; i < train_classes.rows; ++i) {
+    train_classes.at<float>(i, labels[i]) = 1.f;
+  }
+
+  return cv::ml::TrainData::create(samples_, cv::ml::SampleTypes::ROW_SAMPLE,
+    train_classes);
+}
+
+cv::Ptr<cv::ml::TrainData> AnnTrain::tdata() {
+  assert(chars_folder_);
+
+  cv::Mat samples;
+  std::vector<int> labels;
+
+  std::cout << "Collecting chars in " << chars_folder_ << std::endl;
+
+  int classNumber = 0;
+  if (type == 0) classNumber = kCharsTotalNumber;
+  if (type == 1) classNumber = kChineseNumber;
+
+  for (int i = 0; i < classNumber; ++i) {
+    auto char_key = kChars[i + kCharsTotalNumber - classNumber];
+    char sub_folder[512] = {0};
+
+    sprintf(sub_folder, "%s/%s", chars_folder_, char_key);
+    std::cout << "  >> Featuring characters " << char_key << " in "
+              << sub_folder << std::endl;
+
+    auto chars_files = utils::getFiles(sub_folder);
+    for (auto file : chars_files) {
+      auto img = cv::imread(file, 0);  // a grayscale image
+      auto fps = charFeatures2(img, kPredictSize);
+
+      samples.push_back(fps);
+      labels.push_back(i);
+    }
+  }
+
+  cv::Mat samples_;
+  samples.convertTo(samples_, CV_32F);
+  cv::Mat train_classes =
+    cv::Mat::zeros((int)labels.size(), classNumber, CV_32F);
+
+  for (int i = 0; i < train_classes.rows; ++i) {
+    train_classes.at<float>(i, labels[i]) = 1.f;
+  }
+
+  return cv::ml::TrainData::create(samples_, cv::ml::SampleTypes::ROW_SAMPLE,
+                                   train_classes);
+}
+}

src/train/create_data.cpp

@@ -0,0 +1,88 @@
+#include "easypr/train/create_data.h"
+
+namespace easypr {
+
+  int getBoderColor(Mat img) {
+    assert(img.channels() == 1);
+    assert(img.type() == CV_8UC1);
+    int w = img.cols;
+    int h = img.rows;
+
+    float sum = 0;
+    for (int i = 0; i < h; ++i) {
+      sum += img.at<unsigned char>(i, 0);
+      sum += img.at<unsigned char>(i, w-1);
+    }
+    for (int j = 0; j < w; ++j) {
+      sum += img.at<unsigned char>(0, j);
+      sum += img.at<unsigned char>(h-1, j);
+    }
+
+    float avg = sum / float(w + w + h + h);
+    return int(avg);
+  }
+
+  // shift an image
+  Mat translateImg(Mat img, int offsetx, int offsety, int bk){
+    Mat dst;
+    //cout << test << endl;
+    Mat trans_mat = (Mat_<double>(2, 3) << 1, 0, offsetx, 0, 1, offsety);
+    //cout << trans_mat << endl;
+    warpAffine(img, dst, trans_mat, img.size(), 1, 0, Scalar(bk));
+    return dst;
+  }
+
+  // rotate an image
+  Mat rotateImg(Mat source, float angle, int bk){
+    Point2f src_center(source.cols / 2.0F, source.rows / 2.0F);
+    Mat rot_mat = getRotationMatrix2D(src_center, angle, 1.0);
+    Mat dst;
+    warpAffine(source, dst, rot_mat, source.size(), 1, 0, Scalar(bk));
+    return dst;
+  }
+
+  // crop the image
+  Mat cropImg(Mat src, int x, int y, int shift, int bk){
+    int width = src.cols;
+    int height = src.rows;
+
+    int crop_width = width - shift;
+    int crop_height = height - shift;
+
+    int x_shift = shift;
+    int y_shift = shift;
+
+    x = x < x_shift ? x : x_shift;
+    y = y < y_shift ? y : y_shift;
+
+    Rect rect = Rect(x, y, crop_width, crop_height);
+
+    Mat dst = src(rect);
+    resize(dst, dst, Size(width, height));
+    return dst;
+  }
+
+  Mat generateSyntheticImage(const Mat& image, int use_swap) {
+    int rd = rand();
+    int bkColor = getBoderColor(image);
+    Mat result = image.clone();
+    if (0 && (rd >> 6 & 1)) {
+      int shift = 2;
+      int ran_x = rand() % shift;
+      int ran_y = rand() % shift;
+      result = cropImg(result, ran_x, ran_y, shift, bkColor);
+    }
+    if (0 && (rd >> 4 & 1)) {
+      int ran_x = rand() % 2 - 1;
+      int ran_y = rand() % 2 - 1;
+      result = translateImg(result, ran_x, ran_y, bkColor);
+    }
+    if (1 && (rd >> 2 & 1)) {
+      float angle = float(rand() % 100) * 0.1f - 5.f;
+      result = rotateImg(result, angle, bkColor);
+    }
+
+    return result;
+  }
+}
+

src/train/svm_train.cpp

@@ -0,0 +1,196 @@
+#include "easypr/train/svm_train.h"
+#include "easypr/util/util.h"
+#include "easypr/config.h"
+
+#ifdef OS_WINDOWS
+#include <ctime>
+#endif
+
+using namespace cv;
+using namespace cv::ml;
+
+namespace easypr {
+
+SvmTrain::SvmTrain(const char* plates_folder, const char* xml)
+    : plates_folder_(plates_folder), svm_xml_(xml) {
+  assert(plates_folder);
+  assert(xml);
+
+  extractFeature = getHistomPlusColoFeatures;
+}
+
+void SvmTrain::train() {
+  svm_ = cv::ml::SVM::create();
+  svm_->setType(cv::ml::SVM::C_SVC);
+  svm_->setKernel(cv::ml::SVM::RBF);
+  svm_->setDegree(0.1);
+  // 1.4 bug fix: old 1.4 ver gamma is 1
+  svm_->setGamma(0.1); 
+  svm_->setCoef0(0.1);
+  svm_->setC(1);
+  svm_->setNu(0.1);
+  svm_->setP(0.1);
+  svm_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 20000, 0.0001));
+
+  this->prepare();
+
+  if (train_file_list_.size() == 0) {
+    fprintf(stdout, "No file found in the train folder!\n");
+    fprintf(stdout, "You should create a folder named \"tmp\" in EasyPR main folder.\n");
+    fprintf(stdout, "Copy train data folder(like \"SVM\") under \"tmp\". \n");
+    return;
+  }
+  auto train_data = tdata();
+
+  fprintf(stdout, ">> Training SVM model, please wait...\n");
+  long start = utils::getTimestamp();
+  svm_->trainAuto(train_data, 10, SVM::getDefaultGrid(SVM::C),
+                  SVM::getDefaultGrid(SVM::GAMMA), SVM::getDefaultGrid(SVM::P),
+                  SVM::getDefaultGrid(SVM::NU), SVM::getDefaultGrid(SVM::COEF),
+                  SVM::getDefaultGrid(SVM::DEGREE), true);
+  //svm_->train(train_data);
+
+  long end = utils::getTimestamp();
+  fprintf(stdout, ">> Training done. Time elapse: %ldms\n", end - start);
+  fprintf(stdout, ">> Saving model file...\n");
+  svm_->save(svm_xml_);
+
+  fprintf(stdout, ">> Your SVM Model was saved to %s\n", svm_xml_);
+  fprintf(stdout, ">> Testing...\n");
+
+  this->test();
+  
+}
+
+void SvmTrain::test() {
+  // 1.4 bug fix: old 1.4 ver there is no null judge
+  // if (NULL == svm_)
+  LOAD_SVM_MODEL(svm_, svm_xml_);
+
+  if (test_file_list_.empty()) {
+    this->prepare();
+  }
+ 
+  double count_all = test_file_list_.size();
+  double ptrue_rtrue = 0;
+  double ptrue_rfalse = 0;
+  double pfalse_rtrue = 0;
+  double pfalse_rfalse = 0;
+
+  for (auto item : test_file_list_) {
+    auto image = cv::imread(item.file);
+    if (!image.data) {
+      std::cout << "no" << std::endl;
+      continue;
+    }
+    cv::Mat feature;
+    extractFeature(image, feature);
+
+    auto predict = int(svm_->predict(feature));
+    //std::cout << "predict: " << predict << std::endl;
+
+    auto real = item.label;
+    if (predict == kForward && real == kForward) ptrue_rtrue++;
+    if (predict == kForward && real == kInverse) ptrue_rfalse++;
+    if (predict == kInverse && real == kForward) pfalse_rtrue++;
+    if (predict == kInverse && real == kInverse) pfalse_rfalse++;
+  }
+
+  std::cout << "count_all: " << count_all << std::endl;
+  std::cout << "ptrue_rtrue: " << ptrue_rtrue << std::endl;
+  std::cout << "ptrue_rfalse: " << ptrue_rfalse << std::endl;
+  std::cout << "pfalse_rtrue: " << pfalse_rtrue << std::endl;
+  std::cout << "pfalse_rfalse: " << pfalse_rfalse << std::endl;
+
+  double precise = 0;
+  if (ptrue_rtrue + ptrue_rfalse != 0) {
+    precise = ptrue_rtrue / (ptrue_rtrue + ptrue_rfalse);
+    std::cout << "precise: " << precise << std::endl;
+  } else {
+    std::cout << "precise: "
+              << "NA" << std::endl;
+  }
+
+  double recall = 0;
+  if (ptrue_rtrue + pfalse_rtrue != 0) {
+    recall = ptrue_rtrue / (ptrue_rtrue + pfalse_rtrue);
+    std::cout << "recall: " << recall << std::endl;
+  } else {
+    std::cout << "recall: "
+              << "NA" << std::endl;
+  }
+
+  double Fsocre = 0;
+  if (precise + recall != 0) {
+    Fsocre = 2 * (precise * recall) / (precise + recall);
+    std::cout << "Fsocre: " << Fsocre << std::endl;
+  } else {
+    std::cout << "Fsocre: "
+              << "NA" << std::endl;
+  }
+}
+
+void SvmTrain::prepare() {
+  srand(unsigned(time(NULL)));
+
+  char buffer[260] = {0};
+
+  sprintf(buffer, "%s/has/train", plates_folder_);
+  auto has_file_train_list = utils::getFiles(buffer);
+  std::random_shuffle(has_file_train_list.begin(), has_file_train_list.end());
+
+  sprintf(buffer, "%s/has/test", plates_folder_);
+  auto has_file_test_list = utils::getFiles(buffer);
+  std::random_shuffle(has_file_test_list.begin(), has_file_test_list.end());
+
+  sprintf(buffer, "%s/no/train", plates_folder_);
+  auto no_file_train_list = utils::getFiles(buffer);
+  std::random_shuffle(no_file_train_list.begin(), no_file_train_list.end());
+
+  sprintf(buffer, "%s/no/test", plates_folder_);
+  auto no_file_test_list = utils::getFiles(buffer);
+  std::random_shuffle(no_file_test_list.begin(), no_file_test_list.end());
+
+  fprintf(stdout, ">> Collecting train data...\n");
+
+  for (auto file : has_file_train_list)
+    train_file_list_.push_back({ file, kForward });
+
+  for (auto file : no_file_train_list)
+    train_file_list_.push_back({ file, kInverse });
+
+  fprintf(stdout, ">> Collecting test data...\n");
+
+  for (auto file : has_file_test_list)
+    test_file_list_.push_back({ file, kForward });
+
+  for (auto file : no_file_test_list)
+    test_file_list_.push_back({ file, kInverse });
+}
+
+cv::Ptr<cv::ml::TrainData> SvmTrain::tdata() {
+  cv::Mat samples;
+  std::vector<int> responses;
+
+  for (auto f : train_file_list_) {
+    auto image = cv::imread(f.file);
+    if (!image.data) {
+      fprintf(stdout, ">> Invalid image: %s  ignore.\n", f.file.c_str());
+      continue;
+    }
+    cv::Mat feature;
+    extractFeature(image, feature);
+    feature = feature.reshape(1, 1);
+
+    samples.push_back(feature);
+    responses.push_back(int(f.label));
+  }
+
+  cv::Mat samples_, responses_;
+  samples.convertTo(samples_, CV_32FC1);
+  cv::Mat(responses).copyTo(responses_);
+
+  return cv::ml::TrainData::create(samples_, cv::ml::SampleTypes::ROW_SAMPLE, responses_);
+}
+
+}  // namespace easypr

src/train/train.cpp

@@ -0,0 +1,8 @@
+#include "easypr/train/train.h"
+
+namespace easypr {
+
+ITrain::ITrain() {}
+
+ITrain::~ITrain() {}
+}

src/util/kv.cpp

@@ -0,0 +1,81 @@
+#include "easypr/util/kv.h"
+#include "easypr/util/util.h"
+
+namespace easypr {
+
+Kv::Kv() { }
+
+void Kv::load(const std::string &file) {
+  this->clear();
+  std::ifstream reader(file);
+  assert(reader);
+
+  if (reader.is_open()) {
+    while (!reader.eof()) {
+      std::string line;
+      std::getline(reader, line);
+      if (line.empty()) continue;
+
+      const auto parse = [](const std::string &str) {
+        std::string tmp, key, value;
+        for (size_t i = 0, len = str.length(); i < len; ++i) {
+          const char ch = str[i];
+          if (ch == ' ') {
+            if (i > 0 && str[i - 1] != ' ' && key.empty()) {
+              key = tmp;
+              tmp.clear();
+            }
+          }
+          else {
+            tmp.push_back(ch);
+          }
+          if (i == len - 1) {
+            value = tmp;
+          }
+        }
+        return std::make_pair(key, value);
+      };
+
+      auto kv = parse(line);
+      this->add(kv.first, kv.second);
+    }
+    reader.close();
+  }
+}
+
+std::string Kv::get(const std::string &key) {
+  if (data_.find(key) == data_.end()) {
+    std::cerr << "[Kv] cannot find " << key << std::endl;
+    return "";
+  }
+  return data_.at(key);
+}
+
+void Kv::add(const std::string &key, const std::string &value) {
+  if (data_.find(key) != data_.end()) {
+    fprintf(stderr,
+            "[Kv] find duplicate: %s = %s , ignore\n",
+            key.c_str(),
+            value.c_str());
+  } else {
+    std::string v(value);
+#ifdef OS_WINDOWS
+    v = utils::utf8_to_gbk(value.c_str());
+#endif
+    data_[key] = v;
+  }
+}
+
+void Kv::remove(const std::string &key) {
+  if (data_.find(key) == data_.end()) {
+    std::cerr << "[Kv] cannot find " << key << std::endl;
+    return;
+  }
+  data_.erase(key);
+}
+
+void Kv::clear() {
+  data_.clear();
+}
+
+}

src/util/program_options.cpp

@@ -0,0 +1,540 @@
+#include "easypr/util/program_options.h"
+
+namespace program_options {
+
+// class ParseError
+
+ParseError::ParseError(const std::string& msg) : _msg(msg) {}
+
+const char* ParseError::what() const throw() {
+  std::string msg;
+  msg.append("Command line parse error: ").append(_msg).push_back('.');
+  return msg.c_str();
+}
+
+ParseError::~ParseError() throw() {}
+
+// class Generator
+
+Generator::Generator() : parser_(nullptr) {
+  current_subroutine_ = Subroutine::get_default_name();
+  add_subroutine(current_subroutine_.c_str());
+}
+
+Generator::~Generator() {
+  if (parser_) {
+    delete parser_;
+    parser_ = nullptr;
+  }
+  for (auto it = subroutines_.begin(); it != subroutines_.end(); ++it) {
+    if (it->second) {
+      delete it->second;
+      it->second = nullptr;
+    }
+  }
+}
+
+Generator& Generator::make_usage(const char* first_line) {
+  get_subroutine()->set_first_line(first_line);
+  return *this;
+}
+
+Parser* Generator::make_parser() {
+  if (parser_) delete parser_;
+  parser_ = new Parser;
+  parser_->set_usage_subroutines(&subroutines_);
+  return parser_;
+}
+
+Generator& Generator::add_subroutine(const char* name) {
+  add_subroutine(name, "");
+  return *this;
+}
+
+Generator& Generator::add_subroutine(const char* name,
+                                     const char* description) {
+  if (subroutines_.find(name) == subroutines_.end()) {
+    // a new subroutine
+    current_subroutine_ = name;
+    Subroutine* routine = new Subroutine(name, description);
+    subroutines_.insert({current_subroutine_, routine});
+  }
+  return *this;
+}
+
+std::map<std::string, std::string> Generator::get_subroutine_list() {
+  std::map<std::string, std::string> kv;
+  for (auto pr : subroutines_) {
+    Subroutine* subroutine = pr.second;
+    if (subroutine->get_name() != Subroutine::get_default_name())
+      kv[subroutine->get_name()] = subroutine->get_description();
+  }
+  return std::move(kv);
+}
+
+bool Generator::add_usage_line(const char* option, const char* default_value,
+                               const char* description) {
+  std::string option_str(option);
+  auto delimiter_pos = option_str.find(kDelimiter);
+
+  std::string option_short;
+  std::string option_long;
+
+  if (delimiter_pos != std::string::npos) {
+    option_short.assign(std::move(option_str.substr(0, delimiter_pos)));
+    option_long.assign(std::move(option_str.substr(delimiter_pos + 1)));
+
+    Row row;
+    row.oshort(option_short);
+    row.olong(option_long);
+    row.value(default_value);
+    row.desc(description);
+
+    get_subroutine()->add_usage_line(row);
+    return true;
+  }
+  return false;
+}
+
+std::ostream& operator<<(std::ostream& out, Generator& generator) {
+  for (auto pr : generator.subroutines_) {
+    Subroutine* subroutine = pr.second;
+    if (subroutine->get_name() != Subroutine::get_default_name()) {
+      out << subroutine->get_name() << "\t";
+    }
+    out << subroutine->get_description();
+    if (!subroutine->get_usage().empty()) {
+      out << std::endl;
+    }
+    out << *subroutine;
+  }
+  return out;
+}
+
+// class ParseItem
+
+ParseItem::ParseItem(const std::string& value) : value_(value) {}
+
+// class Parser
+
+ParseItem* Parser::get(const std::string& key) {
+  if (pr_->find(key) != pr_->end()) {
+    return (*pr_)[key];
+  }
+  return nullptr;
+}
+
+Parser::Parser() : subroutines_(nullptr), pr_(nullptr) {}
+
+Parser::~Parser() { this->cleanup(); }
+
+Parser::ParseResult* Parser::parse(const int argc, const char** argv) {
+  if (!this->init(argc, argv)) {
+    return nullptr;
+  }
+  auto ibegin = args_.begin() + 1;  // ignore the first cmd name
+  auto iend = args_.end();
+  auto it = ibegin;
+
+  if (argc >= 2 && args_[1][0] != '-') {
+    // the second block may be a subroutine name
+    // e.g., ./exec pull --option
+    if (subroutines_ && (subroutines_->find(args_[1]) != subroutines_->end())) {
+      subroutine_name_ = args_[1];
+      it++;  // ignore the subroutine name
+    } else {
+      subroutine_name_ = args_[1];
+    }
+  } else {
+    // there is no options as well as subroutine name
+    // e.g., ./exec
+    subroutine_name_ = Subroutine::get_default_name();
+  }
+
+  std::string block;
+  std::string previous(*ibegin);
+
+  for (; it != iend; ++it) {
+    block.assign(*it);
+
+    switch (block.size()) {
+      case 1:
+        if (block == "-") {
+          throw ParseError("single '-' is not allowed");
+        }
+        break;
+      case 2:
+        if (block[0] == '-') {
+          if (block[1] == '-') {
+            throw ParseError("option '--' is incomplete");
+          } else if (block[1] == '=') {
+            throw ParseError("option '-=' is invalid");
+          } else {
+            // single option
+            // e.g., ./exec -s
+            (*pr_)[block.substr(1)] = nullptr;
+          }
+        }
+        break;
+      default:  // >=3
+        if (block[0] == '-') {
+          if (block[1] == '-') {
+            size_t pos_equal = block.find('=');
+            if (pos_equal == std::string::npos) {
+              // a long format option
+              // e.g., ./exec --option
+              (*pr_)[block.substr(2)] = nullptr;
+            } else {
+              if (pos_equal > 3) {
+                // e.g, ./exec --op[..=]value
+                std::string key(block.substr(2, pos_equal - 2));
+                if (block.size() > 5)
+                  // e.g, ./exec --op=v
+                  (*pr_)[key] = new ParseItem(block.substr(pos_equal + 1));
+                else
+                  (*pr_)[key] = nullptr;
+              } else {
+                // a long format option but = is illegal
+                // e.g., ./exec --o=[...]
+                (*pr_)[block.substr(2)] = nullptr;
+              }
+            }
+          } else if (block[2] == '=') {
+            // a single option with =
+            // e.g., ./exec -o=[...]
+            std::string key;
+            key.push_back(block[1]);
+            if (block.size() > 3)
+              (*pr_)[key] = new ParseItem(block.substr(3));
+            else
+              (*pr_)[key] = nullptr;
+          } else {
+            // a combination options
+            // e.g., ./exec -ab[...]
+            auto tbegin = block.begin() + 1;  // ignore the first '-'
+            auto tend = block.end();
+            auto t = tbegin;
+
+            for (; t != tend; ++t) {
+              std::string key;
+              key.push_back(*t);
+              (*pr_)[key] = nullptr;
+            }
+          }
+        }
+        break;
+    }  // switch
+
+    if (block[0] != '-' && previous != block  // not the first option
+        ) {
+      if (previous[0] != '-') {
+        // previous is not an option, error occur
+        // e.g., ./exec abc def
+        throw ParseError("'" + block + "' is not allowed here");
+      }
+
+      std::string key;
+
+      if (previous[0] == '-' && previous[1] == '-') {
+        // previous is a long format option.
+        // e.g., ./exec --option value
+        key = previous.substr(2);
+      } else {
+        // it's the value of previous option.
+        // e.g., ./exec -o   [...]
+        // e.g., ./exec -opq [...]
+        key.push_back(*(previous.end() - 1));
+      }
+
+      if (pr_->find(key) != pr_->end()) {
+        (*pr_)[key] = new ParseItem(block);
+      }
+    }
+
+    previous = block;
+  }  // for
+
+  if (subroutines_) {
+    this->set_addition();
+  }
+
+  return pr_;
+}
+
+Parser::ParseResult* Parser::parse(const char* command_line) {
+  int i = 0;
+  std::string block;
+  std::vector<std::string> blocks;
+  char c;
+  while ((c = command_line[i++]) != '\0') {
+    if (c != ' ') {
+      block.push_back(c);
+    } else {
+      if (!block.empty()) {
+        blocks.push_back(block);
+      }
+      block.clear();
+    }
+  }
+  if (!block.empty()) {
+    blocks.push_back(block);
+  }
+  size_t size = blocks.size();  // argc
+  char** argv = new char*[size];
+  i = 0;
+  std::for_each(blocks.begin(), blocks.end(), [argv, &i](const std::string& b) {
+    argv[i++] = const_cast<char*>(b.c_str());
+  });
+  auto pr =
+      this->parse(static_cast<const int>(size), const_cast<const char**>(argv));
+
+  delete[] argv;
+  argv = nullptr;
+
+  return pr;
+}
+
+bool Parser::has(const char* key) {
+  std::string skey(key);
+
+  if (pr_ && !pr_->empty() && !skey.empty()) {
+    if (skey[0] == '-') {
+      // check combination options, e.g., Parser::has("-xyz")
+      for (size_t i = 1; i < skey.size(); ++i) {
+        std::string tkey;
+        tkey.push_back(skey[i]);
+        if (pr_->find(tkey) == pr_->end()) {
+          return false;
+        }
+      }
+      return true;
+    } else {
+      // check single option, e.g., Parser::has("x")
+      return pr_->find(skey) != pr_->end();
+    }
+  }
+  return false;
+}
+
+bool Parser::has_or(std::initializer_list<const char*> options) {
+  if (options.size() == 0) {
+    return false;
+  }
+  for (auto key : options) {
+    if (this->has(key)) return true;
+  }
+  return false;
+}
+
+bool Parser::has_and(std::initializer_list<const char*> options) {
+  if (options.size() == 0) {
+    return false;
+  }
+  for (auto key : options) {
+    if (!this->has(key)) return false;
+  }
+  return true;
+}
+
+bool Parser::init(const int argc, const char** argv) {
+  argc_ = argc;
+  // argv_ = argv;
+  // don't save it, point to a local var in parse(const char* command_line).
+  // use member var args_ instead.
+  if (argc > 0) {
+    this->cleanup();
+
+    args_.reserve(static_cast<size_t>(argc_));
+
+    for (int i = 0; i < argc_; ++i) {
+      args_.push_back(argv[i]);
+    }
+
+    pr_ = new Parser::ParseResult;
+    return true;
+  }
+  return false;
+}
+
+void Parser::cleanup() {
+  args_.clear();
+  if (pr_) {
+    auto ibegin = pr_->begin();
+    auto iend = pr_->end();
+    auto it = ibegin;
+    for (; it != iend; ++it) {
+      ParseItem* item = it->second;
+      if (item) delete item;
+    }
+    delete pr_;
+    pr_ = nullptr;
+  }
+}
+
+void Parser::set_addition() {
+  if (subroutines_->find(subroutine_name_) != subroutines_->end()) {
+    for (const Row& row : *(subroutines_->at(subroutine_name_))) {
+      // assume both -o and --option are allowed,
+      // but only provide -o,
+      // then set the another --option.
+      // vice versa.
+      const std::string& def = row.value();
+      const std::string& ops = row.oshort();
+      const std::string& opl = row.olong();
+      ParseResult& pr = *pr_;
+
+      bool has_short = this->has(ops.c_str());
+      bool has_long = this->has(opl.c_str());
+
+      // assume -o [ --option ] arg = 1
+      // but not provide option value,
+      // then set to default 1.
+      // otherwise, both set to user defined value
+
+      if (!ops.empty()) {
+        if (has_short) {
+          if (pr[ops] != nullptr && !opl.empty()) {
+            pr[opl] = new ParseItem(std::move(pr[ops]->val()));
+          } else if (pr[ops] == nullptr && !def.empty()) {
+            pr[ops] = new ParseItem(std::move(def));
+            if (!opl.empty()) pr[opl] = new ParseItem(std::move(def));
+          } else {
+            pr[opl] = nullptr;
+          }
+        }
+      }
+
+      if (!opl.empty()) {
+        if (has_long) {
+          if (pr[opl] != nullptr && !ops.empty()) {
+            pr[ops] = new ParseItem(std::move(pr[opl]->val()));
+          } else if (pr[opl] == nullptr && !def.empty()) {
+            if (!ops.empty()) pr[ops] = new ParseItem(std::move(def));
+            pr[opl] = new ParseItem(std::move(def));
+          } else {
+            pr[ops] = nullptr;
+          }
+        }
+      }
+
+      if (!has_long && !has_short && !def.empty()) {
+        if (!opl.empty()) pr[opl] = new ParseItem(std::move(def));
+        if (!ops.empty()) pr[ops] = new ParseItem(std::move(def));
+      }
+    }  // for
+  }    // if
+}
+
+// class Row
+
+Row::Row() : require_value(true) {}
+
+// class Subroutine
+
+Subroutine::Subroutine() : first_line_("") {}
+
+Subroutine::Subroutine(const char* name, const char* description)
+    : first_line_(""), description_(description), name_(name) {
+  usages_.reserve(5);
+}
+
+void Subroutine::print_with_row(std::ostream& out) {
+  // print the subroutine name and its description
+  if (strcmp(get_first_line(), "") != 0) {
+    // print the first line
+    out << get_first_line();
+    if (!usages_.empty()) {
+      out << std::endl;
+    }
+  }
+  auto begin = usages_.begin();
+  auto end = usages_.end();
+
+  std::vector<std::string> row_list;
+  row_list.reserve(usages_.size());
+
+  // build usage rows without description field,
+  // find the max-len row at the same time.
+  size_t max_len = 0;
+  std::for_each(begin, end, [&max_len, &row_list](const Row& row) {
+    std::stringstream ss;
+    ss << "  ";
+    if (!row.oshort().empty()) {
+      ss << "-" << row.oshort() << " ";
+    }
+    if (!row.olong().empty()) {
+      if (!row.oshort().empty())
+        ss << "[ --" << row.olong() << " ] ";
+      else
+        ss << "--" << row.olong() << " ";
+    }
+
+    if (row.required()) {
+      ss << "arg ";
+      if (!row.value().empty()) {
+        ss << "= " << row.value() << " ";
+      }
+    }
+
+    max_len = std::max(max_len, ss.str().size());
+    row_list.push_back(std::move(ss.str()));
+  });
+
+  // show all rows and align description field
+  size_t row_count = usages_.size();
+  for (size_t i = 0; i < row_count; ++i) {
+    std::string str_row(std::move(row_list[i]));
+    // print row without description
+    out << str_row;
+    // print spaces
+    size_t spaces = 0;
+    size_t len = str_row.size();
+    if (max_len > len) spaces = max_len - len;
+
+    while (spaces--) {
+      out << " ";
+    }
+    // print description
+    out << usages_.at(i).desc() << std::endl;
+  }
+}
+
+void Subroutine::print_with_template(std::ostream& out) {
+  for (auto usage : usages_) {
+    size_t i = 0;
+    for (auto t = template_str_.begin(); t != template_str_.end(); ++t) {
+      if (*t == '%') {
+        switch (*(order_.begin() + i)) {
+          case Row::kShort:
+            out << usage.oshort();
+            break;
+          case Row::kLong:
+            out << usage.olong();
+            break;
+          case Row::kDefault:
+            out << usage.value();
+            break;
+          case Row::kDescription:
+            out << usage.desc();
+            break;
+          default:
+            break;
+        }
+        ++i;
+      } else {
+        out << *t;
+      }  // if %
+    }    // for template_str_
+    out << std::endl;
+  }  // for usages_
+}
+
+std::ostream& operator<<(std::ostream& out, Subroutine& subroutine) {
+  if (subroutine.template_str_.empty()) {
+    subroutine.print_with_row(out);
+  } else {
+    subroutine.print_with_template(out);
+  }
+  return out;
+}
+}

src/util/util.cpp

@@ -0,0 +1,293 @@
+#include "easypr/util/util.h"
+#include <string>
+
+#ifdef OS_WINDOWS
+#include <windows.h>
+#include <direct.h>
+#include <io.h>
+#define PATH_DELIMITER '\\'
+#ifdef min
+#undef min
+#endif
+
+#ifdef max
+#undef max
+#endif
+#elif defined(OS_LINUX) || defined(OS_UNIX)
+
+#include <cstring>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#define PATH_DELIMITER '/'
+#endif
+
+#ifdef OS_UNIX
+
+#include <sys/timeb.h>
+
+#endif
+
+#include <list>
+#include <opencv2/highgui/highgui.hpp>
+
+namespace easypr {
+
+long Utils::getTimestamp() {
+#ifdef OS_WINDOWS
+  return static_cast<long>(cv::getTickCount());
+#endif
+
+#ifdef OS_LINUX
+  struct timespec ts;
+
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+
+  return (ts.tv_sec * 1e3 + ts.tv_nsec / 1e6);
+#endif
+
+#ifdef OS_UNIX
+  // there is no function provided by osx to get system tick count.
+  // but considering the purpose by using this function,
+  // we can simply return a millisecond since 1970/1/1 to calc the time elapse.
+  struct timeb tb;
+  ftime(&tb);
+  return long(tb.time * 1e3 + tb.millitm);
+#endif
+}
+
+std::string Utils::getFileName(const std::string &path,
+                               const bool postfix /* = false */) {
+  if (!path.empty()) {
+    size_t last_slash = utils::get_last_slash(path);
+    size_t last_dot = path.find_last_of('.');
+
+    if (last_dot < last_slash || last_dot == std::string::npos) {
+      // not found the right dot of the postfix,
+      // return the file name directly
+      return path.substr(last_slash + 1);
+    } else {
+      // the path has a postfix
+      if (postfix) {
+        // return the file name including postfix
+        return path.substr(last_slash + 1);
+      }
+      // without postfix
+      return path.substr(last_slash + 1, last_dot - last_slash - 1);
+    }
+  }
+  return "";
+}
+
+std::vector<std::string> Utils::splitString(const std::string &str,
+                                            const char delimiter) {
+  std::vector<std::string> splited;
+  std::string s(str);
+  size_t pos;
+
+  while ((pos = s.find(delimiter)) != std::string::npos) {
+    std::string sec = s.substr(0, pos);
+
+    if (!sec.empty()) {
+      splited.push_back(s.substr(0, pos));
+    }
+
+    s = s.substr(pos + 1);
+  }
+
+  splited.push_back(s);
+
+  return splited;
+}
+
+std::vector<std::string> Utils::getFiles(const std::string &folder,
+                                         const bool all /* = true */) {
+  std::vector<std::string> files;
+  std::list<std::string> subfolders;
+  subfolders.push_back(folder);
+#ifdef OS_WINDOWS
+  while (!subfolders.empty()) {
+    std::string current_folder(subfolders.back());
+
+    if (*(current_folder.end() - 1) != '/') {
+      current_folder.append("/*");
+    } else {
+      current_folder.append("*");
+    }
+
+    subfolders.pop_back();
+
+    struct _finddata_t file_info;
+    auto file_handler = _findfirst(current_folder.c_str(), &file_info);
+
+    while (file_handler != -1) {
+      if (all &&
+          (!strcmp(file_info.name, ".") || !strcmp(file_info.name, ".."))) {
+        if (_findnext(file_handler, &file_info) != 0) break;
+        continue;
+      }
+
+      if (file_info.attrib & _A_SUBDIR) {
+        // it's a sub folder
+        if (all) {
+          // will search sub folder
+          std::string folder(current_folder);
+          folder.pop_back();
+          folder.append(file_info.name);
+
+          subfolders.push_back(folder.c_str());
+        }
+      } else {
+        // it's a file
+        std::string file_path;
+        // current_folder.pop_back();
+        file_path.assign(current_folder.c_str()).pop_back();
+        file_path.append(file_info.name);
+
+        files.push_back(file_path);
+      }
+
+      if (_findnext(file_handler, &file_info) != 0) break;
+    }  // while
+    _findclose(file_handler);
+  }
+#elif defined(OS_LINUX) || defined(OS_UNIX)
+  while (!subfolders.empty()) {
+    std::string current_folder(subfolders.back());
+
+    if (*(current_folder.end() - 1) != '/') {
+      current_folder.push_back('/');
+    }
+
+    DIR* pdir = opendir(current_folder.c_str());
+
+    subfolders.pop_back();
+
+    if (!pdir) {
+      continue;
+    }
+
+    dirent* dir = NULL;
+
+    while ((dir = readdir(pdir)) != NULL) {
+      // iterates the current folder, search file & sub folder
+      struct stat st;
+
+      if (all && (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))) {
+        // must ignore . & ..
+        continue;
+      }
+
+      if (!strcmp(dir->d_name, ".DS_Store")) {
+        // in OSX, 'finder' will create .DS_Store
+        continue;
+      }
+
+      std::string file_path;
+
+      file_path.append(current_folder.c_str());
+      file_path.append(dir->d_name);
+
+      if (lstat(file_path.c_str(), &st) < 0) {
+        // perror("lstat");
+        continue;
+      }
+
+      if (S_ISDIR(st.st_mode)) {
+        // it's a sub folder
+        if (all) {
+          // will search sub folder
+          std::string subfolder(current_folder);
+          subfolder.append(dir->d_name);
+
+          subfolders.push_back(subfolder.c_str());
+        }
+      } else {
+        // it's a file
+        files.push_back(file_path);
+      }
+    }  // while
+    closedir(pdir);
+  }
+#endif
+  return files;
+}
+
+bool Utils::mkdir(const std::string folder) {
+  std::string folder_builder;
+  std::string sub;
+  sub.reserve(folder.size());
+  for (auto it = folder.begin(); it != folder.end(); ++it) {
+    const char c = *it;
+    sub.push_back(c);
+    if (c == PATH_DELIMITER || it == folder.end() - 1) {
+      folder_builder.append(sub);
+#ifdef OS_WINDOWS
+      if (0 != ::_access(folder_builder.c_str(), 0)) {
+#else
+      if (0 != ::access(folder_builder.c_str(), 0)) {
+#endif
+        // this folder not exist
+#ifdef OS_WINDOWS
+        if (0 != ::_mkdir(folder_builder.c_str())) {
+#else
+        if (0 != ::mkdir(folder_builder.c_str(), S_IRWXU)) {
+#endif
+          // create failed
+          return false;
+        }
+      }
+      sub.clear();
+    }
+  }
+  return true;
+}
+
+bool Utils::imwrite(const std::string &file, const cv::Mat &image) {
+  auto folder = file.substr(0, utils::get_last_slash(file));
+  Utils::mkdir(folder);
+  return cv::imwrite(file, image);
+}
+
+#ifdef OS_WINDOWS
+std::string Utils::utf8_to_gbk(const char* utf8) {
+  int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
+  wchar_t* wszGBK = new wchar_t[len + 1];
+  memset(wszGBK, 0, len * 2 + 2);
+  MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wszGBK, len);
+  len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
+  char* szGBK = new char[len + 1];
+  memset(szGBK, 0, len + 1);
+  WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
+  std::string strTemp(szGBK);
+  if (wszGBK)
+    delete[] wszGBK;
+  if (szGBK)
+    delete[] szGBK;
+  return strTemp;
+}
+#endif
+
+std::size_t Utils::get_last_slash(const std::string &path) {
+#ifdef OS_WINDOWS
+  size_t last_slash_1 = path.find_last_of("\\");
+  size_t last_slash_2 = path.find_last_of("/");
+  size_t last_slash;
+
+  if (last_slash_1 != std::string::npos && last_slash_2 != std::string::npos) {
+    // C:/path\\to/file.postfix
+    last_slash = std::max(last_slash_1, last_slash_2);
+  } else {
+    // C:\\path\\to\\file.postfix
+    // C:/path/to/file.postfix
+    last_slash =
+        (last_slash_1 == std::string::npos) ? last_slash_2 : last_slash_1;
+  }
+#else
+  size_t last_slash = path.find_last_of('/');
+#endif
+  return last_slash;
+}
+
+}  // namespace easypr