new

121.txt

@@ -0,0 +1 @@
+123123

src/src/core/chars_identify.cpp

@@ -7,595 +7,448 @@
 
 using namespace cv;
 
-namespace easypr
-{
+namespace easypr {
 
-  CharsIdentify *CharsIdentify::instance_ = nullptr;
+CharsIdentify* CharsIdentify::instance_ = nullptr;
 
-  CharsIdentify *CharsIdentify::instance()
-  {
-    if (!instance_)
-    {
-      instance_ = new CharsIdentify;
-    }
-    return instance_;
+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);
+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);
+  kv_ = std::shared_ptr<Kv>(new Kv);
+  kv_->load(kChineseMappingPath);
 
-    extractFeature = getGrayPlusProject;
-  }
+  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::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::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::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::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;
-    // 创建一个新的矩阵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++)
-        {
-          float val = output_row.at<float>(j);
-          // std::cout << "j:" << j << "val:" << val << std::endl;
-          if (val > maxVal)
-          {
-            maxVal = val;
-            result = j;
-          }
-        }
-      }
-      // 如果该行是中文字符，
-      // 则从kCharactersNumber开始遍历后面的预测结果，找出值最大的那个，并记录其索引和值。
-      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和out_maxVals的相应位置
-      out_maxIndexs[output_index] = result;
-      out_maxVals[output_index] = maxVal;
-    }
-  }
+void CharsIdentify::classify(cv::Mat featureRows, std::vector<int>& out_maxIndexs,
+                             std::vector<float>& out_maxVals, std::vector<bool> isChineseVec){
+  int rowNum = featureRows.rows;
 
-  // 接受一个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();
-      Mat feature = charFeatures(charInput, kPredictSize);
-      featureRows.push_back(feature);
-    }
+  cv::Mat output(rowNum, kCharsTotalNumber, CV_32FC1);
+  ann_->predict(featureRows, output);
 
-    // 创建一个输出矩阵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);
-
-      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;
-      }
-      // 如果字符是中文字符，函数则从预测结果的后面部分开始查找最大值，并记录其索引和值。
-      // 然后，函数根据这个最大值和索引确定预测的字符，并通过键值对（kv_）查找对应的省份，将字符和省份作为标签。
-      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;
-          }
+  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;
         }
-        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;
-    // 通过循环提取每个字符的特征，并存储在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);
-      bool isChinese = true;
-
-      float maxVal = -2;
-      int result = 0;
-
-      for (int j = 0; j < kChineseNumber; 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)
-        {
+        //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;
+  }
+}
 
-      // no match
-      if (-1 == result)
-      {
-        result = 0;
-        maxVal = 0;
-        isChinese = false;
-      }
 
-      // 根据这个最大值和索引确定预测的字符。
-      // 这是通过查找kChars数组实现的，其中kChars可能是一个预定义的字符集。
-      auto index = result + kCharsTotalNumber - kChineseNumber;
-      const char *key = kChars[index];
-      std::string s = key;
-      std::string province = kv_->get(s);
+void CharsIdentify::classify(std::vector<CCharacter>& charVec){
+  size_t charVecSize = charVec.size();
 
-      /*std::cout << "result:" << result << std::endl;
-      std::cout << "maxVal:" << maxVal << std::endl;*/
+  if (charVecSize == 0)
+    return;
 
-      // 将预测的最大值、预测的字符以及对应的省份作为标签，
-      // 分别设置到对应字符对象的得分、字符串属性和是否为中文字符属性中
-      character.setCharacterScore(maxVal);
-      character.setCharacterStr(province);
-      character.setIsChinese(isChinese);
-    }
+  Mat featureRows;
+  for (size_t index = 0; index < charVecSize; index++) {
+    Mat charInput = charVec[index].getCharacterMat();
+    Mat feature = charFeatures(charInput, kPredictSize);
+    featureRows.push_back(feature);
   }
 
-  // 使用OpenCV库和神经网络进行中文字符识别
-  void CharsIdentify::classifyChinese(std::vector<CCharacter> &charVec)
-  {
-    size_t charVecSize = charVec.size();
-
-    if (charVecSize == 0)
-      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);
+  cv::Mat output(charVecSize, kCharsTotalNumber, CV_32FC1);
+  ann_->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);
-      bool isChinese = true;
+  for (size_t output_index = 0; output_index < charVecSize; output_index++) {
+    CCharacter& character = charVec[output_index];
+    Mat output_row = output.row(output_index);
 
-      float maxVal = -2;
-      int result = 0;
+    int result = 0;
+    float maxVal = -2.f;
+    std::string label = "";
 
-      for (int j = 0; j < kChineseNumber; j++)
-      {
+    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)
-        {
+        //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;
-      }
-
-      // 计算索引值，并使用该索引从kChars数组中获取对应的字符。
-      // 同时，通过键值对（kv_）查找与该字符对应的省份。
-      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;*/
-
-      // 将最大值、省份和isChinese作为标签，分别设置到对应字符对象的得分、字符串属性和是否为中文字符属性中。
-      character.setCharacterScore(maxVal);
-      character.setCharacterStr(province);
-      character.setIsChinese(isChinese);
+      label = std::make_pair(kChars[result], kChars[result]).second;
     }
-  }
-
-  // 对输入的图像数据进行分类
-  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)
-      {
-        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
-    {
+    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)
-        {
+      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;
     }
-    // 返回索引值result，该值是预测的字符在预先定义的字符集kChars中的索引。
-    // 同时，它也将最大值maxVal和对应的索引result设置到输入的float引用maxVal中，以便调用者可以访问这些值。
-    // std::cout << "maxVal:" << maxVal << std::endl;
-    return result;
+    /*std::cout << "result:" << result << std::endl;
+    std::cout << "maxVal:" << maxVal << std::endl;*/
+    character.setCharacterScore(maxVal);
+    character.setCharacterStr(label);
   }
-  // 根据输入的图像数据判断它是否是一个字符（特别是中文字符）
-  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;
-      }
-      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;
+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);
   }
-  // 用于识别输入的图像数据是否是一个中文字符。
-  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);
+
+  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;
 
-    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;
-      if (val > maxVal)
-      {
+    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
-    // 如果索引值为-1（即没有匹配的字符），
-    // 则将result设置为0，maxVal设置为0，并将isChinese设置为false，表示输入的字符不是中文。
-    if (-1 == result)
-    {
+    if (-1 == result) {
       result = 0;
       maxVal = 0;
       isChinese = false;
     }
-    else if (maxVal > 0.9)
-    {
-      isChinese = true;
-    }
-    // 通过索引值获取字符的标签和省份，并将最大值保存到out中。函数返回一个由字符标签和省份组成的pair。
+
     auto index = result + kCharsTotalNumber - kChineseNumber;
-    const char *key = kChars[index];
+    const char* key = kChars[index];
     std::string s = key;
     std::string province = kv_->get(s);
-    out = maxVal;
 
-    return std::make_pair(s, province);
+    /*std::cout << "result:" << result << std::endl;
+    std::cout << "maxVal:" << maxVal << std::endl;*/
+
+    character.setCharacterScore(maxVal);
+    character.setCharacterStr(province);
+    character.setIsChinese(isChinese);
   }
-  // 从输入的图像（可能是一个灰度图像）中识别出可能的中文字符。
-  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);
+}
+
+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;
-    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;
-      if (val > maxVal)
-      {
+
+    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
-    // 如果索引值为-1（即没有匹配的字符），
-    // 则将result设置为0，maxVal设置为0，并将isChinese设置为false，表示输入的字符不是中文
-    if (-1 == result)
-    {
+    if (-1 == result) {
       result = 0;
       maxVal = 0;
       isChinese = false;
     }
-    else if (maxVal > 0.9)
-    {
-      isChinese = true;
-    }
-    // 通过索引值获取字符的标签和省份，并将最大值保存到out中。函数返回一个由字符标签和省份组成的pair。
+
     auto index = result + kCharsTotalNumber - kChineseNumber;
-    const char *key = kChars[index];
+    const char* key = kChars[index];
     std::string s = key;
     std::string province = kv_->get(s);
-    out = maxVal;
-    return std::make_pair(s, province);
+
+    /*std::cout << "result:" << result << std::endl;
+    std::cout << "maxVal:" << maxVal << std::endl;*/
+
+    character.setCharacterScore(maxVal);
+    character.setCharacterStr(province);
+    character.setIsChinese(isChinese);
   }
+}
 
-  // 用于识别输入的图像数据是否是一个字符。
-  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]);
+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;
+      }
     }
-    else
-    {
-      const char *key = kChars[index];
+  }
+  //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);
-      return std::make_pair(s, province);
+      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);
 
-  // 用于处理一组输入的图像数据并识别出对应的字符和省份。
-  // 函数参数包括输入图像数据（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);
-      featureRows.push_back(feature);
+  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;
     }
+  }
 
-    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)
-      {
-        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);
-      }
+  // 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;
     }
-    return 0;
   }
+  // 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/src/core/plate_judge.cpp

@@ -6,47 +6,43 @@
 #include "easypr/core/params.h"
 
 namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类只有一个实例
-//定义了一个静态成员变量instance_，它是PlateJudge类的指针，初始化为nullptr。这是单例模式的关键，所有的PlateJudge实例都将共享这个变量
-  PlateJudge* PlateJudge::instance_ = nullptr;
 
+  PlateJudge* PlateJudge::instance_ = nullptr;
 
-//确保PlateJudge类只有一个实例，当需要使用PlateJudge类时，只需要调用PlateJudge::instance()即可获取到这个唯一的实例
-  PlateJudge* PlateJudge::instance() { //定义了一个静态成员函数instance()，它返回一个指向PlateJudge实例的指针
-    if (!instance_) { //检查instance_是否为nullptr
-      instance_ = new PlateJudge; //如果是，那么就创建一个新的PlateJudge实例，并将instance_设置为指向这个新创建的实例
+  PlateJudge* PlateJudge::instance() {
+    if (!instance_) {
+      instance_ = new PlateJudge;
     }
-    return instance_; //返回instance_，即指向PlateJudge实例的指针
+    return instance_;
   }
 
-  PlateJudge::PlateJudge() { //PlateJudge决定了使用哪种特征提取方法
-    bool useLBP = false; //定义一个布尔变量useLBP，并初始化为false
-    if (useLBP) { //如果useLBP为true，即使用LBP特征提取方法
-      LOAD_SVM_MODEL(svm_, kLBPSvmPath); //加载LBP的SVM模型
-      extractFeature = getLBPFeatures; //设置特征提取函数为getLBPFeatures
+  PlateJudge::PlateJudge() { //PlateJudge决定了使用哪种特征提取方法。
+    bool useLBP = false;
+    if (useLBP) {
+      LOAD_SVM_MODEL(svm_, kLBPSvmPath);
+      extractFeature = getLBPFeatures;
     }
-    else { //如果useLBP为false，即使用直方图特征提取方法
-      LOAD_SVM_MODEL(svm_, kHistSvmPath); //加载直方图的SVM模型
-      extractFeature = getHistomPlusColoFeatures; //设置特征提取函数为getHistomPlusColoFeatures
+    else {
+      LOAD_SVM_MODEL(svm_, kHistSvmPath);
+      extractFeature = getHistomPlusColoFeatures;
     }
   }
 
-  void PlateJudge::LoadModel(std::string path) { //LoadModel函数用于加载SVM模型，函数接收一个字符串参数path，这个参数是SVM模型文件的路径
-    if (path != std::string(kDefaultSvmPath)) { //检查输入的路径path是否与默认的SVM路径kDefaultSvmPath不同。如果不同，那么就需要加载新的SVM模型
-      if (!svm_->empty()) //检查当前的SVM模型是否为空。如果不为空，那么在加载新的SVM模型之前，需要先清空当前的SVM模型
-        svm_->clear(); //清空当前的SVM模型
-      LOAD_SVM_MODEL(svm_, path); //加载新的SVM模型。LOAD_SVM_MODEL是一个宏，它接收两个参数：一个是SVM模型的指针，另一个是SVM模型文件的路径
+  void PlateJudge::LoadModel(std::string path) { //LoadModel函数用于加载SVM模型。
+    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) { //plateSetScore函数用于设置车牌的评分，接收一个CPlate类型的引用作为参数
-    Mat features; //定义一个Mat类型的变量features，用于存储特征
-    extractFeature(plate.getPlateMat(), features); //调用extractFeature方法提取车牌图像的特征，结果存储在features中
-    float score = svm_->predict(features, noArray(), cv::ml::StatModel::Flags::RAW_OUTPUT); //使用SVM模型对特征进行预测，得到的结果存储在score中
+  int PlateJudge::plateSetScore(CPlate& plate) { //plateSetScore函数用于设置车牌的评分。
+    Mat features;
+    extractFeature(plate.getPlateMat(), features);
+    float score = svm_->predict(features, noArray(), cv::ml::StatModel::Flags::RAW_OUTPUT);
     //std::cout << "score:" << score << std::endl;
-
-//这是一个调试用的代码块，如果条件为真（此处为0，所以不会执行），则显示车牌图像，等待用户按键，然后销毁窗口
     if (0) {
       imshow("plate", plate.getPlateMat());
       waitKey(0);
@@ -55,15 +51,14 @@ namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类
     // 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; //如果评分小于0.5，返回0，表示这是一个车牌；否则返回-1，表示这不是一个车牌
+    if (score < 0.5) return 0;
     else return -1;      
   }
 
-//定义了一个名为plateJudge的成员函数，它属于PlateJudge类。该函数接收一个Mat类型的常量引用参数plateMat，这个参数是需要进行车牌判断的图像
   int PlateJudge::plateJudge(const Mat& plateMat) { //plateJudge函数用于判断输入的图像是否为车牌。
-    CPlate plate; //这行创建了一个CPlate类型的对象plate。CPlate是一个类，它可能包含车牌的相关信息，如车牌图像、车牌位置等
-    plate.setPlateMat(plateMat); //调用了CPlate类的setPlateMat成员函数，将输入的图像plateMat设置为plate对象的车牌图像
-    return plateSetScore(plate); //调用了PlateJudge类的plateSetScore成员函数，对plate对象进行评分，然后返回评分结果
+    CPlate plate;
+    plate.setPlateMat(plateMat);
+    return plateSetScore(plate);
   }
 
   int PlateJudge::plateJudge(const std::vector<Mat> &inVec, //inVec是输入的图像向量，resultVec是输出的结果向量。
@@ -112,25 +107,18 @@ namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类
     return 0; //结束循环并返回0，表示方法执行成功
   }
 
-  // non-maximum suppression -->非极大值抑制
-//函数接收三个参数：一个CPlate对象的向量inVec（输入的车牌向量），一个CPlate对象的向量resultVec（输出的车牌向量），以及一个double类型的overlap（重叠阈值）
+  // non-maximum suppression
   void NMS(std::vector<CPlate> &inVec, std::vector<CPlate> &resultVec, double overlap) { //NMS函数实现了非极大值抑制，用于消除重叠的车牌。
-    std::sort(inVec.begin(), inVec.end()); //首先对输入的车牌向量进行排序
-
-//然后遍历输入的车牌向量，对每一个车牌对象，获取其位置的边界矩形
+    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();
-
-//计算两个边界矩形的交并比（Intersection over Union，IoU），如果IoU大于设定的重叠阈值，那么就从输入的车牌向量中删除当前的车牌对象；否则，继续处理下一个车牌对象
         float iou = computeIOU(rectSrc, rectComp);
         if (iou > overlap) {
           itc = inVec.erase(itc);
@@ -140,23 +128,19 @@ namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类
         }
       }
     }
-    resultVec = inVec; //最后，将处理后的车牌向量赋值给输出的车牌向量
+    resultVec = inVec;
   }
 
-  // judge plate using nms --> 使用非极大值抑制进行车牌识别
-// 定义了一个名为plateJudgeUsingNMS的成员函数，它属于PlateJudge类。该函数使用非极大值抑制进行车牌识别，接收一个CPlate对象的向量inVec（输入的车牌向量）、一个CPlate对象的向量resultVec（输出的车牌向量）和一个整数maxPlates（最大车牌数量）作为参数
+  // judge plate using nms
   int PlateJudge::plateJudgeUsingNMS(const std::vector<CPlate> &inVec, std::vector<CPlate> &resultVec, int maxPlates) { //plateJudgeUsingNMS函数使用非极大值抑制进行车牌识别。
-    std::vector<CPlate> plateVec; // 创建一个CPlate对象的向量，用于存储识别出的车牌
-    int num = inVec.size(); // 获取输入向量的大小
-    bool useCascadeJudge = true; // 定义一个布尔变量，表示是否使用级联判断
+    std::vector<CPlate> plateVec;
+    int num = inVec.size();
+    bool useCascadeJudge = true;
 
-// 遍历输入向量中的每一个元素
     for (int j = 0; j < num; j++) {
-      CPlate plate = inVec[j]; // 获取当前的CPlate对象
-      Mat inMat = plate.getPlateMat();  // 获取当前CPlate对象的车牌图像
-      int result = plateSetScore(plate); // 对当前的CPlate对象进行评分
-
-// 如果评分结果为0，表示这是一个车牌
+      CPlate plate = inVec[j];
+      Mat inMat = plate.getPlateMat();
+      int result = plateSetScore(plate);
       if (0 == result) {
         if (0) {
           imshow("inMat", inMat);
@@ -164,22 +148,17 @@ namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类
           destroyWindow("inMat");
         }
 
-        if (plate.getPlateLocateType() == CMSER) { // 如果plate的定位类型为CMSER
-          int w = inMat.cols; // 获取图像的宽度
-          int h = inMat.rows; // 获取图像的高度
-	// 对图像进行裁剪
+        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); // 设置plate的车牌图像为调整后的图像
-
-	// 如果使用级联判断
+          Mat tmpDes = inMat.clone();
+          resize(tmpmat, tmpDes, Size(inMat.size()));
+          plate.setPlateMat(tmpDes);
           if (useCascadeJudge) {
-            int resultCascade = plateSetScore(plate); // 对调整后的图像进行评分
-	// 如果plate的定位类型不是CMSER，将plate的车牌图像设置为原图像
+            int resultCascade = plateSetScore(plate);
             if (plate.getPlateLocateType() != CMSER)
               plate.setPlateMat(inMat);
-	// 如果级联评分结果为0，将plate添加到plateVec中
             if (resultCascade == 0) {
               if (0) {
                 imshow("tmpDes", tmpDes);
@@ -189,24 +168,22 @@ namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类
               plateVec.push_back(plate);
             }
           }
-          else // 如果不使用级联判断，直接将plate添加到plateVec中
+          else 
             plateVec.push_back(plate);
         }
-        else // 如果plate的定位类型不是CMSER，直接将plate添加到plateVec中
+        else 
           plateVec.push_back(plate);                  
       }
     }
 
-    std::vector<CPlate> reDupPlateVec; // 创建一个CPlate对象的向量，用于存储非极大值抑制后的结果
-    double overlap = 0.5; // 定义重叠阈值
+    std::vector<CPlate> reDupPlateVec;
+    double overlap = 0.5;
     // double overlap = CParams::instance()->getParam1f();
     // use NMS to get the result plates
-// 使用非极大值抑制处理plateVec，结果存储在reDupPlateVec中
     NMS(plateVec, reDupPlateVec, overlap);
-    // sort the plates due to their scores --> 根据评分对reDupPlateVec进行排序
+    // sort the plates due to their scores
     std::sort(reDupPlateVec.begin(), reDupPlateVec.end());
     // output the plate judge plates
-// 遍历reDupPlateVec，将结果添加到resultVec中，直到达到最大车牌数量
     std::vector<CPlate>::iterator it = reDupPlateVec.begin();
     int count = 0;
     for (; it != reDupPlateVec.end(); ++it) {
@@ -220,6 +197,6 @@ namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类
       if (count >= maxPlates)
         break;
     }
-    return 0;  // 返回0，表示函数执行成功
+    return 0;
   }
 }

src/src/core/plate_locate.cpp

@@ -11,17 +11,14 @@ const float DEFAULT_ERROR = 0.9f;    // 0.6
 const float DEFAULT_ASPECT = 3.75f;  // 3.75
 
 CPlateLocate::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;
 
@@ -29,7 +26,6 @@ CPlateLocate::CPlateLocate() {
 }
 
 void CPlateLocate::setLifemode(bool param) {
-    //若参数param为真，设置成员变量为特定值，为假则设为初始值
   if (param) {
     setGaussianBlurSize(5);
     setMorphSizeWidth(10);
@@ -50,8 +46,6 @@ void CPlateLocate::setLifemode(bool param) {
 }
 
 bool CPlateLocate::verifySizes(RotatedRect mr) {
-    //验证图像中给定的车牌区域大小是否满足预设的大小限制
-    //主要是在宽度、高度、面积，满足返回true
   float error = m_error;
   // Spain car plate size: 52x11 aspect 4,7272
   // China car plate size: 440mm*140mm，aspect 3.142857
@@ -70,14 +64,12 @@ bool CPlateLocate::verifySizes(RotatedRect mr) {
   float rmax = aspect + aspect * error;
 
   float area = mr.size.height * mr.size.width;
-  //r为宽高比
   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
@@ -86,32 +78,29 @@ bool CPlateLocate::verifySizes(RotatedRect mr) {
 
 //! mser search method
 int CPlateLocate::mserSearch(const Mat &src,  vector<Mat> &out,
-  //在输入的图像src中搜索并找到车牌区域，
-  // 并将找到的蓝色和黄色的车牌信息及其旋转矩形框信息和匹配后的灰度图像返回。
   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);
-  //调用MSER算法的函数，输入源图像和各种参数，输出匹配后的灰度图像以及两种颜色的车牌信息和其旋转矩形框信息。
+
   out_plateVec.push_back(plateVec_blue);
   out_plateVec.push_back(plateVec_yellow);
-  //将找到的蓝色和黄色的车牌信息添加到out_plateVec向量中。
+
   out_plateRRect.push_back(plateRRect_blue);
   out_plateRRect.push_back(plateRRect_yellow);
-  //将找到的蓝色和黄色的车牌的旋转矩形框信息添加到out_plateRRect向量中。
+
   out = match_grey;
 
   return 0;
@@ -122,26 +111,21 @@ int CPlateLocate::colorSearch(const Mat &src, const Color r, Mat &out,
                               vector<RotatedRect> &outRects) {
   Mat match_grey;
 
-  //在输入的图像（src）中搜索特定颜色（r）的区域，
-  // 并返回找到的区域（RotatedRect）的列表
   // 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);
-  //将输入图像·src转换为灰度图像match_grey
   SHOW_IMAGE(match_grey, 0);
 
   Mat src_threshold;
   threshold(match_grey, src_threshold, 0, 255,
             CV_THRESH_OTSU + CV_THRESH_BINARY);
-  //使用阈值函数（threshold）对匹配后的图像进行处理，
-  // 将像素值从0到255进行二值化处理
+
   Mat element = getStructuringElement(
       MORPH_RECT, Size(color_morph_width, color_morph_height));
   morphologyEx(src_threshold, src_threshold, MORPH_CLOSE, element);
-  //morphologyEx进行形态学闭运算，
-  // 主要用于去除噪声以及填充空洞
+
   //if (m_debug) {
   //  utils::imwrite("resources/image/tmp/color.jpg", src_threshold);
   //}
@@ -155,20 +139,17 @@ int CPlateLocate::colorSearch(const Mat &src, const Color r, Mat &out,
                contours,               // a vector of contours
                CV_RETR_EXTERNAL,
                CV_CHAIN_APPROX_NONE);  // all pixels of each contours
-  //indContours函数会找到所有外部轮廓，即所有的区域都会被找到。
+
   vector<vector<Point>>::iterator itc = contours.begin();
   while (itc != contours.end()) {
     RotatedRect mr = minAreaRect(Mat(*itc));
-    //对找到的每个轮廓执行minAreaRect函数，得到该轮廓的最小外接矩形（mr）
-    
+
     if (!verifySizes(mr))
       itc = contours.erase(itc);
     else {
       ++itc;
       outRects.push_back(mr);
     }
-    //最后通过verifySizes函数检查得到的最小外接矩形是否满足预设的条件。
-    // 如果满足条件，则将该矩形添加到outRects列表中；如果不满足条件，则删除该轮廓
   }
 
   return 0;
@@ -177,15 +158,11 @@ int CPlateLocate::colorSearch(const Mat &src, const Color r, Mat &out,
 
 int CPlateLocate::sobelFrtSearch(const Mat &src,
                                  vector<Rect_<float>> &outRects) {
-    //主要功能是在输入的图像（src）中搜索边缘，
-    // 并返回找到的区域（RotatedRect）的列表。
   Mat src_threshold;
-  //对输入图像进行边缘检测后的结果。
+
   sobelOper(src, src_threshold, m_GaussianBlurSize, m_MorphSizeWidth,
             m_MorphSizeHeight);
-  //调用sobelOper函数，对输入图像src进行边缘检测，
-  // 并将结果存储在src_threshold中
-  //该函数还使用了高斯模糊和形态学操作来增强边缘检测的效果
+
   vector<vector<Point>> contours;
   findContours(src_threshold,
                contours,               // a vector of contours
@@ -193,22 +170,19 @@ int CPlateLocate::sobelFrtSearch(const Mat &src,
                CV_CHAIN_APPROX_NONE);  // all pixels of each contours
 
   vector<vector<Point>>::iterator itc = contours.begin();
-  //调用findContours函数找到边缘检测后的轮廓。
+
   vector<RotatedRect> first_rects;
 
   while (itc != contours.end()) {
     RotatedRect mr = minAreaRect(Mat(*itc));
-    //计算其最小外接矩形（minAreaRect函数）
+
 
     if (verifySizes(mr)) {
-        //检查这个矩形是否满足预设的条件（verifySizes函数）。
-        // 如果满足条件，将这个矩形加入到first_rects列表中
       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;
-       //计算其面积和宽高比（r）。如果r小于1，则重新计算宽高比。
     }
 
     ++itc;
@@ -216,14 +190,11 @@ int CPlateLocate::sobelFrtSearch(const Mat &src,
 
   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;
-    //对于每一个在first_rects中的矩形，
-    // 计算其在原图中的安全边界矩形
-    //如果计算失败，则跳过当前循环。
+
     outRects.push_back(safeBoundRect);
-    //将每个安全边界矩形加入到outRects列表中。
   }
   return 0;
 }
@@ -231,23 +202,20 @@ int CPlateLocate::sobelFrtSearch(const Mat &src,
 
 int CPlateLocate::sobelSecSearchPart(Mat &bound, Point2f refpoint,
                                      vector<RotatedRect> &outRects) {
-    //功能：在输入的图像（bound）中搜索边缘，并返回找到的区域（RotatedRect）的列表（outRects）
   Mat bound_threshold;
 
   sobelOperT(bound, bound_threshold, 3, 6, 2);
-  //使用sobelOperT函数进行边缘检测，其中3、6、2是sobel算子的大小。
+
   Mat tempBoundThread = bound_threshold.clone();
 
   clearLiuDingOnly(tempBoundThread);
 
   int posLeft = 0, posRight = 0;
   if (bFindLeftRightBound(tempBoundThread, posLeft, posRight)) {
-    //使用bFindLeftRightBound函数查找图像的左右边界，
+
     // find left and right bounds to repair
 
     if (posRight != 0 && posLeft != 0 && posLeft < posRight) {
-       // 如果左边界不为0且右边界不为0且左边界小于右边界，
-       // 则在图像中央位置的左右边界之间填充白色
       int posY = int(bound_threshold.rows * 0.5);
       for (int i = posLeft + (int) (bound_threshold.rows * 0.1);
            i < posRight - 4; i++) {
@@ -256,16 +224,13 @@ int CPlateLocate::sobelSecSearchPart(Mat &bound, Point2f refpoint,
     }
 
     utils::imwrite("resources/image/tmp/repaireimg1.jpg", bound_threshold);
-    //保存处理后的图像
+
     // remove the left and right boundaries
 
-    for (int i = 0; i < bound_threshold.rows; i++)
-    {
-        //每个行上，将左边界和右边界的像素设置为0。
+    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);
   }
 
@@ -274,28 +239,23 @@ int CPlateLocate::sobelSecSearchPart(Mat &bound, Point2f refpoint,
                contours,               // a vector of contours
                CV_RETR_EXTERNAL,
                CV_CHAIN_APPROX_NONE);  // all pixels of each contours
-  //调用findContours函数找到边缘检测后的轮廓。
+
   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);
-    //对于每个轮廓，计算其最小外接矩形（minAreaRect函数）
-    //并将结果添加到second_rects列表中。
     ++itc;
   }
 
   for (size_t i = 0; i < second_rects.size(); i++) {
     RotatedRect roi = second_rects[i];
-
     if (verifySizes(roi)) {
-    //对于second_rects中的每个矩形，
-    // 如果满足条件（verifySizes函数）则计算其中心、大小和角度
       Point2f refcenter = roi.center + refpoint;
       Size2f size = roi.size;
       float angle = roi.angle;
-      //创建一个新的RotatedRect对象，然后将其添加到outRects列表中。
+
       RotatedRect refroi(refcenter, size, angle);
       outRects.push_back(refroi);
     }
@@ -307,8 +267,6 @@ int CPlateLocate::sobelSecSearchPart(Mat &bound, Point2f refpoint,
 
 int CPlateLocate::sobelSecSearch(Mat &bound, Point2f refpoint,
                                  vector<RotatedRect> &outRects) {
-  //功能：在输入的图像（bound）中搜索边缘，并返回找到的区域（RotatedRect）的列表（outRects）
-  //函数内部的函数功能和sobelSecSearch函数差不多
   Mat bound_threshold;
 
 
@@ -349,24 +307,19 @@ int CPlateLocate::sobelSecSearch(Mat &bound, Point2f refpoint,
 
 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);
-  //对输入图像in进行高斯模糊处理，并将结果存储在mat_blur中
 
   Mat mat_gray;
   if (mat_blur.channels() == 3)
     cvtColor(mat_blur, mat_gray, CV_RGB2GRAY);
-    //如果是彩色图，则转换为灰度图像
-    //否则直接将mat_blur作为灰度图像。
   else
     mat_gray = mat_blur;
 
   int scale = SOBEL_SCALE;
   int delta = SOBEL_DELTA;
   int ddepth = SOBEL_DDEPTH;
-  //三个变量分别表示Sobel算子中的尺度、偏差和深度。
 
   Mat grad_x, grad_y;
   Mat abs_grad_x, abs_grad_y;
@@ -374,31 +327,30 @@ int CPlateLocate::sobelOper(const Mat &in, Mat &out, int blurSize, int morphW,
 
   Sobel(mat_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
   convertScaleAbs(grad_x, abs_grad_x);
-  //调用Sobel函数，对灰度图像进行Sobel算子运算，得到梯度图像grad_x。
+
   Mat grad;
   addWeighted(abs_grad_x, SOBEL_X_WEIGHT, 0, 0, 0, grad);
-  //将x方向的梯度图像和y方向的梯度图像加权叠加，得到最终的梯度图像grad。
+
   Mat mat_threshold;
   double otsu_thresh_val =
       threshold(grad, mat_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
-  //对梯度图像grad进行阈值处理，得到二值化图像mat_threshold
+
 
   Mat element = getStructuringElement(MORPH_RECT, Size(morphW, morphH));
   morphologyEx(mat_threshold, mat_threshold, MORPH_CLOSE, element);
-  //对二值化图像mat_threshold进行形态学闭运算，以填充孔洞和连接断开的边缘
+
   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;
@@ -408,42 +360,36 @@ void deleteNotArea(Mat &inmat, Color color = UNKNOWN) {
   else {
     plateType = color;
   }
-  //根据输入的颜色参数，确定要保留的颜色类型。
-  //如果输入颜色为未知（UNKNOWN），则通过getPlateType函数确定颜色类型。
+
   Mat img_threshold;
 
   if (BLUE == plateType) {
     img_threshold = input_grey.clone();
-    //若车牌是蓝色，克隆灰度图像input_grey到img_threshold
     Mat tmp = input_grey(Rect_<double>(w * 0.15, h * 0.15, w * 0.7, h * 0.7));
-     // 在input_grey中截取中心70%的部分进行阈值分割
     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);
-    // 应用计算出的最佳阈值进行二值化，即低于阈值的像素点变为0，高于阈值的变为255
+
     utils::imwrite("resources/image/tmp/inputgray2.jpg", img_threshold);
-    //保存二值化处理后的图像
-  } else if (YELLOW == plateType) {// 如果车牌类型是黄色
-    
+
+  } 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));
-    // 在input_grey中截取中心80%的部分进行阈值分割
     int threadHoldV = ThresholdOtsu(tmp);
-    // 使用Otsu方法计算最佳阈值
+
     threshold(input_grey, img_threshold, threadHoldV, 255,
               CV_THRESH_BINARY_INV);
-    // 应用计算出的最佳阈值进行反向二值化，即高于阈值的像素点变为0，低于阈值的变为255
+
     utils::imwrite("resources/image/tmp/inputgray2.jpg", img_threshold);
 
     // threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU +
     // CV_THRESH_BINARY_INV);
-  } else// 如果既不是蓝色也不是黄色的车牌
+  } else
     threshold(input_grey, img_threshold, 10, 255,
               CV_THRESH_OTSU + CV_THRESH_BINARY);
-    // 直接使用固定阈值10进行OTSU二值化处理
+
   //img_threshold = input_grey.clone();
   //spatial_ostu(img_threshold, 8, 2, plateType);
 
@@ -453,13 +399,13 @@ void deleteNotArea(Mat &inmat, Color color = UNKNOWN) {
   int top = 0;
   int bottom = img_threshold.rows - 1;
   clearLiuDing(img_threshold, top, bottom);
-  //清除图像中噪声
-  if (0) { //用于调试使用
+
+  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) {
@@ -468,7 +414,6 @@ void deleteNotArea(Mat &inmat, Color color = UNKNOWN) {
       destroyWindow("inmat");
     }
   }
- // 如果找到了图像的左右边界，则将图像裁剪为这个边界内的部分。
 }
 
 
@@ -477,21 +422,20 @@ int CPlateLocate::deskew(const Mat &src, const Mat &src_b,
                          vector<CPlate> &outPlates, bool useDeteleArea, Color color) {
   Mat mat_debug;
   src.copyTo(mat_debug);
-  //创建一个新的Mat对象，并将源图像复制到这个新对象。
 
-  for (size_t i = 0; i < inRects.size(); i++) { //遍历输入的旋转句型
+  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;//计算旋转矩形的宽高比和角度。
+    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);
     }
-    //如果宽高比小于1，说明矩形是竖直的，需要调整角度和宽高。
-    if (m_debug) {  //调试模式，绘制旋转矩形的边界
+
+    if (m_debug) {
       Point2f rect_points[4];
       roi_rect.points(rect_points);
       for (int j = 0; j < 4; j++)
@@ -504,14 +448,14 @@ int CPlateLocate::deskew(const Mat &src, const Mat &src_b,
     // rotation < m_angel;
 
     // m_angle=60
-    if (roi_angle - m_angle < 0 && roi_angle + m_angle > 0) { //旋转矩形的角度在合理范围时
+    if (roi_angle - m_angle < 0 && roi_angle + m_angle > 0) {
       Rect_<float> safeBoundRect;
-      bool isFormRect = calcSafeRect(roi_rect, src, 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);
@@ -524,16 +468,13 @@ int CPlateLocate::deskew(const Mat &src, const Mat &src_b,
       if ((roi_angle - 5 < 0 && roi_angle + 5 > 0) || 90.0 == roi_angle ||
           -90.0 == roi_angle) {
         deskew_mat = bound_mat;
-        //如果矩形角度接近0度或90度，直接使用截取的子图像，
-        
-      } else {//倾斜调整
+      } else {
         Mat rotated_mat;
         Mat rotated_mat_b;
 
         if (!rotation(bound_mat, rotated_mat, roi_rect_size, roi_ref_center, roi_angle))
           continue;
-        //对bound_mat应用旋转，旋转后存储在rotated_mat中，
-        //若旋转失败，继续下一次循环
+
         if (!rotation(bound_mat_b, rotated_mat_b, roi_rect_size, roi_ref_center, roi_angle))
           continue;
 
@@ -542,9 +483,7 @@ int CPlateLocate::deskew(const Mat &src, const Mat &src_b,
         // imshow("1roated_mat",rotated_mat);
         // imshow("rotated_mat_b",rotated_mat_b);
         if (isdeflection(rotated_mat_b, roi_angle, roi_slope)) {
-        // 检查rotated_mat_b是否需要倾斜调整
           affine(rotated_mat, deskew_mat, roi_slope);
-          //应用仿射变换
         } else
           deskew_mat = rotated_mat;
       }
@@ -555,23 +494,18 @@ int CPlateLocate::deskew(const Mat &src, const Mat &src_b,
       // 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) {
-        //检查经过校正的图像（deskew_mat）的长宽比是否在某个范围内
         if (deskew_mat.cols >= WIDTH || deskew_mat.rows >= HEIGHT)
-        // 如果校正后的图像的宽（cols）或高（rows）超出预设的阈值（WIDTH或HEIGHT）
-
           resize(deskew_mat, plate_mat, plate_mat.size(), 0, 0, INTER_AREA);
-        // 使用INTER_AREA（区域插值）方法缩小图像，保持plate_mat.size()大小
         else
           resize(deskew_mat, plate_mat, plate_mat.size(), 0, 0, INTER_CUBIC);
-          // 如果宽或高没有超出阈值，则使用INTER_CUBIC（三次插值）方法放大图像，保持plate_mat.size()大小
-        CPlate plate; //存储车牌信息
+
+        CPlate plate;
         plate.setPlatePos(roi_rect);
         plate.setPlateMat(plate_mat);
-        if (color != UNKNOWN) plate.setPlateColor(color); // 如果车牌颜色已知，则设置车牌颜色
-        outPlates.push_back(plate); //将包含车牌信息的对象输出
+        if (color != UNKNOWN) plate.setPlateColor(color);
+        outPlates.push_back(plate);
       }
     }
   }
@@ -581,7 +515,7 @@ int CPlateLocate::deskew(const Mat &src, const Mat &src_b,
 
 bool CPlateLocate::rotation(Mat &in, Mat &out, const Size rect_size,
                             const Point2f center, const double angle) {
-  if (0) {//通过打印imshow信息调试
+  if (0) {
     imshow("in", in);
     waitKey(0);
     destroyWindow("in");
@@ -589,33 +523,33 @@ bool CPlateLocate::rotation(Mat &in, Mat &out, const Size rect_size,
 
   Mat in_large;
   in_large.create(int(in.rows * 1.5), int(in.cols * 1.5), in.type());
-  //创建一个1.5倍in图像的行数、1.5倍in图像的列数且同类的图像
+
   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;
-  //计算原始图像 in 在放大图像 in_large 中的位置，确保其居中且不超出 in_large 的边界。
+
   /*assert(width == in.cols);
   assert(height == in.rows);*/
 
   if (width != in.cols || height != in.rows) return false;
-  //如果计算得到的宽度和高度与原图 in 不匹配，函数返回 false。
-  Mat imageRoi = in_large(Rect_<float>(x, y, width, height));//合并原图并放大
+
+  Mat imageRoi = in_large(Rect_<float>(x, y, width, height));
   addWeighted(imageRoi, 0, in, 1, 0, imageRoi);
-  //选择 in_large 中的一个区域 imageRoi，将原图 in 覆盖到这个区域上。
+
   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);
-    //使用 OpenCV 函数 getRotationMatrix2D 生成旋转矩阵 rot_mat。
+
   /*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);
-  //使用 warpAffine 函数将旋转矩阵应用于放大后的图像 in_large，结果存储在 mat_rotated 中
+
   /*imshow("mat_rotated", mat_rotated);
   waitKey(0);*/
 
@@ -624,9 +558,8 @@ bool CPlateLocate::rotation(Mat &in, Mat &out, const Size rect_size,
                 new_center, img_crop);
 
   out = img_crop;
-  //使用 getRectSubPix 函数根据指定的尺寸和中心点从旋转后的图像中裁剪出区域，
-  //结果存储在 img_crop 中，然后赋值给输出参数 out。
-  if (0) {  //调试代码
+
+  if (0) {
     imshow("out", out);
     waitKey(0);
     destroyWindow("out");
@@ -641,9 +574,7 @@ bool CPlateLocate::rotation(Mat &in, Mat &out, const Size rect_size,
 bool CPlateLocate::isdeflection(const Mat &in, const double angle,
                                 double &slope) { /*imshow("in",in);
                                                 waitKey(0);*/
-
-  //用于检测输入图像 in 是否有偏转，并计算斜率 slope                   
-  if (0) { //用于调试
+  if (0) {
     imshow("in", in);
     waitKey(0);
     destroyWindow("in");
@@ -653,16 +584,16 @@ bool CPlateLocate::isdeflection(const Mat &in, const double angle,
   int nCols = in.cols;
 
   assert(in.channels() == 1);
-  //获取图像的行数 nRows 和列数 nCols，并确认图像是单通道（灰度图）。
+
   int comp_index[3];
   int len[3];
-  // 分别计算1/4、1/2、3/4高度处的行索引
+
   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);
@@ -672,7 +603,6 @@ bool CPlateLocate::isdeflection(const Mat &in, const double angle,
     while (0 == value && j < nCols) value = int(p[j++]);
 
     len[i] = j;
-    
   }
 
   // cout << "len[0]:" << len[0] << endl;
@@ -688,15 +618,19 @@ bool CPlateLocate::isdeflection(const Mat &in, const double angle,
   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;
@@ -706,23 +640,21 @@ bool CPlateLocate::isdeflection(const Mat &in, const double angle,
   }
 
   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) {
-      //如果斜率 slope > 0，变换将图像向右倾斜。
 
     // right, new position is xiff/2
 
@@ -734,7 +666,7 @@ void CPlateLocate::affine(const Mat &in, Mat &out, const double slope) {
     dstTri[1] = Point2f(width - 1 - xiff / 2, 0);
     dstTri[2] = Point2f(xiff / 2, height - 1);
   } else {
-    //如果斜率 slope < 0，变换将图像向左倾斜。
+
     // left, new position is -xiff/2
 
     plTri[0] = Point2f(0 + xiff, 0);
@@ -747,18 +679,15 @@ void CPlateLocate::affine(const Mat &in, Mat &out, const double slope) {
   }
 
   Mat warp_mat = getAffineTransform(plTri, dstTri);
-  //使用 OpenCV 的 getAffineTransform 函数，根据源点和目标点计算仿射变换矩阵 warp_mat。
+
   Mat affine_mat;
   affine_mat.create((int) height, (int) width, TYPE);
 
-  if (in.rows > HEIGHT || in.cols > WIDTH)//根据输入图像的大小，选择不同的插值方法：
-
+  if (in.rows > HEIGHT || in.cols > WIDTH)
 
-  //如果图像的大小超过预设的 HEIGHT 或 WIDTH，使用 CV_INTER_AREA 插值，这个通常用于缩小。
     warpAffine(in, affine_mat, warp_mat, affine_mat.size(),
                CV_INTER_AREA);
   else
-  //否则使用 CV_INTER_CUBIC 插值，这个插值方法在放大时可以提供平滑的边界。
     warpAffine(in, affine_mat, warp_mat, affine_mat.size(), CV_INTER_CUBIC);
 
   out = affine_mat;
@@ -766,24 +695,22 @@ void CPlateLocate::affine(const Mat &in, Mat &out, const double slope) {
 
 int CPlateLocate::plateColorLocate(Mat src, vector<CPlate> &candPlates,
                                    int index) {
-  //初始化两个 RotatedRect 类型的向量 rects_color_blue 和 rects_color_yellow，以及两个 CPlate 类型的向量 plates_blue 和 plates_yellow
   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();
-  //使用 OpenMP 并行处理，分别对蓝色和黄色车牌进行搜索和倾斜矫正。
-  //这是通过调用 colorSearch 和 deskew 函数完成的。
+
   Mat src_b_blue;
   Mat src_b_yellow;
 #pragma omp parallel sections
-  { 
+  {
 #pragma omp section
     {
       colorSearch(src, BLUE, src_b_blue, rects_color_blue);
@@ -795,7 +722,6 @@ int CPlateLocate::plateColorLocate(Mat src, vector<CPlate> &candPlates,
       deskew(src_clone, src_b_yellow, rects_color_yellow, plates_yellow, true, YELLOW);
     }
   }
-  //将找到的蓝色和黄色车牌信息添加到 candPlates 向量中。
 
   candPlates.insert(candPlates.end(), plates_blue.begin(), plates_blue.end());
   candPlates.insert(candPlates.end(), plates_yellow.begin(), plates_yellow.end());
@@ -891,13 +817,10 @@ int CPlateLocate::plateMserLocate(Mat src, vector<CPlate> &candPlates, int img_i
 
 int CPlateLocate::sobelOperT(const Mat &in, Mat &out, int blurSize, int morphW,
                              int morphH) {
-  //在输入图像（src）中使用 MSER（最大稳定极值区域）方法定位车牌
   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);
@@ -911,25 +834,24 @@ int CPlateLocate::sobelOperT(const Mat &in, Mat &out, int blurSize, int morphW,
   int scale = SOBEL_SCALE;
   int delta = SOBEL_DELTA;
   int ddepth = SOBEL_DDEPTH;
-  //对灰度图像应用 Sobel 操作，得到 x 和 y 方向的梯度。
+
   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);
-  //将 x 方向的梯度转换为绝对值，然后与 y 方向的梯度合并（假设 y 方向的梯度为0）。
+
   Mat grad;
   addWeighted(abs_grad_x, 1, 0, 0, 0, grad);
 
   utils::imwrite("resources/image/tmp/graygrad.jpg", grad);
 
-  //使用 Otsu 的阈值法对得到的梯度图像进行二值化
   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);
 
@@ -943,7 +865,6 @@ int CPlateLocate::sobelOperT(const Mat &in, Mat &out, int blurSize, int morphW,
 int CPlateLocate::plateSobelLocate(Mat src, vector<CPlate> &candPlates,
                                    int index) {
   vector<RotatedRect> rects_sobel_all;
-  //引用传递的 CPlate 类的矢量，用于存储最后识别为候选车牌的结果。
   rects_sobel_all.reserve(256);
 
   vector<CPlate> plates;
@@ -953,13 +874,11 @@ int CPlateLocate::plateSobelLocate(Mat src, vector<CPlate> &candPlates,
   bound_rects.reserve(256);
 
   sobelFrtSearch(src, bound_rects);
-  //使用 Sobel 算子处理输入的图像 src 并返回可能的边界矩形 bound_rects。
+
   vector<Rect_<float>> bound_rects_part;
   bound_rects_part.reserve(256);
 
   // enlarge area 
-  //通过扩大每个边界矩形的面积进行进一步处理，这通常是为了使候选区域更大，
-  //以包含整个车牌。代码通过改变矩形的 x 坐标，宽度，和 y 坐标，高度来实现此目的。
   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) {
@@ -982,8 +901,6 @@ int CPlateLocate::plateSobelLocate(Mat src, vector<CPlate> &candPlates,
   }
 
   // second processing to split one
-  //使用 OpenMP 并行处理进行第二次搜索。pragma omp parallel for 使循环并行执行，
-  //以加快处理速度。在每次循环中，对于每个边界矩形：
 #pragma omp parallel for
   for (int i = 0; i < (int)bound_rects_part.size(); i++) {
     Rect_<float> bound_rect = bound_rects_part[i];
@@ -999,13 +916,12 @@ int CPlateLocate::plateSobelLocate(Mat src, vector<CPlate> &candPlates,
 
     Rect_<float> safe_bound_rect(x, y, width, height);
     Mat bound_mat = src(safe_bound_rect);
-  //调用 sobelSecSearchPart 函数，它可能进一步处理提取的子图并返回可能的车牌候选区域 rects_sobel                      
+
     vector<RotatedRect> rects_sobel;
     rects_sobel.reserve(128);
     sobelSecSearchPart(bound_mat, refpoint, rects_sobel);
 
 #pragma omp critical
-//确保当多个线程尝试将其搜索结果添加到 rects_sobel_all 集合时，不会发生冲突。
     {
       rects_sobel_all.insert(rects_sobel_all.end(), rects_sobel.begin(), rects_sobel.end());
     }
@@ -1038,15 +954,13 @@ int CPlateLocate::plateSobelLocate(Mat src, vector<CPlate> &candPlates,
   }
 
   Mat src_b;
-  //调用 sobelOper 函数来执行 Sobel 操作。
   sobelOper(src, src_b, 3, 10, 3);
-  //每个可能的矩形区域都发送给 deskew 函数，这个函数可能旨在纠正候选车牌的偏斜。
 
   deskew(src, src_b, rects_sobel_all, plates);
 
   //for (size_t i = 0; i < plates.size(); i++) 
   //  candPlates.push_back(plates[i]);
-  //得到的车牌从 plates 转移至 candPlates
+
   candPlates.insert(candPlates.end(), plates.begin(), plates.end());
 
   return 0;
@@ -1054,15 +968,12 @@ int CPlateLocate::plateSobelLocate(Mat src, vector<CPlate> &candPlates,
 
 
 int CPlateLocate::plateLocate(Mat src, vector<Mat> &resultVec, int index) {
-  //对输入图像src执行车牌定位，并将定位到的车牌图像放入resultVec中
   vector<CPlate> all_result_Plates;
-  //三个函数分别使用颜色定位、Sobel边缘检测和MSER算法来识别车牌
+
   plateColorLocate(src, all_result_Plates, index);
   plateSobelLocate(src, all_result_Plates, index);
   plateMserLocate(src, all_result_Plates, index);
 
-  //循环通过all_result_Plates，对于每个CPlate对象，
-  //调用getPlateMat()获取车牌对应的图像，并将其添加到resultVec向量中。
   for (size_t i = 0; i < all_result_Plates.size(); i++) {
     CPlate plate = all_result_Plates[i];
     resultVec.push_back(plate.getPlateMat());
@@ -1072,14 +983,12 @@ int CPlateLocate::plateLocate(Mat src, vector<Mat> &resultVec, int index) {
 }
 
 int CPlateLocate::plateLocate(Mat src, vector<CPlate> &resultVec, int index) {
-  //对输入图像src执行车牌定位，将定位到的车牌对象(CPlate)放入resultVec中
   vector<CPlate> all_result_Plates;
 
   plateColorLocate(src, all_result_Plates, index);
   plateSobelLocate(src, all_result_Plates, index);
   plateMserLocate(src, all_result_Plates, index);
-  
-  //循环通过all_result_Plates，将每一个CPlate对象直接添加到resultVec向量中。
+
   for (size_t i = 0; i < all_result_Plates.size(); i++) {
     resultVec.push_back(all_result_Plates[i]);
   }

src/src/train/annCh_train.cpp

@@ -1,257 +1,187 @@
-#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，可能是为了增加一些额外的输入节点  
+#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;
 }
 
-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; // 设置输出层节点数量  
+  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);
 }
 
-// 设置神经网络层的大小  
-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);  
-  }  
+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);
 }
-// 生成合成图像  
-// 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);  
-    }  
-  }  
+
+  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);

src/src/train/svm_train.cpp

@@ -18,7 +18,9 @@ SvmTrain::SvmTrain(const char* plates_folder, const char* xml)
 
   extractFeature = getHistomPlusColoFeatures;
 }
-
+// 这段代码是SvmTrain类的构造函数，接受两个const char*类型的参数plates_folder和xml。
+// 在构造函数中，使用了assert函数来确保plates_folder和xml不为空。
+// 同时，将extractFeature设置为getHistomPlusColoFeatures函数。
 void SvmTrain::train() {
   svm_ = cv::ml::SVM::create();
   svm_->setType(cv::ml::SVM::C_SVC);
@@ -31,7 +33,10 @@ void SvmTrain::train() {
   svm_->setNu(0.1);
   svm_->setP(0.1);
   svm_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 20000, 0.0001));
-
+// 这段代码是SvmTrain类的train方法，用于训练支持向量机模型。
+// 在方法中，创建了一个SVM对象，并设置了其类型、核函数类型、参数等。
+// 最后调用了trainAuto方法进行模型训练，并保存了训练好的模型。
+// 该方法还包括了一些打印输出和测试方法的调用。
   this->prepare();
 
   if (train_file_list_.size() == 0) {
@@ -41,7 +46,9 @@ void SvmTrain::train() {
     return;
   }
   auto train_data = tdata();
-
+// 这段代码是在svm_train.cpp文件中的train方法中的一部分。
+// 首先调用了prepare方法，然后检查train_file_list_的大小是否为0，如果是则输出提示信息并返回。
+// 最后调用了tdata方法并将返回值赋给train_data。
   fprintf(stdout, ">> Training SVM model, please wait...\n");
   long start = utils::getTimestamp();
   svm_->trainAuto(train_data, 10, SVM::getDefaultGrid(SVM::C),
@@ -49,7 +56,10 @@ void SvmTrain::train() {
                   SVM::getDefaultGrid(SVM::NU), SVM::getDefaultGrid(SVM::COEF),
                   SVM::getDefaultGrid(SVM::DEGREE), true);
   //svm_->train(train_data);
-
+// 这段代码是在svm_train.cpp文件中的train方法中的一部分。
+// 首先输出训练提示信息，然后获取当前时间戳作为训练开始时间。
+// 接着调用svm_->trainAuto方法进行支持向量机模型的自动训练，使用了默认的参数网格和并行化。
+// 最后注释掉了旧的svm_->train方法的调用。
   long end = utils::getTimestamp();
   fprintf(stdout, ">> Training done. Time elapse: %ldms\n", end - start);
   fprintf(stdout, ">> Saving model file...\n");
@@ -61,7 +71,11 @@ void SvmTrain::train() {
   this->test();
   
 }
-
+// 这段代码是SvmTrain类中的test方法，用于测试支持向量机模型。
+// 首先通过utils::getTimestamp()获取当前时间戳作为测试结束时间，并计算训练时间。
+// 然后输出训练完成的提示信息，并保存训练好的模型到指定的xml文件中。
+// 接着输出模型保存的路径，并提示进行测试。
+// 最后调用了SvmTrain类中的test方法进行模型测试。
 void SvmTrain::test() {
   // 1.4 bug fix: old 1.4 ver there is no null judge
   // if (NULL == svm_)
@@ -70,13 +84,16 @@ void SvmTrain::test() {
   if (test_file_list_.empty()) {
     this->prepare();
   }
- 
+ // 这段代码是SvmTrain类中的test方法。
+// 首先通过LOAD_SVM_MODEL宏加载了svm模型。
+// 然后检查test_file_list_是否为空，如果为空则调用prepare方法。
   double count_all = test_file_list_.size();
   double ptrue_rtrue = 0;
   double ptrue_rfalse = 0;
   double pfalse_rtrue = 0;
   double pfalse_rfalse = 0;
-
+// 这段代码用于初始化四个double类型的变量，分别表示总数、真正例、假反例和假正例。
+// 这些变量将在后续的循环中用于统计支持向量机模型的预测结果。
   for (auto item : test_file_list_) {
     auto image = cv::imread(item.file);
     if (!image.data) {
@@ -85,7 +102,10 @@ void SvmTrain::test() {
     }
     cv::Mat feature;
     extractFeature(image, feature);
-
+// 这段代码是在SvmTrain类中的test方法中的循环部分。
+// 首先遍历test_file_list_中的每个item，然后使用OpenCV的imread函数读取图像文件。
+// 如果图像数据为空，则输出"no"并继续下一次循环。
+// 否则创建一个cv::Mat类型的feature变量，并调用extractFeature函数提取图像特征。
     auto predict = int(svm_->predict(feature));
     //std::cout << "predict: " << predict << std::endl;
 
@@ -95,13 +115,17 @@ void SvmTrain::test() {
     if (predict == kInverse && real == kForward) pfalse_rtrue++;
     if (predict == kInverse && real == kInverse) pfalse_rfalse++;
   }
-
+// 这段代码用于对图像特征进行预测，并统计预测结果的真正例、假反例、假正例和真反例的数量。
+// 首先使用svm_->predict函数对特征进行预测，然后根据预测结果和真实标签进行统计。
+// 最后根据统计结果计算精确率（precise）、召回率（recall）和F分数（Fsocre）。
   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;
-
+// 评注该代码
+// 这段代码用于输出count_all、ptrue_rtrue、ptrue_rfalse、pfalse_rtrue和pfalse_rfalse的值
+// 这些值分别表示总数、真正例、假反例、假正例和真反例的数量
   double precise = 0;
   if (ptrue_rtrue + ptrue_rfalse != 0) {
     precise = ptrue_rtrue / (ptrue_rtrue + ptrue_rfalse);
@@ -110,7 +134,8 @@ void SvmTrain::test() {
     std::cout << "precise: "
               << "NA" << std::endl;
   }
-
+// 这段代码用于计算精确率（precision），如果ptrue_rtrue和ptrue_rfalse之和不为0，
+// 则计算精确率并输出，否则输出"NA"
   double recall = 0;
   if (ptrue_rtrue + pfalse_rtrue != 0) {
     recall = ptrue_rtrue / (ptrue_rtrue + pfalse_rtrue);
@@ -119,7 +144,8 @@ void SvmTrain::test() {
     std::cout << "recall: "
               << "NA" << std::endl;
   }
-
+// 这段代码计算并输出召回率（recall），召回率表示被正确预测为正例的样本数占所有实际正例样本数的比例。
+// 如果ptrue_rtrue和pfalse_rtrue之和不为0，则计算召回率并输出，否则输出"NA"。
   double Fsocre = 0;
   if (precise + recall != 0) {
     Fsocre = 2 * (precise * recall) / (precise + recall);
@@ -129,7 +155,9 @@ void SvmTrain::test() {
               << "NA" << std::endl;
   }
 }
-
+// 评注该代码
+// 这段代码用于计算并输出F分数（Fsocre），F分数是精确率（precision）和召回率（recall）的调和平均数。
+// 首先判断精确率和召回率之和是否为0，如果不为0，则计算F分数并输出，否则输出"NA"。
 void SvmTrain::prepare() {
   srand(unsigned(time(NULL)));
 
@@ -150,7 +178,10 @@ void SvmTrain::prepare() {
   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());
-
+// 该代码是SvmTrain类中的prepare方法，用于准备训练和测试数据集。
+// 首先使用srand和time函数生成随机种子。
+// 然后通过sprintf和utils::getFiles函数获取训练和测试数据集的文件列表，并对列表进行随机打乱。
+// 最后将获取到的文件列表分别存储到has_file_train_list、has_file_test_list、no_file_train_list和no_file_test_list中。
   fprintf(stdout, ">> Collecting train data...\n");
 
   for (auto file : has_file_train_list)
@@ -167,11 +198,19 @@ void SvmTrain::prepare() {
   for (auto file : no_file_test_list)
     test_file_list_.push_back({ file, kInverse });
 }
-
+// 该部分代码用于收集训练数据和测试数据。
+// 首先输出提示信息"Collecting train data..."，然后遍历has_file_train_list和no_file_train_list，
+// 将文件路径和标签分别添加到train_file_list_中。
+// 然后输出提示信息"Collecting test data..."，并遍历has_file_test_list和no_file_test_list，
+// 将文件路径和标签分别添加到test_file_list_中。
 cv::Ptr<cv::ml::TrainData> SvmTrain::tdata() {
   cv::Mat samples;
   std::vector<int> responses;
-
+// 这段代码是SvmTrain类中的tdata方法，用于准备支持向量机训练数据。
+// 首先定义了一个cv::Mat类型的samples和一个std::vector<int>类型的responses。
+// 然后遍历train_file_list_中的每个文件，使用OpenCV的imread函数读取图像文件，提取图像特征，并将特征转换为一行的形式。
+// 将特征和标签分别添加到samples和responses中。
+// 最后将samples和responses转换为CV_32FC1类型的samples_和responses_，并使用cv::ml::TrainData::create创建训练数据对象并返回。
   for (auto f : train_file_list_) {
     auto image = cv::imread(f.file);
     if (!image.data) {
@@ -185,7 +224,11 @@ cv::Ptr<cv::ml::TrainData> SvmTrain::tdata() {
     samples.push_back(feature);
     responses.push_back(int(f.label));
   }
-
+// 这段代码是在SvmTrain类中的tdata方法中的循环部分。
+// 首先遍历train_file_list_中的每个文件，使用OpenCV的imread函数读取图像文件。
+// 如果图像数据为空，则输出"Invalid image: 文件路径 ignore."并继续下一次循环。
+// 否则创建一个cv::Mat类型的feature变量，并调用extractFeature函数提取图像特征。
+// 将特征转换为一行的形式，然后将特征和标签分别添加到samples和responses中。
   cv::Mat samples_, responses_;
   samples.convertTo(samples_, CV_32FC1);
   cv::Mat(responses).copyTo(responses_);
@@ -194,3 +237,6 @@ cv::Ptr<cv::ml::TrainData> SvmTrain::tdata() {
 }
 
 }  // namespace easypr
+// 这段代码是在SvmTrain类中的tdata方法中的最后部分。
+// 首先将samples转换为CV_32FC1类型的samples_，然后将responses复制到responses_中。
+// 最后使用cv::ml::TrainData::create创建并返回训练数据对象。

src/src/train/train.cpp

@@ -6,3 +6,4 @@ ITrain::ITrain() {}
 
 ITrain::~ITrain() {}
 }
+//这段代码是一个C++文件，定义了一个名为ITrain的类，包含了一个默认构造函数和一个析构函数。这些函数都位于easypr命名空间中。

src/src/util/kv.cpp

@@ -1,81 +1,81 @@
-#include "easypr/util/kv.h"  // 引入kv头文件
-#include "easypr/util/util.h"  // 引入util头文件
+#include "easypr/util/kv.h"
+#include "easypr/util/util.h"
 
-namespace easypr {  // 定义easypr命名空间
+namespace easypr {
 
-Kv::Kv() { }  // Kv类构造函数
+Kv::Kv() { }
 
-void Kv::load(const std::string &file) {  // 加载文件
-  this->clear();  // 清空数据
-  std::ifstream reader(file);  // 创建文件读取流
-  assert(reader);  // 断言文件读取流创建成功
+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;  // 定义字符串变量line
-      std::getline(reader, line);  // 读取一行数据到line
-      if (line.empty()) continue;  // 如果line为空，则跳过本次循环
+  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();  // 清空临时变量
+      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);  // 将当前字符添加到临时变量
+            tmp.push_back(ch);
           }
-          if (i == len - 1) {  // 如果当前字符是最后一个字符
-            value = tmp;  // 将临时变量赋值给值
+          if (i == len - 1) {
+            value = tmp;
           }
         }
-        return std::make_pair(key, value);  // 返回键值对
+        return std::make_pair(key, value);
       };
 
-      auto kv = parse(line);  // 解析行数据
-      this->add(kv.first, kv.second);  // 添加键值对
+      auto kv = parse(line);
+      this->add(kv.first, kv.second);
     }
-    reader.close();  // 关闭文件读取流
+    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 "";  // 返回空字符串
+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);  // 返回键对应的值
+  return data_.at(key);
 }
 
-void Kv::add(const std::string &key, const std::string &value) {  // 添加键值对
-  if (data_.find(key) != data_.end()) {  // 如果键已存在
+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());  // 输出错误信息
+            value.c_str());
   } else {
     std::string v(value);
 #ifdef OS_WINDOWS
-    v = utils::utf8_to_gbk(value.c_str());());  // 如果是Windows系统，将值转换为gbk编码
+    v = utils::utf8_to_gbk(value.c_str());
 #endif
-    data_[key] = v;  // 添加键值对
+    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;  // 返回
+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);  // 删除键值对
+  data_.erase(key);
 }
 
-void Kv::clear() {  // 清空数据
-  data_.clear();  // 清空数据
+void Kv::clear() {
+  data_.clear();
 }
 
 }

src/src/util/program_options.cpp

@@ -3,429 +3,423 @@
 namespace program_options {
 
 // class ParseError
-//定义了一个名为ParseError的类
-//ParseError类是一个用于处理命令行解析错误的异常类。
-ParseError::ParseError(const std::string& msg) : _msg(msg) {}//是ParseError类的构造函数
-//它接受一个字符串作为参数，并将这个字符串赋值给成员变量_msg。
-const char* ParseError::what() const throw() {//是一个成员函数，它返回一个描述错误的字符串
-  std::string msg;//首先创建一个新的字符串
-  msg.append("Command line parse error: ").append(_msg).push_back('.');//添加一个错误消息前缀，接着添加成员变量_msg，最后添加一个句点。
-  return msg.c_str();//返回这个字符串的C风格字符串。
+
+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() {}// 是ParseError类的析构函数
+ParseError::~ParseError() throw() {}
 
 // class Generator
-//定义了一个名为Generator的类，该类用于生成和管理命令行选项解析器和子程序。
-Generator::Generator() : parser_(nullptr) {//Generator类的构造函数
-  current_subroutine_ = Subroutine::get_default_name();//初始化parser_为nullptr，设置当前子程序为默认子程序
-  add_subroutine(current_subroutine_.c_str());//添加这个子程序。
+
+Generator::Generator() : parser_(nullptr) {
+  current_subroutine_ = Subroutine::get_default_name();
+  add_subroutine(current_subroutine_.c_str());
 }
 
-Generator::~Generator() {//Generator类的析构函数
+Generator::~Generator() {
   if (parser_) {
     delete parser_;
     parser_ = nullptr;
-  }//它删除parser_和所有的子程序
+  }
   for (auto it = subroutines_.begin(); it != subroutines_.end(); ++it) {
     if (it->second) {
-      delete it->second;//它删除所有的子程序，
-      it->second = nullptr;//并将parser_和所有的子程序设置为nullptr。
+      delete it->second;
+      it->second = nullptr;
     }
   }
 }
 
-Generator& Generator::make_usage(const char* first_line) {//是一个成员函数
-  get_subroutine()->set_first_line(first_line);//它设置当前子程序的第一行
-  return *this;//并返回this指针。
+Generator& Generator::make_usage(const char* first_line) {
+  get_subroutine()->set_first_line(first_line);
+  return *this;
 }
 
-Parser* Generator::make_parser() {//是一个成员函数
+Parser* Generator::make_parser() {
   if (parser_) delete parser_;
-  parser_ = new Parser;//它创建一个新的Parser对象
-  parser_->set_usage_subroutines(&subroutines_);//设置其使用的子程序
-  return parser_;//并返回这个Parser对象。
+  parser_ = new Parser;
+  parser_->set_usage_subroutines(&subroutines_);
+  return parser_;
 }
 
-Generator& Generator::add_subroutine(const char* name) {//是成员函数
-  add_subroutine(name, "");//它们添加一个新的子程序。
+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()) {//如果子程序已经存在，它们不会添加。
+                                     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});//添加一个新的子程序。
+    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> 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();//将子程序的名称和描述添加到映射中。
+  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);//返回一个包含所有子程序名称和描述的映射
+  return std::move(kv);
 }
 
 bool Generator::add_usage_line(const char* option, const char* default_value,
-                               const char* description) {// 是一个成员函数，它添加一个使用行到当前子程序。
+                               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对象，
+    Row row;
     row.oshort(option_short);
     row.olong(option_long);
     row.value(default_value);
     row.desc(description);
-////设置其短选项、长选项、默认值和描述
-    get_subroutine()->add_usage_line(row);//将这个Row对象添加到当前子程序的使用行中。
+
+    get_subroutine()->add_usage_line(row);
     return true;
   }
   return false;
 }
 
-std::ostream& operator<<(std::ostream& out, Generator& generator) {// 是一个输出运算符重载函数，它打印所有子程序的名称和描述。
-  for (auto pr : generator.subroutines_) {//遍历所有的子程序
+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;//打印子程序的使用信息。
+    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) {}//ParseItem 类的构造函数
-//它接受一个 std::string 类型的参数 value。在构造函数体中，将传入的 value 直接赋值给类的成员变量 value_。
-//这个构造函数用于创建一个 ParseItem 对象，并初始化其 value_ 成员变量。
+ParseItem::ParseItem(const std::string& value) : value_(value) {}
 
 // class Parser
 
-ParseItem* Parser::get(const std::string& key) {//Parser 类的 get 方法，它接受一个 std::string 类型的参数 key。
-  if (pr_->find(key) != pr_->end()) {//如果 key 在 pr_ 中存在
-    return (*pr_)[key];//那么返回对应的 ParseItem 指针
+ParseItem* Parser::get(const std::string& key) {
+  if (pr_->find(key) != pr_->end()) {
+    return (*pr_)[key];
   }
-  return nullptr;//返回 nullptr
+  return nullptr;
 }
 
-Parser::Parser() : subroutines_(nullptr), pr_(nullptr) {}//
-//Parser 类的构造函数，它使用初始化列表将 subroutines_ 和 pr_ 成员变量初始化为 nullptr。
+Parser::Parser() : subroutines_(nullptr), pr_(nullptr) {}
+
 Parser::~Parser() { this->cleanup(); }
-//这是 Parser 类的析构函数，它调用 cleanup 方法来清理资源。
-Parser::ParseResult* Parser::parse(const int argc, const char** argv) {//Parser 类的 parse 方法，它接受命令行参数的数量 argc 和参数值 argv
-  if (!this->init(argc, argv)) {//它调用 init 方法来初始化解析过程
-    return nullptr;//如果初始化失败，那么返回 nullptr
+
+Parser::ParseResult* Parser::parse(const int argc, const char** argv) {
+  if (!this->init(argc, argv)) {
+    return nullptr;
   }
-  auto ibegin = args_.begin() + 1;  // 忽略第一个命令名
+  auto ibegin = args_.begin() + 1;  // ignore the first cmd name
   auto iend = args_.end();
-  auto it = ibegin;//定义开始变量名
+  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++;   // 忽略子程序名
+      it++;  // ignore the subroutine name
     } else {
       subroutine_name_ = args_[1];
     }
   } else {
-    // 没有选项以及子程序名
-    // 例如，./exec
+    // 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);//声明变量
+  std::string block;
+  std::string previous(*ibegin);
 
-  for (; it != iend; ++it) {// 遍历所有的命令行参数
-    block.assign(*it);// 将当前参数赋值给 block
+  for (; it != iend; ++it) {
+    block.assign(*it);
 
-    switch (block.size()) {//// 根据 block 的大小进行不同的处理
-      case 1://// 如果 block 的大小为 1
-        if (block == "-") {//// 如果 block 是一个单独的 "-"
-          throw ParseError("single '-' is not allowed");//// 抛出异常，因为单独的 "-" 是不允许的
+    switch (block.size()) {
+      case 1:
+        if (block == "-") {
+          throw ParseError("single '-' is not allowed");
         }
         break;
-      case 2:// // 如果 block 的大小为 2
-        if (block[0] == '-') {//// 如果 block 的第一个字符是 "-"
-          if (block[1] == '-') {//// 如果 block 的第二个字符也是 "-"
-            throw ParseError("option '--' is incomplete");//// 抛出异常，因为 "--" 是不完整的选项
-
-          } else if (block[1] == '=') {//// 如果 block 的第二个字符是 "="
-            throw ParseError("option '-=' is invalid");//// 抛出异常，因为 "-=" 是无效的选项
+      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] == '-') {//// 如果 block 的第一个字符是 "-"
-          if (block[1] == '-') {//// 如果 block 的第二个字符也是 "-"
-            size_t pos_equal = block.find('=');//// 查找 "=" 在 block 中的位置
-            if (pos_equal == std::string::npos) {//// 如果没有找到 "="
-              // 长格式选项
+        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;//// 将选项添加到 pr_ 中，值为 nullptr
+              (*pr_)[block.substr(2)] = nullptr;
             } else {
-              if (pos_equal > 3) {// 如果 "=" 的位置大于 3
+              if (pos_equal > 3) {
                 // e.g, ./exec --op[..=]value
-                std::string key(block.substr(2, pos_equal - 2));// 获取选项名
-                if (block.size() > 5)//// 如果 block 的大小大于 5
+                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));// 将选项和值添加到 pr_ 中
+                  (*pr_)[key] = new ParseItem(block.substr(pos_equal + 1));
                 else
-                  (*pr_)[key] = nullptr;// 将选项添加到 pr_ 中，值为 nullptr
+                  (*pr_)[key] = nullptr;
               } else {
-                // 长格式选项但 = 是非法的
+                // a long format option but = is illegal
                 // e.g., ./exec --o=[...]
-                (*pr_)[block.substr(2)] = nullptr;//// 将选项添加到 pr_ 中，值为 nullptr
+                (*pr_)[block.substr(2)] = nullptr;
               }
             }
-          } else if (block[2] == '=') {// // 如果 block 的第三个字符是 "="
-            // 单个选项带有 =
+          } else if (block[2] == '=') {
+            // a single option with =
             // e.g., ./exec -o=[...]
             std::string key;
-            key.push_back(block[1]);// 获取选项名
-            if (block.size() > 3)// 如果 block 的大小大于 3
-              (*pr_)[key] = new ParseItem(block.substr(3));//// 将选项和值添加到 pr_ 中
+            key.push_back(block[1]);
+            if (block.size() > 3)
+              (*pr_)[key] = new ParseItem(block.substr(3));
             else
-              (*pr_)[key] = nullptr;// 将选项添加到 pr_ 中，值为 nullptr
+              (*pr_)[key] = nullptr;
           } else {
-            // 组合选项
+            // a combination options
             // e.g., ./exec -ab[...]
-            auto tbegin = block.begin() + 1;  // 忽略第一个 '-'
+            auto tbegin = block.begin() + 1;  // ignore the first '-'
             auto tend = block.end();
             auto t = tbegin;
 
-            for (; t != tend; ++t) { // 遍历 block 中的每个字符
+            for (; t != tend; ++t) {
               std::string key;
-              key.push_back(*t);// // 获取选项名
-              (*pr_)[key] = nullptr; // 将选项添加到 pr_ 中，值为 nullptr
+              key.push_back(*t);
+              (*pr_)[key] = nullptr;
             }
           }
         }
         break;
     }  // switch
 
-    if (block[0] != '-' && previous != block  // 如果 block 不是选项（不以 "-" 开头）并且不是第一个选项
+    if (block[0] != '-' && previous != block  // not the first option
         ) {
-      if (previous[0] != '-') {//// 如果 previous 不是选项
-        // previous 不是一个选项，发生错误
+      if (previous[0] != '-') {
+        // previous is not an option, error occur
         // e.g., ./exec abc def
-        throw ParseError("'" + block + "' is not allowed here");//抛出异常，因为在这里不允许非选项
+        throw ParseError("'" + block + "' is not allowed here");
       }
 
       std::string key;
 
-      if (previous[0] == '-' && previous[1] == '-') {//// 如果 previous 是一个长格式选项
+      if (previous[0] == '-' && previous[1] == '-') {
         // previous is a long format option.
         // e.g., ./exec --option value
-        key = previous.substr(2);//// 获取选项名
+        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));// // 获取选项名
+        key.push_back(*(previous.end() - 1));
       }
 
-      if (pr_->find(key) != pr_->end()) {//// 如果选项在 pr_ 中存在
-        (*pr_)[key] = new ParseItem(block); // 将选项和值添加到 pr_ 中
+      if (pr_->find(key) != pr_->end()) {
+        (*pr_)[key] = new ParseItem(block);
       }
     }
 
-    previous = block;//// 更新 previous 为当前的 block
+    previous = block;
   }  // for
 
   if (subroutines_) {
-    this->set_addition();// 如果存在子程序，调用 set_addition 方法处理额外的选项
+    this->set_addition();
   }
 
-  return pr_;//返回解析结果 pr_
+  return pr_;
 }
 
-Parser::ParseResult* Parser::parse(const char* command_line) {//Parser 类的 parse 方法
-  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);//// 将当前字符添加到 block
+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()) {// 如果 block 不为空
-        blocks.push_back(block);// 将 block 添加到 blocks
+      if (!block.empty()) {
+        blocks.push_back(block);
       }
-      block.clear();//清空 block
+      block.clear();
     }
   }
-  if (!block.empty()) {// 如果最后一个 block 不为空
-    blocks.push_back(block);// 将 block 添加到 blocks
+  if (!block.empty()) {
+    blocks.push_back(block);
   }
   size_t size = blocks.size();  // argc
-  char** argv = new char*[size];// 创建一个新的 char* 数组
+  char** argv = new char*[size];
   i = 0;
-  std::for_each(blocks.begin(), blocks.end(), [argv, &i](const std::string& b) {// 遍历 blocks
-    argv[i++] = const_cast<char*>(b.c_str());// 将每个 block 转换为 char* 并存储在 argv 中
+  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)); // 调用 parse 方法解析命令行参数
+      this->parse(static_cast<const int>(size), const_cast<const char**>(argv));
 
-  delete[] argv;// 删除 argv
+  delete[] argv;
   argv = nullptr;
 
-  return pr;// 返回解析结果
+  return pr;
 }
 
-bool Parser::has(const char* key) {//Parser 类的 has 方法，它接受一个 char 指针 key，并检查 key 是否在 pr_ 中存在。
-  std::string skey(key);// 将 key 转换为 std::string
+bool Parser::has(const char* key) {
+  std::string skey(key);
 
-  if (pr_ && !pr_->empty() && !skey.empty()) {//判断是否存在
+  if (pr_ && !pr_->empty() && !skey.empty()) {
     if (skey[0] == '-') {
-       // 如果 skey 是一个组合选项，例如 "-xyz"
-      for (size_t i = 1; i < skey.size(); ++i) {// 遍历 skey 的每个字符
+      // 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()) { // 如果选项名在 pr_ 中不存在
+        tkey.push_back(skey[i]);
+        if (pr_->find(tkey) == pr_->end()) {
           return false;
         }
       }
       return true;
     } else {
-      // 如果 skey 是一个单个选项，例如 "x"
-      return pr_->find(skey) != pr_->end();// 检查选项是否在 pr_ 中存在
+      // check single option, e.g., Parser::has("x")
+      return pr_->find(skey) != pr_->end();
     }
   }
-  return false;// 如果 pr_ 为空或 skey 为空，返回 false
+  return false;
 }
 
-//parser 类的 has_or 方法，它接受一个初始化列表 options，并检查 options 中的任何一个 key 是否在 pr_ 中存在。
 bool Parser::has_or(std::initializer_list<const char*> options) {
-  if (options.size() == 0) {// 如果 options 为空
+  if (options.size() == 0) {
     return false;
-  }4
-  for (auto key : options) {// 遍历 options 中的每个选项
-    if (this->has(key)) return true;// 如果选项在 pr_ 中存在，返回 true
   }
-  return false;// 如果 options 中的所有选项都不存在，返回 false
+  for (auto key : options) {
+    if (this->has(key)) return true;
+  }
+  return false;
 }
 
-bool Parser::has_and(std::initializer_list<const char*> options) { // Parser 类的 has_and 方法，接受一个初始化列表 options
-  if (options.size() == 0) {// 如果 options 为空
+bool Parser::has_and(std::initializer_list<const char*> options) {
+  if (options.size() == 0) {
     return false;
   }
-  for (auto key : options) {// 遍历 options 中的每个选项
-    if (!this->has(key)) return false;// 如果选项在 pr_ 中不存在，返回 false
+  for (auto key : options) {
+    if (!this->has(key)) return false;
   }
-  return true;// 如果 options 中的所有选项都存在，返回 true
+  return true;
 }
 
 bool Parser::init(const int argc, const char** argv) {
-  argc_ = argc;// 保存参数数量
+  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) {// 如果参数数量大于 0
-    this->cleanup(); // 清理之前的解析结果
-
+  if (argc > 0) {
+    this->cleanup();
 
-    args_.reserve(static_cast<size_t>(argc_));// 为 args_ 预留空间
+    args_.reserve(static_cast<size_t>(argc_));
 
-    for (int i = 0; i < argc_; ++i) {// 遍历所有的命令行参数
-      args_.push_back(argv[i]);// 将参数添加到 args_
+    for (int i = 0; i < argc_; ++i) {
+      args_.push_back(argv[i]);
     }
 
-    pr_ = new Parser::ParseResult;// 创建新的解析结果
+    pr_ = new Parser::ParseResult;
     return true;
   }
-  return false;// 如果参数数量为 0，返回 false
+  return false;
 }
 
-void Parser::cleanup() {// Parser 类的 cleanup 方法，用于清理解析结果
-  args_.clear();// 清空 args_
-  if (pr_) {// 如果 pr_ 不为空
+void Parser::cleanup() {
+  args_.clear();
+  if (pr_) {
     auto ibegin = pr_->begin();
     auto iend = pr_->end();
     auto it = ibegin;
-    for (; it != iend; ++it) {// 遍历 pr_ 中的每个元素
+    for (; it != iend; ++it) {
       ParseItem* item = it->second;
-      if (item) delete item;// 删除元素
+      if (item) delete item;
     }
-    delete pr_;// 删除 pr_
+    delete pr_;
     pr_ = nullptr;
   }
 }
 
-void Parser::set_addition() {// Parser 类的 set_addition 方法，用于处理额外的选项
-  if (subroutines_->find(subroutine_name_) != subroutines_->end()) {// 如果子程序名在 subroutines_ 中存在
-    for (const Row& row : *(subroutines_->at(subroutine_name_))) {// 遍历子程序中的每一行
+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_; // 获取解析结果
+      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());// 检查长选项是否存在
+      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));// 如果长选项不为空，也将默认值赋给长选项
+      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;// 将长选项的值设为 nullptr
+            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));// 将默认值赋给长选项
+      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;// 将短选项的值设为 nullptr
+            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));// 如果短选项不为空，将默认值赋给短选项
+      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
@@ -433,115 +427,114 @@ void Parser::set_addition() {// Parser 类的 set_addition 方法，用于处理
 
 // class Row
 
-Row::Row() : require_value(true) {} // Row 类的构造函数，初始化 require_value 为 true
+Row::Row() : require_value(true) {}
 
 // class Subroutine
 
-Subroutine::Subroutine() : first_line_("") {}// Subroutine 类的默认构造函数，初始化 first_line_ 为空字符串
+Subroutine::Subroutine() : first_line_("") {}
 
 Subroutine::Subroutine(const char* name, const char* description)
-    : first_line_(""), description_(description), name_(name) { // Subroutine 类的构造函数，接受子程序名和描述作为参数
-  usages_.reserve(5);// 为 usages_ 预留空间
+    : first_line_(""), description_(description), name_(name) {
+  usages_.reserve(5);
 }
 
-void Subroutine::print_with_row(std::ostream& out) {// Subroutine 类的 print_with_row 方法，接受一个输出流作为参数
+void Subroutine::print_with_row(std::ostream& out) {
   // print the subroutine name and its description
-  // 打印子程序名和描述
-  if (strcmp(get_first_line(), "") != 0) {// 如果 first_line_ 不为空
+  if (strcmp(get_first_line(), "") != 0) {
     // print the first line
     out << get_first_line();
-    if (!usages_.empty()) {// 如果 usages_ 不为空
-      out << std::endl;// 打印换行符
+    if (!usages_.empty()) {
+      out << std::endl;
     }
   }
-  auto begin = usages_.begin(); // 获取 usages_ 的开始迭代器
-  auto end = usages_.end();// 获取 usages_ 的结束迭代器
+  auto begin = usages_.begin();
+  auto end = usages_.end();
 
-  std::vector<std::string> row_list;// 创建一个字符串向量用于存储行
-  row_list.reserve(usages_.size());// 为 row_list 预留空间
+  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) {// 遍历 usages_
-    std::stringstream ss;// 创建一个字符串流
-    ss << "  ";// 向字符串流中添加两个空格
-    if (!row.oshort().empty()) {// 如果短选项不为空
-      ss << "-" << row.oshort() << " "; // 添加短选项
+  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.olong().empty()) {
       if (!row.oshort().empty())
-        ss << "[ --" << row.olong() << " ] ";// 添加长选项
+        ss << "[ --" << row.olong() << " ] ";
       else
-        ss << "--" << row.olong() << " "; // 添加长选项
+        ss << "--" << row.olong() << " ";
     }
 
-    if (row.required()) {// 如果选项是必需的
-      ss << "arg "; // 添加 "arg "
-      if (!row.value().empty()) {// 如果选项值不为空
-        ss << "= " << row.value() << " ";// 添加选项值
+    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()));// 将字符串流的内容添加到 row_list
+    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();// 获取 usages_ 的大小
-  for (size_t i = 0; i < row_count; ++i) {// 遍历 usages_
-    std::string str_row(std::move(row_list[i]));// 获取当前行
+  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;// 打印当前行
+    out << str_row;
     // print spaces
-    size_t spaces = 0;// 打印空格
-    size_t len = str_row.size();// 获取当前行的长度
-    if (max_len > len) spaces = max_len - len;// 计算需要打印的空格数量
+    size_t spaces = 0;
+    size_t len = str_row.size();
+    if (max_len > len) spaces = max_len - len;
 
-    while (spaces--) {// 打印空格
+    while (spaces--) {
       out << " ";
     }
     // print description
-    out << usages_.at(i).desc() << std::endl;// 打印描述
+    out << usages_.at(i).desc() << std::endl;
   }
 }
 
-void Subroutine::print_with_template(std::ostream& out) {// Subroutine 类的 print_with_template 方法，接受一个输出流作为参数
-  for (auto usage : usages_) {// 遍历 usages_
+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)) { // 根据 order_ 中的值决定打印哪个字段
+    for (auto t = template_str_.begin(); t != template_str_.end(); ++t) {
+      if (*t == '%') {
+        switch (*(order_.begin() + i)) {
           case Row::kShort:
-            out << usage.oshort();// 打印短选项
+            out << usage.oshort();
             break;
           case Row::kLong:
-            out << usage.olong();// 打印长选项
+            out << usage.olong();
             break;
           case Row::kDefault:
-            out << usage.value();// 打印默认值
+            out << usage.value();
             break;
           case Row::kDescription:
-            out << usage.desc();// 打印描述
+            out << usage.desc();
             break;
           default:
             break;
         }
         ++i;
       } else {
-        out << *t;// 如果当前字符不是 '%'，直接打印
+        out << *t;
       }  // if %
     }    // for template_str_
-    out << std::endl;// 打印换行符
+    out << std::endl;
   }  // for usages_
 }
 
-std::ostream& operator<<(std::ostream& out, Subroutine& subroutine) {// 重载 << 运算符，接受一个输出流和一个 Subroutine 对象作为参数
-  if (subroutine.template_str_.empty()) {// 如果模板字符串为空
-    subroutine.print_with_row(out);// 使用 print_with_row 方法打印
+std::ostream& operator<<(std::ostream& out, Subroutine& subroutine) {
+  if (subroutine.template_str_.empty()) {
+    subroutine.print_with_row(out);
   } else {
-    subroutine.print_with_template(out);// 使用 print_with_template 方法打印
+    subroutine.print_with_template(out);
   }
-  return out;// 返回输出流
+  return out;
 }
 }

src/src/util/util.cpp

@@ -1,127 +1,127 @@
 #include "easypr/util/util.h"
 #include <string>
 
-// #ifdef OS_WINDOWS
-#include <windows.h>  // 包含windows.h头文件，用于Windows平台的系统调用
-#include <direct.h>  // 包含direct.h头文件，用于Windows平台的目录操作
-#include <io.h>  // 包含io.h头文件，用于Windows平台的IO操作
-#define PATH_DELIMITER '\\'  // 定义路径分隔符为'\\'
+#ifdef OS_WINDOWS
+#include <windows.h>
+#include <direct.h>
+#include <io.h>
+#define PATH_DELIMITER '\\'
 #ifdef min
-#undef min  // 如果已经定义了min，取消其定义
+#undef min
 #endif
 
 #ifdef max
-#undef max  // 如果已经定义了max，取消其定义
+#undef max
 #endif
 #elif defined(OS_LINUX) || defined(OS_UNIX)
 
-#include <cstring>  // 包含cstring头文件，用于字符串操作
-#include <dirent.h>  // 包含dirent.h头文件，用于目录操作
-#include <sys/stat.h>  // 包含sys/stat.h头文件，用于文件状态检查
-#include <unistd.h>  // 包含unistd.h头文件，用于Unix标准的系统调用
+#include <cstring>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
-#define PATH_DELIMITER '/'  // 定义路径分隔符为'/'
+#define PATH_DELIMITER '/'
 #endif
 
 #ifdef OS_UNIX
 
-#include <sys/timeb.h>  // 包含sys/timeb.h头文件，用于时间操作
+#include <sys/timeb.h>
 
 #endif
 
-#include <list>  // 包含list头文件，用于list数据结构
-#include <opencv2/highgui/highgui.hpp>  // 包含opencv的highgui模块，用于图像IO操作
+#include <list>
+#include <opencv2/highgui/highgui.hpp>
 
-namespace easypr {  // 定义easypr命名空间
+namespace easypr {
 
-long Utils::getTimestamp() {  // 定义获取时间戳的函数
+long Utils::getTimestamp() {
 #ifdef OS_WINDOWS
-  return static_cast<long>(cv::getTickCount());  // Windows平台下，使用opencv的getTickCount函数获取时间戳
+  return static_cast<long>(cv::getTickCount());
 #endif
 
 #ifdef OS_LINUX
-  struct timespec ts;  // 定义timespec结构体，用于获取时间
+  struct timespec ts;
 
-  clock_gettime(CLOCK_MONOTONIC, &ts);  // 获取当前时间
+  clock_gettime(CLOCK_MONOTONIC, &ts);
 
-  return (ts.tv_sec * 1e3 + ts.tv_nsec / 1e6);  // 返回毫秒级的时间戳
+  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;  // 定义timeb结构体，用于获取时间
-  ftime(&tb);  // 获取当前时间
-  return long(tb.time * 1e3 + tb.millitm);  // 返回毫秒级的时间戳
+  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('.');  // 获取路径中最后一个点的位置
+                               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);  // 如果没有找到正确的后缀点，直接返回文件名
+      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);  // 如果路径有后缀，并且需要返回后缀，返回包含后缀的文件名
+        return path.substr(last_slash + 1);
       }
       // without postfix
-      return path.substr(last_slash + 1, last_dot - last_slash - 1);  // 如果路径有后缀，但不需要返回后缀，返回不包含后缀的文件名
+      return path.substr(last_slash + 1, last_dot - last_slash - 1);
     }
   }
-  return "";  // 如果路径为空，返回空字符串
+  return "";
 }
 
 std::vector<std::string> Utils::splitString(const std::string &str,
-                                            const char delimiter) {  // 定义字符串分割函数
-  std::vector<std::string> splited;  // 定义存储分割结果的vector
-  std::string s(str);  // 复制输入的字符串
-  size_t pos;  // 定义分割位置
+                                            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);  // 获取分隔符前的子串
+  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));  // 将子串添加到分割结果中
+    if (!sec.empty()) {
+      splited.push_back(s.substr(0, pos));
     }
 
-    s = s.substr(pos + 1);  // 更新待分割的字符串
+    s = s.substr(pos + 1);
   }
 
-  splited.push_back(s);  // 将最后一个子串添加到分割结果中
+  splited.push_back(s);
 
-  return splited;  // 返回分割结果
+  return splited;
 }
 
 std::vector<std::string> Utils::getFiles(const std::string &folder,
-                                         const bool all /* = true */) {  // 定义获取文件列表的函数
-  std::vector<std::string> files;  // 定义存储文件列表的vector
-  std::list<std::string> subfolders;  // 定义存储子文件夹的list
-  subfolders.push_back(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());  // 获取当前处理的文件夹
+  while (!subfolders.empty()) {
+    std::string current_folder(subfolders.back());
 
     if (*(current_folder.end() - 1) != '/') {
-      current_folder.append("/*");  // 如果当前文件夹的路径不以'/'结尾，添加'/*'
+      current_folder.append("/*");
     } else {
-      current_folder.append("*");  // 如果当前文件夹的路径以'/'结尾，添加'*'
+      current_folder.append("*");
     }
 
-    subfolders.pop_back();  // 从子文件夹列表中移除当前处理的文件夹
+    subfolders.pop_back();
 
-    struct _finddata_t file_info;  // 定义文件信息结构体
-    auto file_handler = _findfirst(current_folder.c_str(), &file_info);  // 打开当前文件夹
+    struct _finddata_t file_info;
+    auto file_handler = _findfirst(current_folder.c_str(), &file_info);
 
-    while (file_handler != -1) {  // 当文件夹打开成功时
+    while (file_handler != -1) {
       if (all &&
           (!strcmp(file_info.name, ".") || !strcmp(file_info.name, ".."))) {
         if (_findnext(file_handler, &file_info) != 0) break;
@@ -136,7 +136,7 @@ std::vector<std::string> Utils::getFiles(const std::string &folder,
           folder.pop_back();
           folder.append(file_info.name);
 
-          subfolders.push_back(folder.c_str());  // 如果是子文件夹，并且需要搜索子文件夹，将子文件夹添加到子文件夹列表中
+          subfolders.push_back(folder.c_str());
         }
       } else {
         // it's a file
@@ -145,24 +145,24 @@ std::vector<std::string> Utils::getFiles(const std::string &folder,
         file_path.assign(current_folder.c_str()).pop_back();
         file_path.append(file_info.name);
 
-        files.push_back(file_path);  // 如果是文件，将文件路径添加到文件列表中
+        files.push_back(file_path);
       }
 
       if (_findnext(file_handler, &file_info) != 0) break;
     }  // while
-    _findclose(file_handler);  // 关闭文件夹
+    _findclose(file_handler);
   }
 #elif defined(OS_LINUX) || defined(OS_UNIX)
-  while (!subfolders.empty()) {  // 当子文件夹列表不为空时
-    std::string current_folder(subfolders.back());  // 获取当前处理的文件夹
+  while (!subfolders.empty()) {
+    std::string current_folder(subfolders.back());
 
     if (*(current_folder.end() - 1) != '/') {
-      current_folder.push_back('/');  // 如果当前文件夹的路径不以'/'结尾，添加'/'
+      current_folder.push_back('/');
     }
 
-    DIR* pdir = opendir(current_folder.c_str());  // 打开当前文件夹
+    DIR* pdir = opendir(current_folder.c_str());
 
-    subfolders.pop_back();  // 从子文件夹列表中移除当前处理的文件夹
+    subfolders.pop_back();
 
     if (!pdir) {
       continue;
@@ -170,9 +170,9 @@ std::vector<std::string> Utils::getFiles(const std::string &folder,
 
     dirent* dir = NULL;
 
-    while ((dir = readdir(pdir)) != NULL) {  // 当读取到文件或文件夹时
+    while ((dir = readdir(pdir)) != NULL) {
       // iterates the current folder, search file & sub folder
-      struct stat st;  // 定义文件状态结构体
+      struct stat st;
 
       if (all && (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))) {
         // must ignore . & ..
@@ -201,93 +201,93 @@ std::vector<std::string> Utils::getFiles(const std::string &folder,
           std::string subfolder(current_folder);
           subfolder.append(dir->d_name);
 
-          subfolders.push_back(subfolder.c_str());  // 如果是子文件夹，并且需要搜索子文件夹，将子文件夹添加到子文件夹列表中
+          subfolders.push_back(subfolder.c_str());
         }
       } else {
         // it's a file
-        files.push_back(file_path);  // 如果是文件，将文件路径添加到文件列表中
+        files.push_back(file_path);
       }
     }  // while
-    closedir(pdir);  // 关闭文件夹
+    closedir(pdir);
   }
 #endif
-  return files;  // 返回文件列表
+  return files;
 }
 
-bool Utils::mkdir(const std::string folder) {  // 定义创建文件夹的函数
-  std::string folder_builder;  // 定义文件夹路径构造器
-  std::string sub;  // 定义子路径
+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) {  // 遍历输入的文件夹路径
+  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);  // 将子路径添加到文件夹路径构造器中
+    if (c == PATH_DELIMITER || it == folder.end() - 1) {
+      folder_builder.append(sub);
 #ifdef OS_WINDOWS
-      if (0 != ::_access(folder_builder.c_str(), 0)) {  // 如果文件夹不存在
+      if (0 != ::_access(folder_builder.c_str(), 0)) {
 #else
-      if (0 != ::access(folder_builder.c_str(), 0)) {  // 如果文件夹不存在
+      if (0 != ::access(folder_builder.c_str(), 0)) {
 #endif
         // this folder not exist
 #ifdef OS_WINDOWS
-        if (0 != ::_mkdir(folder_builder.c_str())) {  // 如果创建文件夹失败
+        if (0 != ::_mkdir(folder_builder.c_str())) {
 #else
-        if (0 != ::mkdir(folder_builder.c_str(), S_IRWXU)) {  // 如果创建文件夹失败
+        if (0 != ::mkdir(folder_builder.c_str(), S_IRWXU)) {
 #endif
           // create failed
-          return false;  // 返回失败
+          return false;
         }
       }
-      sub.clear();  // 清空子路径
+      sub.clear();
     }
   }
-  return true;  // 返回成功
+  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);  // 写入图像
+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) {  // 定义UTF-8到GBK的转换函数
-  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);  // 将UTF-8字符串转换为宽字符字符串
-  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);  // 将宽字符字符串转换为GBK字符串
-  std::string strTemp(szGBK);  // 将GBK字符串转换为std::string
+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;  // 删除宽字符数组
+    delete[] wszGBK;
   if (szGBK)
-    delete[] szGBK;  // 删除字符数组
-  return strTemp;  // 返回转换结果
+    delete[] szGBK;
+  return strTemp;
 }
 #endif
 
-std::size_t Utils::get_last_slash(const std::string &path) {  // 定义获取路径中最后一个斜杠的位置的函数
+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_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);  // 如果路径中既有'\\'又有'/'，取最后出现的一个
+    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;  // 如果路径中只有'\\'或只有'/'，取出现的那一个
+        (last_slash_1 == std::string::npos) ? last_slash_2 : last_slash_1;
   }
 #else
-  size_t last_slash = path.find_last_of('/');  // 获取路径中最后一个'/'的位置
+  size_t last_slash = path.find_last_of('/');
 #endif
-  return last_slash;  // 返回最后一个斜杠的位置
+  return last_slash;
 }
 
 }  // namespace easypr