泛读报告

把詹志鹏放错位置的代码删除并放到src/src/train/annCh_train.cpp

src/src/core/chars_identify.cpp

@@ -7,448 +7,595 @@
 
 using namespace cv;
 
-namespace easypr {
+namespace easypr
+{
 
-CharsIdentify* CharsIdentify::instance_ = nullptr;
+  CharsIdentify *CharsIdentify::instance_ = nullptr;
 
-CharsIdentify* CharsIdentify::instance() {
-  if (!instance_) {
-    instance_ = new CharsIdentify;
+  CharsIdentify *CharsIdentify::instance()
+  {
+    if (!instance_)
+    {
+      instance_ = new CharsIdentify;
+    }
+    return instance_;
   }
-  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;
+  // 对输入的特征行进行预测，并识别出最可能的字符。
+  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;
+    }
+  }
 
-  cv::Mat output(rowNum, kCharsTotalNumber, CV_32FC1);
-  ann_->predict(featureRows, output);
+  // 接受一个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);
+    }
 
-  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;
+    // 创建一个输出矩阵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;
+          }
         }
+        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);
     }
-    else {
-      result = kCharactersNumber;
-      for (int j = kCharactersNumber; j < kCharsTotalNumber; j++) {
+  }
+
+  // 对输入的中文字符进行分类
+  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++)
+      {
         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;
+      }
 
-void CharsIdentify::classify(std::vector<CCharacter>& charVec){
-  size_t charVecSize = charVec.size();
+      // 根据这个最大值和索引确定预测的字符。
+      // 这是通过查找kChars数组实现的，其中kChars可能是一个预定义的字符集。
+      auto index = result + kCharsTotalNumber - kChineseNumber;
+      const char *key = kChars[index];
+      std::string s = key;
+      std::string province = kv_->get(s);
 
-  if (charVecSize == 0)
-    return;
+      /*std::cout << "result:" << result << std::endl;
+      std::cout << "maxVal:" << maxVal << std::endl;*/
 
-  Mat featureRows;
-  for (size_t index = 0; index < charVecSize; index++) {
-    Mat charInput = charVec[index].getCharacterMat();
-    Mat feature = charFeatures(charInput, kPredictSize);
-    featureRows.push_back(feature);
+      // 将预测的最大值、预测的字符以及对应的省份作为标签，
+      // 分别设置到对应字符对象的得分、字符串属性和是否为中文字符属性中
+      character.setCharacterScore(maxVal);
+      character.setCharacterStr(province);
+      character.setIsChinese(isChinese);
+    }
   }
 
-  cv::Mat output(charVecSize, kCharsTotalNumber, CV_32FC1);
-  ann_->predict(featureRows, output);
+  // 使用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);
+    }
 
-  for (size_t output_index = 0; output_index < charVecSize; output_index++) {
-    CCharacter& character = charVec[output_index];
-    Mat output_row = output.row(output_index);
+    // 创建一个输出矩阵（output），并使用预先训练好的模型（annChinese_）对特征进行预测。预测结果存储在output中。
+    cv::Mat output(charVecSize, kChineseNumber, CV_32FC1);
+    annChinese_->predict(featureRows, output);
 
-    int result = 0;
-    float maxVal = -2.f;
-    std::string label = "";
+    // 遍历每个预测结果，并对每个结果进行处理。对于每个预测结果，函数查找最大值及其索引。
+    // 如果最大值小于或等于-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;
 
-    bool isChinses = character.getIsChinese();
-    if (!isChinses) {
-      result = 0;
-      for (int j = 0; j < kCharactersNumber; j++) {
+      float maxVal = -2;
+      int result = 0;
+
+      for (int j = 0; j < kChineseNumber; j++)
+      {
         float val = output_row.at<float>(j);
-        //std::cout << "j:" << j << "val:" << val << std::endl;
-        if (val > maxVal) {
+        // std::cout << "j:" << j << "val:" << val << std::endl;
+        if (val > maxVal)
+        {
           maxVal = val;
           result = j;
         }
       }
-      label = std::make_pair(kChars[result], kChars[result]).second;
+
+      // 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);
     }
-    else {
+  }
+
+  // 对输入的图像数据进行分类
+  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
+    {
       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) {
+      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;
         }
       }
-      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);
+    // 返回索引值result，该值是预测的字符在预先定义的字符集kChars中的索引。
+    // 同时，它也将最大值maxVal和对应的索引result设置到输入的float引用maxVal中，以便调用者可以访问这些值。
+    // std::cout << "maxVal:" << maxVal << std::endl;
+    return result;
   }
-}
-
+  // 根据输入的图像数据判断它是否是一个字符（特别是中文字符）
+  bool CharsIdentify::isCharacter(cv::Mat input, std::string &label, float &maxVal, bool isChinese)
+  {
+    // 调用charFeatures函数提取输入图像的特征，并存储在feature变量中。
+    // 然后，它调用classify函数对特征进行分类，得到一个索引值index
+    cv::Mat feature = charFeatures(input, kPredictSize);
+    auto index = static_cast<int>(classify(feature, maxVal, isChinese));
 
-void CharsIdentify::classifyChineseGray(std::vector<CCharacter>& charVec){
-  size_t charVecSize = charVec.size();
-  if (charVecSize == 0)
-    return;
+    if (isChinese)
+    {
+      // std::cout << "maxVal:" << maxVal << std::endl;
+    }
 
-  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);
+    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;
   }
-
-  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;
-
+  // 用于识别输入的图像数据是否是一个中文字符。
+  std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input, float &out, bool &isChinese)
+  {
+    // 调用charFeatures函数提取输入图像的特征，并存储在feature变量中。
+    // 然后，它调用预先训练好的模型annChinese_进行预测，并将预测结果存储在output变量中。
+    cv::Mat feature = charFeatures(input, kChineseSize);
     float maxVal = -2;
     int result = 0;
 
-    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) {
+    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)
+      {
         maxVal = val;
         result = j;
       }
     }
 
     // no match
-    if (-1 == result) {
+    // 如果索引值为-1（即没有匹配的字符），
+    // 则将result设置为0，maxVal设置为0，并将isChinese设置为false，表示输入的字符不是中文。
+    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;
 
-    /*std::cout << "result:" << result << std::endl;
-    std::cout << "maxVal:" << maxVal << std::endl;*/
-
-    character.setCharacterScore(maxVal);
-    character.setCharacterStr(province);
-    character.setIsChinese(isChinese);
-  }
-}
-
-void CharsIdentify::classifyChinese(std::vector<CCharacter>& charVec){
-  size_t charVecSize = charVec.size();
-
-  if (charVecSize == 0)
-    return;
-
-  Mat featureRows;
-  for (size_t index = 0; index < charVecSize; index++) {
-    Mat charInput = charVec[index].getCharacterMat();
-    Mat feature = charFeatures(charInput, kChineseSize);
-    featureRows.push_back(feature);
+    return std::make_pair(s, province);
   }
-
-  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;
-
+  // 从输入的图像（可能是一个灰度图像）中识别出可能的中文字符。
+  std::pair<std::string, std::string> CharsIdentify::identifyChineseGray(cv::Mat input, float &out, bool &isChinese)
+  {
+    cv::Mat feature;
+    // 通过extractFeature函数提取输入图像的特征，并将特征保存在feature变量中。
+    // 然后，它使用预先训练好的模型annGray_进行预测，并将预测结果存储在output变量中。
+    extractFeature(input, feature);
     float maxVal = -2;
     int result = 0;
-
-    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) {
+    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)
+      {
         maxVal = val;
         result = j;
       }
     }
-
     // no match
-    if (-1 == result) {
+    // 如果索引值为-1（即没有匹配的字符），
+    // 则将result设置为0，maxVal设置为0，并将isChinese设置为false，表示输入的字符不是中文
+    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);
-
-    /*std::cout << "result:" << result << std::endl;
-    std::cout << "maxVal:" << maxVal << std::endl;*/
-
-    character.setCharacterScore(maxVal);
-    character.setCharacterStr(province);
-    character.setIsChinese(isChinese);
-  }
-}
-
-int CharsIdentify::classify(cv::Mat f, float& maxVal, bool isChinses, bool isAlphabet){
-  int result = 0;
-
-  cv::Mat output(1, kCharsTotalNumber, CV_32FC1);
-  ann_->predict(f, output);
-
-  maxVal = -2.f;
-  if (!isChinses) {
-    if (!isAlphabet) {
-      result = 0;
-      for (int j = 0; j < kCharactersNumber; j++) {
-        float val = output.at<float>(j);
-        // std::cout << "j:" << j << "val:" << val << std::endl;
-        if (val > maxVal) {
-          maxVal = val;
-          result = j;
-        }
-      }
-    }
-    else {
-      result = 0;
-      // begin with 11th char, which is 'A'
-      for (int j = 10; j < kCharactersNumber; j++) {
-        float val = output.at<float>(j);
-        // std::cout << "j:" << j << "val:" << val << std::endl;
-        if (val > maxVal) {
-          maxVal = val;
-          result = j;
-        }
-      }
-    }
-  }
-  else {
-    result = kCharactersNumber;
-    for (int j = kCharactersNumber; j < kCharsTotalNumber; j++) {
-      float val = output.at<float>(j);
-      //std::cout << "j:" << j << "val:" << val << std::endl;
-      if (val > maxVal) {
-        maxVal = val;
-        result = j;
-      }
-    }
-  }
-  //std::cout << "maxVal:" << maxVal << std::endl;
-  return result;
-}
-
-bool CharsIdentify::isCharacter(cv::Mat input, std::string& label, float& maxVal, bool isChinese) {
-  cv::Mat feature = charFeatures(input, kPredictSize);
-  auto index = static_cast<int>(classify(feature, maxVal, isChinese));
-
-  if (isChinese) {
-    //std::cout << "maxVal:" << maxVal << std::endl;
+    out = maxVal;
+    return std::make_pair(s, province);
   }
 
-  float chineseMaxThresh = 0.2f;
-
-  if (maxVal >= 0.9 || (isChinese && maxVal >= chineseMaxThresh)) {
-    if (index < kCharactersNumber) {
-      label = std::make_pair(kChars[index], kChars[index]).second;
+  // 用于识别输入的图像数据是否是一个字符。
+  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]);
     }
-    else {
-      const char* key = kChars[index];
+    else
+    {
+      const char *key = kChars[index];
       std::string s = key;
       std::string province = kv_->get(s);
-      label = std::make_pair(s, province).second;
+      return std::make_pair(s, province);
     }
-    return true;
   }
-  else
-    return false;
-}
-
-std::pair<std::string, std::string> CharsIdentify::identifyChinese(cv::Mat input, float& out, bool& isChinese) {
-  cv::Mat feature = charFeatures(input, kChineseSize);
-  float maxVal = -2;
-  int result = 0;
-
-  cv::Mat output(1, kChineseNumber, CV_32FC1);
-  annChinese_->predict(feature, output);
 
-  for (int j = 0; j < kChineseNumber; j++) {
-    float val = output.at<float>(j);
-    //std::cout << "j:" << j << "val:" << val << std::endl;
-    if (val > maxVal) {
-      maxVal = val;
-      result = j;
+  // 用于处理一组输入的图像数据并识别出对应的字符和省份。
+  // 函数参数包括输入图像数据（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);
     }
-  }
-
-  // no match
-  if (-1 == result) {
-    result = 0;
-    maxVal = 0;
-    isChinese = false;
-  }
-  else if (maxVal > 0.9){
-    isChinese = true;
-  }
-
-  auto index = result + kCharsTotalNumber - kChineseNumber;
-  const char* key = kChars[index];
-  std::string s = key;
-  std::string province = kv_->get(s);
-  out = maxVal;
 
-  return std::make_pair(s, province);
-}
-
-std::pair<std::string, std::string> CharsIdentify::identifyChineseGray(cv::Mat input, float& out, bool& isChinese) {
-  cv::Mat feature;
-  extractFeature(input, feature);
-  float maxVal = -2;
-  int result = 0;
-  cv::Mat output(1, kChineseNumber, CV_32FC1);
-  annGray_->predict(feature, output);
-
-  for (int j = 0; j < kChineseNumber; j++) {
-    float val = output.at<float>(j);
-    //std::cout << "j:" << j << "val:" << val << std::endl;
-    if (val > maxVal) {
-      maxVal = val;
-      result = j;
-    }
-  }
-  // no match
-  if (-1 == result) {
-    result = 0;
-    maxVal = 0;
-    isChinese = false;
-  } else if (maxVal > 0.9){
-    isChinese = true;
-  }
-  auto index = result + kCharsTotalNumber - kChineseNumber;
-  const char* key = kChars[index];
-  std::string s = key;
-  std::string province = kv_->get(s);
-  out = maxVal;
-  return std::make_pair(s, province);
-}
-
-
-std::pair<std::string, std::string> CharsIdentify::identify(cv::Mat input, bool isChinese, bool isAlphabet) {
-  cv::Mat feature = charFeatures(input, kPredictSize);
-  float maxVal = -2;
-  auto index = static_cast<int>(classify(feature, maxVal, isChinese, isAlphabet));
-  if (index < kCharactersNumber) {
-    return std::make_pair(kChars[index], kChars[index]);
-  }
-  else {
-    const char* key = kChars[index];
-    std::string s = key;
-    std::string province = kv_->get(s);
-    return std::make_pair(s, province);
-  }
-}
-
-int CharsIdentify::identify(std::vector<cv::Mat> inputs, std::vector<std::pair<std::string, std::string>>& outputs,
-                            std::vector<bool> isChineseVec) {
-  Mat featureRows;
-  size_t input_size = inputs.size();
-  for (size_t i = 0; i < input_size; i++) {
-    Mat input = inputs[i];
-    cv::Mat feature = charFeatures(input, kPredictSize);
-    featureRows.push_back(feature);
-  }
-
-  std::vector<int> maxIndexs;
-  std::vector<float> maxVals;
-  classify(featureRows, maxIndexs, maxVals, isChineseVec);
-
-  for (size_t row_index = 0; row_index < input_size; row_index++) {
-    int index = maxIndexs[row_index];
-    if (index < kCharactersNumber) {
-      outputs[row_index] = std::make_pair(kChars[index], kChars[index]);
-    }
-    else {
-      const char* key = kChars[index];
-      std::string s = key;
-      std::string province = kv_->get(s);
-      outputs[row_index] = std::make_pair(s, province);
+    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);
+      }
     }
+    return 0;
   }
-  return 0;
-}
 }

src/src/core/params.cpp

@@ -9,4 +9,5 @@ namespace easypr {
     }
     return instance_;
   }
-}/*! \namespace easypr*/
+}/*! \namespace easypr*/
+//这段代码是一个单例模式的实现。CParams类的instance_成员变量被初始化为nullptr，然后instance()函数用来获取CParams类的唯一实例。如果instance_为空，就会创建一个新的实例并返回，否则直接返回现有的实例。这样可以确保在程序运行期间只有一个CParams类的实例存在。

src/src/core/plate_detect.cpp

@@ -11,7 +11,7 @@ namespace easypr {
     m_type = 0;
     m_showDetect = false;
   }
-
+// 这段代码是CPlateDetect类的构造函数，初始化了一些成员变量，包括m_plateLocate指针、m_maxPlates、m_type和m_showDetect。
   CPlateDetect::~CPlateDetect() { SAFE_RELEASE(m_plateLocate); }
 
   int CPlateDetect::plateDetect(Mat src, std::vector<CPlate> &resultVec, int type,
@@ -24,6 +24,11 @@ namespace easypr {
     mser_Plates.reserve(16);
     std::vector<CPlate> all_result_Plates;
     all_result_Plates.reserve(64);
+    // 这部分代码定义了CPlateDetect类的析构函数和plateDetect方法。
+// 在plateDetect方法中，使用了OpenMP并行处理来同时进行Sobel、颜色和MSER三种车牌定位方法。
+// 最后使用NMS（非极大值抑制）来判断车牌，并返回结果。
+// plateDetect方法还有一个重载版本，其中showDetectArea参数为false。
+// LoadSVM方法用于加载SVM模型。
 #pragma omp parallel sections
     {
 #pragma omp section
@@ -32,12 +37,16 @@ namespace easypr {
           m_plateLocate->plateSobelLocate(src, sobel_Plates, img_index);
         }
       }
+      // 这部分代码使用了OpenMP并行处理来进行Sobel车牌定位方法。
+// 如果type为0或者包含PR_DETECT_SOBEL标志位，则调用m_plateLocate的plateSobelLocate方法。
+// plateSobelLocate方法用于进行Sobel算子定位车牌。
 #pragma omp section
       {
         if (!type || type & PR_DETECT_COLOR) {
           m_plateLocate->plateColorLocate(src, color_Plates, img_index);
         }
       }
+      //这段代码是使用OpenMP并行处理来调用m_plateLocate的plateColorLocate方法，用于进行颜色定位车牌。根据type参数的值，判断是否需要进行颜色定位
 #pragma omp section
       {
         if (!type || type & PR_DETECT_CMSER) {
@@ -64,7 +73,11 @@ namespace easypr {
       showDectectResults(src, resultVec, m_maxPlates);
     return 0;
   }
-
+// 这部分代码是CPlateDetect类的plateDetect方法的一部分。
+// 首先通过OpenMP并行处理调用plateMserLocate方法来进行MSER车牌定位。
+// 然后将定位结果分别设置为对应的类型（SOBEL、COLOR、CMSER）并存入all_result_Plates中。
+// 最后使用NMS（非极大值抑制）来判断车牌，并将结果存入resultVec中。
+// 代码中的if (0)条件语句似乎没有实际作用，可能需要进一步确认其意图。
   int CPlateDetect::plateDetect(Mat src, std::vector<CPlate> &resultVec, int img_index) {
     int result = plateDetect(src, resultVec, m_type, false, img_index);
     return result;
@@ -74,4 +87,6 @@ namespace easypr {
     PlateJudge::instance()->LoadModel(path);
   }
 
-}
+}
+// 这段代码中的plateDetect方法是CPlateDetect类的成员函数，用于调用另一个重载版本的plateDetect方法，并返回结果。
+// LoadSVM方法用于加载SVM模型，其中调用了PlateJudge类的LoadModel方法。

src/src/core/plate_judge.cpp

@@ -1,46 +1,52 @@
+//该代码主要用于车牌识别。它定义了一个名为PlateJudge的类，该类包含了一系列用于车牌识别的方法。
+
 #include "easypr/core/plate_judge.h"
 #include "easypr/config.h"
 #include "easypr/core/core_func.h"
 #include "easypr/core/params.h"
 
-namespace easypr {
-
+namespace easypr { //这部分代码实现了单例模式，确保PlateJudge类只有一个实例
+//定义了一个静态成员变量instance_，它是PlateJudge类的指针，初始化为nullptr。这是单例模式的关键，所有的PlateJudge实例都将共享这个变量
   PlateJudge* PlateJudge::instance_ = nullptr;
 
-  PlateJudge* PlateJudge::instance() {
-    if (!instance_) {
-      instance_ = new PlateJudge;
+
+//确保PlateJudge类只有一个实例，当需要使用PlateJudge类时，只需要调用PlateJudge::instance()即可获取到这个唯一的实例
+  PlateJudge* PlateJudge::instance() { //定义了一个静态成员函数instance()，它返回一个指向PlateJudge实例的指针
+    if (!instance_) { //检查instance_是否为nullptr
+      instance_ = new PlateJudge; //如果是，那么就创建一个新的PlateJudge实例，并将instance_设置为指向这个新创建的实例
     }
-    return instance_;
+    return instance_; //返回instance_，即指向PlateJudge实例的指针
   }
 
-  PlateJudge::PlateJudge() { 
-    bool useLBP = false;
-    if (useLBP) {
-      LOAD_SVM_MODEL(svm_, kLBPSvmPath);
-      extractFeature = getLBPFeatures;
+  PlateJudge::PlateJudge() { //PlateJudge决定了使用哪种特征提取方法
+    bool useLBP = false; //定义一个布尔变量useLBP，并初始化为false
+    if (useLBP) { //如果useLBP为true，即使用LBP特征提取方法
+      LOAD_SVM_MODEL(svm_, kLBPSvmPath); //加载LBP的SVM模型
+      extractFeature = getLBPFeatures; //设置特征提取函数为getLBPFeatures
     }
-    else {
-      LOAD_SVM_MODEL(svm_, kHistSvmPath);
-      extractFeature = getHistomPlusColoFeatures;
+    else { //如果useLBP为false，即使用直方图特征提取方法
+      LOAD_SVM_MODEL(svm_, kHistSvmPath); //加载直方图的SVM模型
+      extractFeature = getHistomPlusColoFeatures; //设置特征提取函数为getHistomPlusColoFeatures
     }
   }
 
-  void PlateJudge::LoadModel(std::string path) {
-    if (path != std::string(kDefaultSvmPath)) {
-      if (!svm_->empty())
-        svm_->clear();
-      LOAD_SVM_MODEL(svm_, path);
+  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模型文件的路径
     }
   }
 
   // set the score of plate
   // 0 is plate, -1 is not.
-  int PlateJudge::plateSetScore(CPlate& plate) {
-    Mat features;
-    extractFeature(plate.getPlateMat(), features);
-    float score = svm_->predict(features, noArray(), cv::ml::StatModel::Flags::RAW_OUTPUT);
+  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中
     //std::cout << "score:" << score << std::endl;
+
+//这是一个调试用的代码块，如果条件为真（此处为0，所以不会执行），则显示车牌图像，等待用户按键，然后销毁窗口
     if (0) {
       imshow("plate", plate.getPlateMat());
       waitKey(0);
@@ -49,67 +55,82 @@ namespace easypr {
     // 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;
+    if (score < 0.5) return 0; //如果评分小于0.5，返回0，表示这是一个车牌；否则返回-1，表示这不是一个车牌
     else return -1;      
   }
 
-  int PlateJudge::plateJudge(const Mat& plateMat) {
-    CPlate plate;
-    plate.setPlateMat(plateMat);
-    return plateSetScore(plate);
+//定义了一个名为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对象进行评分，然后返回评分结果
   }
 
-  int PlateJudge::plateJudge(const std::vector<Mat> &inVec,
-    std::vector<Mat> &resultVec) {
-    int num = inVec.size();
-    for (int j = 0; j < num; j++) {
-      Mat inMat = inVec[j];
+  int PlateJudge::plateJudge(const std::vector<Mat> &inVec, //inVec是输入的图像向量，resultVec是输出的结果向量。
+    std::vector<Mat> &resultVec) { //对inVec中的每一张图像进行车牌判断。如果判断结果为车牌（即plateJudge(inMat)的返回值为0），则将该图像添加到resultVec中。
+    int num = inVec.size(); // 获取输入图像的数量
+    for (int j = 0; j < num; j++) { // 遍历每一张图像
+      Mat inMat = inVec[j]; // 获取当前图像
 
       int response = -1;
-      response = plateJudge(inMat);
+      response = plateJudge(inMat);  // 对当前图像进行车牌判断
 
-      if (response == 0) resultVec.push_back(inMat);
+      if (response == 0) resultVec.push_back(inMat);  // 如果判断结果为车牌，将该图像添加到结果向量中
     }
-    return 0;
+    return 0; // 返回0，表示执行成功
   }
 
-  int PlateJudge::plateJudge(const std::vector<CPlate> &inVec,
-    std::vector<CPlate> &resultVec) {
-    int num = inVec.size();
-    for (int j = 0; j < num; j++) {
-      CPlate inPlate = inVec[j];
+//属于PlateJudge类，用于判断输入的车牌向量中哪些是有效的车牌。这个方法的输入是一个CPlate对象的向量inVec，输出是一个有效车牌的CPlate对象的向量resultVec。
+  int PlateJudge::plateJudge(const std::vector<CPlate> &inVec, 
+    std::vector<CPlate> &resultVec) { //接收两个参数：一个CPlate对象的向量inVec（输入的车牌向量）和一个CPlate对象的向量resultVec（输出的有效车牌向量）。
+    int num = inVec.size(); // 获取输入向量的大小
+    for (int j = 0; j < num; j++) { //遍历输入向量中的每一个元素
+
+//获取当前的CPlate对象和它的车牌图像
+      CPlate inPlate = inVec[j]; 
       Mat inMat = inPlate.getPlateMat();
+
+//调用plateJudge方法判断当前的车牌图像是否有效，结果存储在response中
       int response = -1;
       response = plateJudge(inMat);
 
+//如果当前的车牌图像有效（response等于0），则将当前的CPlate对象添加到结果向量中
       if (response == 0)
         resultVec.push_back(inPlate);
+//如果当前的车牌图像无效，那么对车牌图像进行裁剪和调整大小
       else {
         int w = inMat.cols;
         int h = inMat.rows;
         Mat tmpmat = inMat(Rect_<double>(w * 0.05, h * 0.1, w * 0.9, h * 0.8));
         Mat tmpDes = inMat.clone();
         resize(tmpmat, tmpDes, Size(inMat.size()));
-
+//再次调用plateJudge方法判断调整后的车牌图像是否有效，如果有效则将当前的CPlate对象添加到结果向量中
         response = plateJudge(tmpDes);
         if (response == 0) resultVec.push_back(inPlate);
       }
     }
-    return 0;
+    return 0; //结束循环并返回0，表示方法执行成功
   }
 
-  // non-maximum suppression
-  void NMS(std::vector<CPlate> &inVec, std::vector<CPlate> &resultVec, double overlap) {
-    std::sort(inVec.begin(), inVec.end());
+  // non-maximum suppression -->非极大值抑制
+//函数接收三个参数：一个CPlate对象的向量inVec（输入的车牌向量），一个CPlate对象的向量resultVec（输出的车牌向量），以及一个double类型的overlap（重叠阈值）
+  void NMS(std::vector<CPlate> &inVec, std::vector<CPlate> &resultVec, double overlap) { //NMS函数实现了非极大值抑制，用于消除重叠的车牌。
+    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);
@@ -119,19 +140,23 @@ namespace easypr {
         }
       }
     }
-    resultVec = inVec;
+    resultVec = inVec; //最后，将处理后的车牌向量赋值给输出的车牌向量
   }
 
-  // judge plate using nms
-  int PlateJudge::plateJudgeUsingNMS(const std::vector<CPlate> &inVec, std::vector<CPlate> &resultVec, int maxPlates) {
-    std::vector<CPlate> plateVec;
-    int num = inVec.size();
-    bool useCascadeJudge = true;
+  // judge plate using nms --> 使用非极大值抑制进行车牌识别
+// 定义了一个名为plateJudgeUsingNMS的成员函数，它属于PlateJudge类。该函数使用非极大值抑制进行车牌识别，接收一个CPlate对象的向量inVec（输入的车牌向量）、一个CPlate对象的向量resultVec（输出的车牌向量）和一个整数maxPlates（最大车牌数量）作为参数
+  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; // 定义一个布尔变量，表示是否使用级联判断
 
+// 遍历输入向量中的每一个元素
     for (int j = 0; j < num; j++) {
-      CPlate plate = inVec[j];
-      Mat inMat = plate.getPlateMat();
-      int result = plateSetScore(plate);
+      CPlate plate = inVec[j]; // 获取当前的CPlate对象
+      Mat inMat = plate.getPlateMat();  // 获取当前CPlate对象的车牌图像
+      int result = plateSetScore(plate); // 对当前的CPlate对象进行评分
+
+// 如果评分结果为0，表示这是一个车牌
       if (0 == result) {
         if (0) {
           imshow("inMat", inMat);
@@ -139,17 +164,22 @@ namespace easypr {
           destroyWindow("inMat");
         }
 
-        if (plate.getPlateLocateType() == CMSER) {
-          int w = inMat.cols;
-          int h = inMat.rows;
+        if (plate.getPlateLocateType() == CMSER) { // 如果plate的定位类型为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);
+          Mat tmpDes = inMat.clone(); // 克隆图像
+          resize(tmpmat, tmpDes, Size(inMat.size())); // 调整图像大小
+          plate.setPlateMat(tmpDes); // 设置plate的车牌图像为调整后的图像
+
+	// 如果使用级联判断
           if (useCascadeJudge) {
-            int resultCascade = plateSetScore(plate);
+            int resultCascade = plateSetScore(plate); // 对调整后的图像进行评分
+	// 如果plate的定位类型不是CMSER，将plate的车牌图像设置为原图像
             if (plate.getPlateLocateType() != CMSER)
               plate.setPlateMat(inMat);
+	// 如果级联评分结果为0，将plate添加到plateVec中
             if (resultCascade == 0) {
               if (0) {
                 imshow("tmpDes", tmpDes);
@@ -159,22 +189,24 @@ namespace easypr {
               plateVec.push_back(plate);
             }
           }
-          else 
+          else // 如果不使用级联判断，直接将plate添加到plateVec中
             plateVec.push_back(plate);
         }
-        else 
+        else // 如果plate的定位类型不是CMSER，直接将plate添加到plateVec中
           plateVec.push_back(plate);                  
       }
     }
 
-    std::vector<CPlate> reDupPlateVec;
-    double overlap = 0.5;
+    std::vector<CPlate> reDupPlateVec; // 创建一个CPlate对象的向量，用于存储非极大值抑制后的结果
+    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
+    // sort the plates due to their scores --> 根据评分对reDupPlateVec进行排序
     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) {
@@ -188,6 +220,6 @@ namespace easypr {
       if (count >= maxPlates)
         break;
     }
-    return 0;
+    return 0;  // 返回0，表示函数执行成功
   }
 }

src/src/core/plate_recognize.cpp

@@ -7,7 +7,10 @@ namespace easypr {
 CPlateRecognize::CPlateRecognize() { 
   m_showResult = false;
 }
-
+// 这段代码是C++中的类定义，定义了CPlateRecognize类的构造函数，初始化了m_showResult成员变量为false。
+// 该类包含plateRecognize方法，用于车牌识别，包括车牌检测和字符识别两部分。
+// 还包含了一些Load方法，用于加载模型文件。
+// 代码中使用了OpenCV库中的Mat类和一些自定义的类和方法。
 
 // main method, plate recognize, contain two parts
 // 1. plate detect
@@ -19,10 +22,11 @@ int CPlateRecognize::plateRecognize(const Mat& src, std::vector<CPlate> &plateVe
 
   // 1. plate detect
   std::vector<CPlate> plateVec;
-  //车牌检测
   int resultPD = plateDetect(img, plateVec, img_index);
+  // 这段代码是C++中的类方法CPlateRecognize::plateRecognize的一部分，用于车牌识别。
+// 首先对输入图像进行统一尺寸的调整，然后进行车牌检测，将结果存储在plateVec中。
+// 返回值resultPD表示车牌检测的结果，0表示成功，非0表示失败。
   if (resultPD == 0) {
-    //显示车牌图像（如果启用）。
     size_t num = plateVec.size();
     for (size_t j = 0; j < num; j++) {
       CPlate& item = plateVec.at(j);
@@ -30,14 +34,17 @@ int CPlateRecognize::plateRecognize(const Mat& src, std::vector<CPlate> &plateVe
       SHOW_IMAGE(plateMat, 0);
 
       // scale the rect to src;
-      //依比例缩放检测到的车牌矩形位置。
       item.setPlateScale(scale);
       RotatedRect rect = item.getPlatePos();
       item.setPlatePos(scaleBackRRect(rect, 1.f / scale));
-
+// 如果车牌检测成功（resultPD == 0），则对每个检测到的车牌进行处理：
+// 1. 获取车牌图像并显示
+// 2. 调整车牌位置和大小
+// 3. 获取车牌颜色并识别字符
+// 4. 将识别结果存储，并根据识别结果设置车牌字符串
+// 5. 根据显示类型展示检测结果或识别结果
       // get plate color
       Color color = item.getPlateColor();
-      //获得车牌颜色，并将其设置为车牌对象的属性。
       if (color == UNKNOWN) {
         color = getPlateType(plateMat, true);
         item.setPlateColor(color);
@@ -46,17 +53,16 @@ int CPlateRecognize::plateRecognize(const Mat& src, std::vector<CPlate> &plateVe
       if (0) {
         std::cout << "plateColor:" << plateColor << std::endl;
       }
-
+// 这段代码用于获取车牌颜色并进行处理。
+// 首先获取车牌颜色，如果颜色为UNKNOWN，则调用getPlateType方法获取颜色并设置到item中。
+// 然后将颜色转换为字符串形式并存储在plateColor中。
+// 最后，通过条件判断，如果条件为0，则输出plateColor到控制台。
       // 2. chars recognize
       std::string plateIdentify = "";
-      //字符识别
-      //调用 charsRecognise 方法进行字符识别，
-      //并将结果附加到车牌颜色字符串前以形成最终的车牌字符串。
       int resultCR = charsRecognise(item, plateIdentify);
       if (resultCR == 0) {
         std::string license = plateColor + ":" + plateIdentify;
         item.setPlateStr(license);
-        //将含有识别字符串的车牌对象 item 添加到输出向量 plateVecOut 中。
         plateVecOut.push_back(item);
         if (0) std::cout << "resultCR:" << resultCR << std::endl;
       }
@@ -67,6 +73,11 @@ int CPlateRecognize::plateRecognize(const Mat& src, std::vector<CPlate> &plateVe
         if (0) std::cout << "resultCR:" << resultCR << std::endl;
       }
     }
+    // 这段代码是C++中的类方法CPlateRecognize::plateRecognize的一部分，用于字符识别。
+// 首先定义了一个空字符串plateIdentify，并调用charsRecognise方法进行字符识别，结果存储在resultCR中。
+// 如果resultCR为0，则将plateColor和plateIdentify拼接成license字符串，并设置到item中，然后将item存入plateVecOut中。
+// 否则，只将plateColor设置到license字符串中，然后将item存入plateVecOut中。
+// 最后，根据条件判断，如果条件为0，则输出resultCR到控制台。
     if (getResultShow()) {
       // param type: 0 detect, 1 recognize;
       int showType = 1;
@@ -78,28 +89,36 @@ int CPlateRecognize::plateRecognize(const Mat& src, std::vector<CPlate> &plateVe
   }
   return resultPD;
 }
-//加载支持向量机(SVM)模型，用于车牌判断。
+// 这段代码是C++中的类方法CPlateRecognize::plateRecognize的一部分，用于根据getResultShow()的返回值决定是否展示检测结果或识别结果。
+// 如果getResultShow()返回true，则根据showType的值选择展示检测结果或识别结果。
+// 最后返回resultPD，表示车牌检测的结果。
 void CPlateRecognize::LoadSVM(std::string path) {
   PlateJudge::instance()->LoadModel(path);
 }
-//加载人工神经网络(ANN)模型，用于字符识别。
+
 void CPlateRecognize::LoadANN(std::string path) {
   CharsIdentify::instance()->LoadModel(path);
 }
-//加载用于中文字符识别的ANN模型。
+// 评注该代码
+
+// 这部分代码定义了CPlateRecognize类的两个方法：LoadSVM和LoadANN。
+// LoadSVM方法用于加载SVM模型，调用PlateJudge类的实例的LoadModel方法加载模型。
+// LoadANN方法用于加载ANN模型，调用CharsIdentify类的实例的LoadModel方法加载模型。
+// 这些方法用于在车牌识别过程中加载相关的机器学习模型。
 void CPlateRecognize::LoadChineseANN(std::string path) {
   CharsIdentify::instance()->LoadChineseModel(path);
 }
-//加载用于灰度中文字符识别的ANN模型。
 
 void CPlateRecognize::LoadGrayChANN(std::string path) {
   CharsIdentify::instance()->LoadGrayChANN(path);
 }
-// 加载中文字符映射表
+
 void CPlateRecognize::LoadChineseMapping(std::string path) {
   CharsIdentify::instance()->LoadChineseMapping(path);
 }
-
+// 这部分代码定义了CPlateRecognize类的三个方法：LoadChineseANN、LoadGrayChANN和LoadChineseMapping。
+// 这些方法用于在字符识别过程中加载相关的中文字符识别模型和映射文件。
+// 分别调用CharsIdentify类的实例的LoadChineseModel、LoadGrayChANN和LoadChineseMapping方法加载模型和映射文件。
 // deprected
 int CPlateRecognize::plateRecognize(const Mat& src, std::vector<std::string> &licenseVec) {
   vector<CPlate> plates;
@@ -111,4 +130,8 @@ int CPlateRecognize::plateRecognize(const Mat& src, std::vector<std::string> &li
   return resultPR;
 }
 
-}
+}
+// 这段代码定义了CPlateRecognize类的一个新方法plateRecognize，接受一个输入图像和一个字符串向量作为参数。
+// 在方法内部，首先创建了一个CPlate类型的向量plates，并调用了原有的plateRecognize方法来进行车牌识别。
+// 然后遍历plates向量中的每个车牌，将其车牌字符串存入传入的licenseVec向量中。
+// 最后返回了车牌识别的结果resultPR。

src/src/train/annCh_train.cpp

@@ -1,187 +1,257 @@
-#include <numeric>
-#include <ctime>
-
-#include "easypr/train/annCh_train.h"
-#include "easypr/config.h"
-#include "easypr/core/chars_identify.h"
-#include "easypr/core/feature.h"
-#include "easypr/core/core_func.h"
-#include "easypr/util/util.h"
-#include "easypr/train/create_data.h"
-
-namespace easypr {
-
-  AnnChTrain::AnnChTrain(const char* chars_folder, const char* xml)
-    : chars_folder_(chars_folder), ann_xml_(xml)
-  {
-  ann_ = cv::ml::ANN_MLP::create();
-  type = 1;
-  kv_ = std::shared_ptr<Kv>(new Kv);
-  kv_->load("resources/text/province_mapping");
-  extractFeature = getGrayPlusProject;
-}
-
-  void AnnChTrain::train()
-  {
-    int classNumber = 0;
-    int input_number = 0;
-    int hidden_number = 0;
-    int output_number = 0;
-
-    bool useLBP = false;
-    if (useLBP)
-      input_number = kCharLBPPatterns * kCharLBPGridX * kCharLBPGridY;
-    else
-      input_number = kGrayCharHeight * kGrayCharWidth;
-
-    input_number += 64;
-
-  classNumber = kChineseNumber;
-  hidden_number = kCharHiddenNeurans;
-  output_number = classNumber;
-  cv::Mat layers;
-
-    int first_hidden_neurons = 48;
-    int second_hidden_neurons = 32;
-
-    int N = input_number;
-    int m = output_number;
-    //int first_hidden_neurons = int(std::sqrt((m + 2) * N) + 2 * std::sqrt(N / (m + 2)));
-    //int second_hidden_neurons = int(m * std::sqrt(N / (m + 2)));
-
-    bool useTLFN = false;
-    if (!useTLFN) {
-      layers.create(1, 3, CV_32SC1);
-      layers.at<int>(0) = input_number;
-      layers.at<int>(1) = hidden_number;
-      layers.at<int>(2) = output_number;
-    }
-    else {
-      fprintf(stdout, ">> Use two-layers neural networks,\n");
-      fprintf(stdout, ">> First_hidden_neurons: %d \n", first_hidden_neurons);
-      fprintf(stdout, ">> Second_hidden_neurons: %d \n", second_hidden_neurons);
-
-      layers.create(1, 4, CV_32SC1);
-      layers.at<int>(0) = input_number;
-      layers.at<int>(1) = first_hidden_neurons;
-      layers.at<int>(2) = second_hidden_neurons;
-      layers.at<int>(3) = output_number;
-    }
-
-  ann_->setLayerSizes(layers);
-  ann_->setActivationFunction(cv::ml::ANN_MLP::SIGMOID_SYM, 1, 1);
-  ann_->setTrainMethod(cv::ml::ANN_MLP::TrainingMethods::BACKPROP);
-  ann_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 30000, 0.0001));
-  ann_->setBackpropWeightScale(0.1);
-  ann_->setBackpropMomentumScale(0.1);
-
-  auto files = Utils::getFiles(chars_folder_);
-  if (files.size() == 0) {
-    fprintf(stdout, "No file found in the train folder!\n");
-    fprintf(stdout, "You should create a folder named \"tmp\" in EasyPR main folder.\n");
-    fprintf(stdout, "Copy train data folder(like \"annCh\") under \"tmp\". \n");
-    return;
+#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函数，用于特征提取  
   }
-
-  // using raw data or raw + synthic data.
-  trainVal(m_number_for_count);
+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，可能是为了增加一些额外的输入节点  
 }
 
-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);
+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::test() {
-    //TODO
+// 设置神经网络层的大小  
+ann_->setLayerSizes(layers);  
+  
+// 设置激活函数为Sigmoid函数，其对称性取决于第二个参数，第三个参数是该函数的斜率  
+ann_->setActivationFunction(cv::ml::ANN_MLP::SIGMOID_SYM, 1, 1);  
+  
+// 设置训练方法为反向传播法  
+ann_->setTrainMethod(cv::ml::ANN_MLP::TrainingMethods::BACKPROP);  
+  
+// 设置训练终止条件为最大迭代次数30000次，或当误差小于0.0001时终止  
+ann_->setTermCriteria(cvTermCriteria(CV_TERMCRIT_ITER, 30000, 0.0001));  
+  
+// 设置权重的更新比例因子为0.1  
+ann_->setBackpropWeightScale(0.1);  
+  
+// 设置权重的动量更新比例因子为0.1  
+ann_->setBackpropMomentumScale(0.1);  
+  
+// 获取文件夹中的文件列表，如果文件列表为空，则打印错误信息并给出建议  
+auto files = Utils::getFiles(chars_folder_);  
+if (files.size() == 0) {  
+  fprintf(stdout, "No file found in the train folder!\n");  
+  fprintf(stdout, "You should create a folder named \"tmp\" in EasyPR main folder.\n");  
+  fprintf(stdout, "Copy train data folder(like \"annCh\") under \"tmp\". \n");  
+  return;  
+}  
+  
+// 使用原始数据或原始数据 + 合成的数据进行训练和验证，具体数量由 m_number_for_count 决定  
+trainVal(m_number_for_count);
+
+// 定义一个方法，用于识别汉字  
+// 参数：输入图像  
+// 返回值：一个由汉字字符串和对应的省份字符串组成的pair  
+std::pair<std::string, std::string> AnnChTrain::identifyGrayChinese(cv::Mat input) {  
+  // 定义特征向量  
+  Mat feature;  
+  // 从输入图像中提取特征  
+  extractFeature(input, feature);  
+  // 初始化最大值为-2  
+  float maxVal = -2;  
+  // 初始化结果为0  
+  int result = 0;  
+  
+  // 定义输出矩阵，大小为1行，kChineseNumber列，数据类型为CV_32FC1（32位浮点型）  
+  cv::Mat output(1, kChineseNumber, CV_32FC1);  
+  // 使用神经网络模型进行预测，输入特征向量，输出结果到output矩阵中  
+  ann_->predict(feature, output);  
+  
+  // 遍历输出矩阵中的每一个值  
+  for (int j = 0; j < kChineseNumber; j++) {  
+    // 获取当前位置的值  
+    float val = output.at<float>(j);  
+    // 如果当前值大于maxVal，则更新maxVal和result的值  
+    //std::cout << "j:" << j << "val:" << val << std::endl;  
+    if (val > maxVal) {  
+      maxVal = val;  
+      result = j;  
+    }  
+  }  
+  
+  // 根据result的值计算索引index，注意这里进行了偏移操作，可能是因为字符集的索引与输出结果的索引之间存在偏移  
+  auto index = result + kCharsTotalNumber - kChineseNumber;  
+  // 根据索引获取对应的字符key  
+  const char* key = kChars[index];  
+  // 将字符key转换为字符串s  
+  std::string s = key;  
+  // 通过kv_（应该是某个键值对容器）获取与s对应的省份字符串，存储到province变量中  
+  std::string province = kv_->get(s);  
+  
+  // 返回一个由字符s和省份province组成的pair对象  
+  return std::make_pair(s, province);  
+}  
+  
+// 定义一个方法，用于测试模型性能（目前为空）  
+void AnnChTrain::test() {  
+  // TODO: 需要实现测试代码，评估模型的性能指标，如准确率、召回率等。  
+}  
+  
+// 定义一个方法，用于训练验证集（目前为空）  
+void AnnChTrain::trainVal(size_t number_for_count) {  
+  // 断言chars_folder_不为空，否则会抛出异常（TODO: 需要实现断言失败的处理逻辑）  
+  assert(chars_folder_);  
+  // 定义训练样本的存储容器train_samples（TODO: 这里需要解释这个变量名和变量的具体含义）  
+  cv::Mat train_samples;  
+  // 定义训练图像、验证图像的存储容器（TODO: 这里需要解释这些变量名和变量的具体含义）  
+  std::vector<cv::Mat>  train_images, val_images;  
+  std::vector<int> train_label, val_labels;  
+  // 设置训练验证集分割比例为0.7（70%用于训练，30%用于验证）  
+  float percentage = 0.7f;  
+  // 设置类别数为kChineseNumber（TODO: 需要解释这个变量的具体含义）直接把代码改成评注形式
+
+// 循环遍历每个字符类别  
+for (int i = 0; i < classNumber; ++i) {   
+  // 从kChars数组中获取当前字符的键  
+  auto char_key = kChars[i + kCharsTotalNumber - classNumber];  
+  // 定义一个字符数组sub_folder，用于存储子文件夹的路径，并初始化为0  
+  char sub_folder[512] = { 0 };  
+  // 使用sprintf函数将字符键和字符文件夹路径拼接，存入sub_folder  
+  sprintf(sub_folder, "%s/%s", chars_folder_, char_key);  
+  // 将字符键转化为字符串类型，方便后续操作  
+  std::string test_char(char_key);  
+  // 如果test_char不等于"zh_yun"，则跳过当前循环  
+  // if (test_char != "zh_yun") continue;  
+  fprintf(stdout, ">> Testing characters %s in %s \n", char_key, sub_folder);  
+  // 调用utils::getFiles函数获取子文件夹下的所有文件，存入chars_files  
+  auto chars_files = utils::getFiles(sub_folder);  
+  // 获取子文件夹下的文件数量  
+  size_t char_size = chars_files.size();  
+  fprintf(stdout, ">> Characters count: %d \n", (int)char_size);  
+  
+  // 定义一个向量matVec，用于存储处理过的图像  
+  std::vector<cv::Mat> matVec;  
+  // 为matVec预留空间，提高性能  
+  matVec.reserve(number_for_count);  
+  // 内层循环，遍历子文件夹下的每一个文件  
+  for (auto file : chars_files) {  
+    std::cout << file << std::endl;  
+    // 使用OpenCV的imread函数读取图像，并将其转化为灰度图像  
+    auto img = cv::imread(file, IMREAD_GRAYSCALE);  // a grayscale image   
+    Mat img_resize;  
+    // 为img_resize分配空间，并设置其大小和数据类型  
+    img_resize.create(kGrayCharHeight, kGrayCharWidth, CV_8UC1);  
+    // 使用OpenCV的resize函数调整图像大小  
+    resize(img, img_resize, img_resize.size(), 0, 0, INTER_LINEAR);  
+    // 将调整大小后的图像存入matVec  
+    matVec.push_back(img_resize);  
+  }  
+}
+// 生成合成图像  
+// genrate the synthetic images  
+for (int t = 0; t < (int)number_for_count - (int)char_size; t++) {  
+  // 确定随机数的范围  
+  int rand_range = char_size + t;  
+  // 生成一个随机数  
+  int ran_num = rand() % rand_range;  
+  // 从matVec中获取一个图像  
+  auto img = matVec.at(ran_num);  
+  // 显示该图像  
+  SHOW_IMAGE(img, 0);  
+  // 生成合成图像  
+  auto simg = generateSyntheticImage(img);  
+  // 显示合成图像  
+  SHOW_IMAGE(simg, 0);  
+  // 将合成图像添加到matVec中  
+  matVec.push_back(simg);  
+}  
+// 输出matVec的大小  
+fprintf(stdout, ">> Characters count: %d \n", (int)matVec.size());  
+  
+// 对matVec进行随机排序  
+// random sort the mat;  
+srand(unsigned(time(NULL)));  
+random_shuffle(matVec.begin(), matVec.end());  
+  
+// 获取matVec的大小  
+int mat_size = (int)matVec.size();  
+// 计算分割索引  
+int split_index = int((float)mat_size * percentage);  
+// 从后往前遍历matVec  
+for (int j = mat_size - 1; j >= 0; j--) {  
+  // 从matVec中获取图像  
+  Mat img = matVec.at(j);  
+  // 此处代码可能有误，因为该判断语句始终为真，无法起到分割训练集和验证集的作用  
+  // 应该根据split_index来分割训练集和验证集  
+  if (1) {  
+    Mat feature;  
+    // 提取图像特征  
+    extractFeature(img, feature);  
+    if (j <= split_index) {  
+      // 将特征和图像添加到训练样本和训练图像中  
+      train_samples.push_back(feature);  
+      train_images.push_back(img);  
+      train_label.push_back(i);  
+    }  
+    else {  
+      // 将图像添加到验证图像中，将标签添加到验证标签中  
+      val_images.push_back(img);  
+      val_labels.push_back(i);  
+    }  
+  }  
 }
-
-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/ann_train.cpp

@@ -21,6 +21,10 @@ AnnTrain::AnnTrain(const char* chars_folder, const char* xml)
   kv_->load("resources/text/province_mapping");
 }
 
+// 这段代码是C++的类成员函数AnnTrain::AnnTrain的构造函数实现。
+// 构造函数接受两个参数chars_folder和xml，并将其分别赋值给成员变量chars_folder_和ann_xml_。
+// 然后使用cv::ml::ANN_MLP::create()创建了一个神经网络对象ann_。
+// type被初始化为0，kv_被初始化为一个加载了"resources/text/province_mapping"的Kv对象。
 void AnnTrain::train() {
   
   int classNumber = 0;
@@ -45,7 +49,9 @@ void AnnTrain::train() {
     hidden_number = kNeurons;
     output_number = classNumber;
   }
-
+// 这段代码是AnnTrain类的train方法，根据type的值选择不同的classNumber、input_number、hidden_number和output_number。
+// 当type为0时，classNumber为kCharsTotalNumber，input_number为kAnnInput，hidden_number为kNeurons，output_number为classNumber。
+// 当type为1时，classNumber为kChineseNumber，input_number为kAnnInput，hidden_number为kNeurons，output_number为classNumber。
   int N = input_number;
   int m = output_number;
   int first_hidden_neurons = int(std::sqrt((m + 2) * N) + 2 * std::sqrt(N / (m + 2)));
@@ -70,7 +76,9 @@ void AnnTrain::train() {
     layers.at<int>(2) = second_hidden_neurons;
     layers.at<int>(3) = output_number;
   }
-
+//这段代码根据输入和输出的数量计算了两个隐藏层的神经元数量，
+//并根据布尔变量useTLFN的值选择了创建三层或四层的神经网络层。如果useTLFN为false，则创建三层，否则创建四层。
+//在创建四层时，输出了两个隐藏层的神经元数量。
   ann_->setLayerSizes(layers);
   ann_->setActivationFunction(cv::ml::ANN_MLP::SIGMOID_SYM, 1, 1);
   ann_->setTrainMethod(cv::ml::ANN_MLP::TrainingMethods::BACKPROP);
@@ -99,7 +107,11 @@ void AnnTrain::train() {
   std::cout << "Your ANN Model was saved to " << ann_xml_ << std::endl;
   std::cout << "Training done. Time elapse: " << (end - start) / (1000 * 60) << "minute" << std::endl;
 }
-
+//这段代码是一个C++类成员函数AnnTrain::train的实现。
+//在这段代码中，神经网络ann_被训练并保存到ann_xml_文件中。
+//训练数据通过sdata(350)函数获取，然后使用ann_->train(traindata)进行训练。
+//训练完成后，会输出"Your ANN Model was saved to "以及训练所花费的时间。
+//同时，还会调用test()函数进行测试。如果训练文件夹中没有文件，则会输出相应的提示信息。
 std::pair<std::string, std::string> AnnTrain::identifyChinese(cv::Mat input) {
   cv::Mat feature = charFeatures2(input, kPredictSize);
   float maxVal = -2;
@@ -124,7 +136,10 @@ std::pair<std::string, std::string> AnnTrain::identifyChinese(cv::Mat input) {
 
   return std::make_pair(s, province);
 }
-
+// 这段代码是AnnTrain类的identifyChinese方法，接受一个cv::Mat类型的输入参数input。
+// 首先调用charFeatures2函数提取特征，然后使用神经网络ann_对特征进行预测，得到输出output。
+// 接着遍历output，找到最大值对应的索引result，并计算出最终的索引index。
+// 最后根据index获取对应的字符key，再通过kv_获取对应的省份province，最终返回一个包含字符和省份的pair。
 
 std::pair<std::string, std::string> AnnTrain::identify(cv::Mat input) {
   cv::Mat feature = charFeatures2(input, kPredictSize);
@@ -155,7 +170,10 @@ std::pair<std::string, std::string> AnnTrain::identify(cv::Mat input) {
     return std::make_pair(s, province);
   }
 }
-
+// 这段代码是AnnTrain类的identify方法，接受一个cv::Mat类型的输入参数input。
+// 首先调用charFeatures2函数提取特征，然后使用神经网络ann_对特征进行预测，得到输出output。
+// 接着遍历output，找到最大值对应的索引result，并计算出最终的索引index。
+// 最后根据index判断返回的字符和省份信息，返回一个包含字符和省份的pair。
 void AnnTrain::test() {
   assert(chars_folder_);
 
@@ -175,7 +193,10 @@ void AnnTrain::test() {
     auto chars_files = utils::getFiles(sub_folder);
     int corrects = 0, sum = 0;
     std::vector<std::pair<std::string, std::string>> error_files;
-
+// 这段代码是AnnTrain类的test方法，用于测试字符识别的准确率。
+// 首先根据type的值确定classNumber，然后遍历每个字符的文件夹进行测试。
+// 在测试过程中，会统计正确识别的字符数量和总测试字符数量，以及每个字符的识别准确率。
+// 最后输出总的测试结果和平均准确率。
     for (auto file : chars_files) {
       auto img = cv::imread(file, 0);  // a grayscale image
       if (!img.data) {
@@ -196,6 +217,11 @@ void AnnTrain::test() {
       ++sum;
       ++sum_all;
     }
+// 这段代码是一个循环，遍历chars_files中的文件，对每个文件进行处理。
+// 首先使用OpenCV的imread函数读取文件为灰度图像img，然后判断img是否为空。
+// 如果type为0，则调用identify函数对图像进行识别，否则调用identifyChinese函数。
+// 如果识别结果与char_key相同，则将corrects和corrects_all加一，否则将错误信息加入error_files。
+// 最后将sum和sum_all加一。
     float rate = (float)corrects / (sum == 0 ? 1 : sum);
     fprintf(stdout, ">>   [sum: %d, correct: %d, rate: %.2f]\n", sum, corrects, rate);
     rate_list.push_back(rate);
@@ -217,6 +243,10 @@ void AnnTrain::test() {
     }
     fprintf(stdout, ">>   [\n%s\n     ]\n", error_string.c_str());
   }
+// 这段代码计算了识别准确率，并输出了每个字符的识别结果和错误信息。
+// 首先计算了识别准确率rate，并将其加入rate_list中。
+// 然后构建了错误信息字符串error_string，遍历error_files并将错误信息添加到字符串中。
+// 最后使用fprintf输出了总的识别结果和错误信息。
   fprintf(stdout, ">>   [sum_all: %d, correct_all: %d, rate: %.4f]\n", sum_all, corrects_all,
     (float)corrects_all / (sum_all == 0 ? 1 : sum_all));
 
@@ -226,6 +256,8 @@ void AnnTrain::test() {
   fprintf(stdout, ">>   [classNumber: %d, avg_rate: %.4f]\n", classNumber, rate_mean);
 }
 
+// 这段代码用于输出总的测试结果和平均准确率。
+// 首先输出总的测试结果和准确率，然后计算了每个字符的识别准确率的平均值并输出。
 cv::Mat getSyntheticImage(const Mat& image) {
   int rand_type = rand();
   Mat result = image.clone();
@@ -244,7 +276,11 @@ cv::Mat getSyntheticImage(const Mat& image) {
   
   return result;
 }
-
+// 该代码定义了一个函数getSyntheticImage，接受一个cv::Mat类型的参数image。
+//首先生成一个随机数rand_type，然后将result初始化为image的克隆。
+//如果rand_type为偶数，则生成两个随机数ran_x和ran_y，然后调用translateImg函数对result进行平移操作。
+// 如果rand_type为奇数，则生成一个随机角度angle，然后调用rotateImg函数对result进行旋转操作。
+// 最后返回result。
 cv::Ptr<cv::ml::TrainData> AnnTrain::sdata(size_t number_for_count) {
   assert(chars_folder_);
 
@@ -256,6 +292,9 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::sdata(size_t number_for_count) {
   if (type == 1) classNumber = kChineseNumber;
   
   srand((unsigned)time(0));
+  // 这段代码是AnnTrain类的sdata方法，用于生成训练数据。
+// 首先检查chars_folder_是否存在，然后初始化samples和labels。
+// 根据type的值确定classNumber，然后使用srand函数初始化随机数种子。
   for (int i = 0; i < classNumber; ++i) {
    
     auto char_key = kChars[i + kCharsTotalNumber - classNumber];
@@ -274,7 +313,11 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::sdata(size_t number_for_count) {
       auto img = cv::imread(file, 0);  // a grayscale image
       matVec.push_back(img);
     }
-
+// 这段代码是一个循环，遍历每个字符文件夹中的文件，并将文件读取为灰度图像后存入matVec中。
+// 首先根据循环变量i计算出当前字符的关键字char_key，并构建对应的子文件夹路径sub_folder。
+// 然后使用utils::getFiles函数获取子文件夹中的文件列表chars_files，并统计文件数量char_size。
+// 接着初始化了一个存储灰度图像的向量matVec，并预留了number_for_count个元素的空间。
+// 遍历chars_files，使用cv::imread函数读取文件为灰度图像img，并将其存入matVec中。
     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;
@@ -287,7 +330,10 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::sdata(size_t number_for_count) {
         imwrite(ss.str(), simg);
       }
     }
-
+// 这段代码是一个循环，用于生成合成图像并保存到文件中。
+// 首先循环变量t从0到number_for_count - char_size，然后生成一个随机数ran_num。
+// 接着从matVec中获取对应索引的图像img，并调用getSyntheticImage函数生成合成图像simg。
+// 将simg添加到matVec中，并使用imwrite函数将simg保存为文件。
     fprintf(stdout, ">> Characters count: %d \n", (int)matVec.size());
 
     for (auto img : matVec) {
@@ -297,7 +343,8 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::sdata(size_t number_for_count) {
       labels.push_back(i);
     }
   } 
-
+// 这段代码用于统计字符数量并将特征和标签添加到训练数据中。
+// 首先使用fprintf输出字符数量，然后遍历matVec中的图像，对每个图像提取特征并将特征和标签添加到训练数据中。
   cv::Mat samples_;
   samples.convertTo(samples_, CV_32F);
   cv::Mat train_classes =
@@ -310,7 +357,10 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::sdata(size_t number_for_count) {
   return cv::ml::TrainData::create(samples_, cv::ml::SampleTypes::ROW_SAMPLE,
     train_classes);
 }
-
+// 该部分代码是AnnTrain类的tdata方法，用于生成训练数据。
+// 首先将samples转换为CV_32F类型的samples_，然后初始化train_classes为全零矩阵。
+// 接着遍历train_classes的每一行，将对应位置的值设为1。
+// 最后使用cv::ml::TrainData::create函数创建并返回训练数据对象。
 cv::Ptr<cv::ml::TrainData> AnnTrain::tdata() {
   assert(chars_folder_);
 
@@ -322,7 +372,9 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::tdata() {
   int classNumber = 0;
   if (type == 0) classNumber = kCharsTotalNumber;
   if (type == 1) classNumber = kChineseNumber;
-
+// 这段代码是AnnTrain类的tdata方法，用于生成训练数据。
+// 首先检查chars_folder_是否存在，然后初始化samples和labels。
+// 根据type的值确定classNumber。
   for (int i = 0; i < classNumber; ++i) {
     auto char_key = kChars[i + kCharsTotalNumber - classNumber];
     char sub_folder[512] = {0};
@@ -340,7 +392,11 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::tdata() {
       labels.push_back(i);
     }
   }
-
+// 这段代码是一个循环，遍历每个字符文件夹中的文件，并将文件读取为灰度图像后提取特征并添加到训练数据中。
+// 首先根据循环变量i计算出当前字符的关键字char_key，并构建对应的子文件夹路径sub_folder。
+// 然后使用utils::getFiles函数获取子文件夹中的文件列表chars_files，并遍历每个文件。
+// 对每个文件使用cv::imread函数读取为灰度图像img，然后调用charFeatures2函数提取特征fps，并将其添加到samples中。
+// 同时将当前字符的标签i添加到labels中。
   cv::Mat samples_;
   samples.convertTo(samples_, CV_32F);
   cv::Mat train_classes =
@@ -354,3 +410,6 @@ cv::Ptr<cv::ml::TrainData> AnnTrain::tdata() {
                                    train_classes);
 }
 }
+// 该部分代码是用于生成训练数据的一部分，首先将samples转换为CV_32F类型的samples_，
+// 然后初始化train_classes为全零矩阵，接着遍历train_classes的每一行，将对应位置的值设为1。
+// 最后使用cv::ml::TrainData::create函数创建并返回训练数据对象。

src/src/train/create_data.cpp

@@ -7,7 +7,10 @@ namespace easypr {
     assert(img.type() == CV_8UC1);
     int w = img.cols;
     int h = img.rows;
-
+// 该部分代码定义了一个名为getBorderColor的函数，用于获取图像边界的颜色值
+// 函数首先确保输入图像是单通道灰度图像，然后获取图像的宽度和高度
+// 接下来通过遍历图像边界像素的方式计算边界颜色的平均值，并返回整数类型的平均值
+// 该文件还包含了一些其他图像处理函数，如平移、旋转、裁剪和生成合成图像的函数
     float sum = 0;
     for (int i = 0; i < h; ++i) {
       sum += img.at<unsigned char>(i, 0);
@@ -21,7 +24,9 @@ namespace easypr {
     float avg = sum / float(w + w + h + h);
     return int(avg);
   }
-
+// 该部分代码计算了图像边界像素的平均值作为边界颜色值，并返回整数类型的平均值
+// 首先对图像边界像素进行遍历，累加像素值到sum中
+// 然后计算平均值avg，并返回整数类型的平均值
   // shift an image
   Mat translateImg(Mat img, int offsetx, int offsety, int bk){
     Mat dst;
@@ -31,7 +36,12 @@ namespace easypr {
     warpAffine(img, dst, trans_mat, img.size(), 1, 0, Scalar(bk));
     return dst;
   }
-
+// 该部分代码定义了一个名为translateImg的函数，用于对图像进行平移操作
+// 函数接受输入图像img以及x和y方向的偏移量offsetx和offsety，以及背景颜色bk
+// 在函数内部，首先创建了一个空的目标图像dst
+// 然后定义了一个2x3的变换矩阵trans_mat，用于表示平移操作
+// 最后调用warpAffine函数对输入图像进行平移操作，并将结果存储在目标图像dst中
+// 最终返回平移后的目标图像dst
   // rotate an image
   Mat rotateImg(Mat source, float angle, int bk){
     Point2f src_center(source.cols / 2.0F, source.rows / 2.0F);
@@ -40,7 +50,12 @@ namespace easypr {
     warpAffine(source, dst, rot_mat, source.size(), 1, 0, Scalar(bk));
     return dst;
   }
-
+// 该部分代码定义了一个名为rotateImg的函数，用于对图像进行旋转操作
+// 函数接受输入图像source以及旋转角度angle和背景颜色bk作为参数
+// 在函数内部，首先计算了输入图像的中心点坐标src_center
+// 然后利用getRotationMatrix2D函数计算了旋转矩阵rot_mat
+// 最后调用warpAffine函数对输入图像进行旋转操作，并将结果存储在目标图像dst中
+// 最终返回旋转后的目标图像dst
   // crop the image
   Mat cropImg(Mat src, int x, int y, int shift, int bk){
     int width = src.cols;
@@ -61,7 +76,13 @@ namespace easypr {
     resize(dst, dst, Size(width, height));
     return dst;
   }
-
+// 该部分代码定义了一个名为cropImg的函数，用于对图像进行裁剪操作
+// 函数接受输入图像src以及裁剪起始点的x和y坐标，裁剪尺寸shift和背景颜色bk作为参数
+// 在函数内部，首先获取输入图像的宽度和高度
+// 然后计算裁剪后的图像宽度和高度
+// 接着根据裁剪起始点和裁剪尺寸计算裁剪区域的矩形rect
+// 将裁剪后的图像存储在目标图像dst中，并进行大小调整
+// 最终返回裁剪后的目标图像dst
   Mat generateSyntheticImage(const Mat& image, int use_swap) {
     int rd = rand();
     int bkColor = getBoderColor(image);
@@ -85,4 +106,10 @@ namespace easypr {
     return result;
   }
 }
-
+// 该部分代码定义了一个名为generateSyntheticImage的函数，用于生成合成图像
+// 函数接受输入图像image以及一个整数参数use_swap
+// 首先通过rand函数生成一个随机数rd
+// 然后调用getBorderColor函数获取输入图像的边界颜色值，并存储在bkColor中
+// 接着对输入图像进行克隆，存储在result中
+// 之后根据随机数rd的不同位进行裁剪、平移和旋转操作，并将结果存储在result中
+// 最终返回合成后的目标图像result

src/src/util/kv.cpp

@@ -1,81 +1,81 @@
-#include "easypr/util/kv.h"
-#include "easypr/util/util.h"
+#include "easypr/util/kv.h"  // 引入kv头文件
+#include "easypr/util/util.h"  // 引入util头文件
 
-namespace easypr {
+namespace easypr {  // 定义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;
-      std::getline(reader, line);
-      if (line.empty()) continue;
+  if (reader.is_open()) {  // 如果文件打开成功
+    while (!reader.eof()) {  // 当未到达文件末尾时
+      std::string line;  // 定义字符串变量line
+      std::getline(reader, line);  // 读取一行数据到line
+      if (line.empty()) continue;  // 如果line为空，则跳过本次循环
 
-      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());
+    v = utils::utf8_to_gbk(value.c_str());());  // 如果是Windows系统，将值转换为gbk编码
 #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,423 +3,429 @@
 namespace program_options {
 
 // class ParseError
-
-ParseError::ParseError(const std::string& msg) : _msg(msg) {}
-
-const char* ParseError::what() const throw() {
-  std::string msg;
-  msg.append("Command line parse error: ").append(_msg).push_back('.');
-  return msg.c_str();
+//定义了一个名为ParseError的类
+//ParseError类是一个用于处理命令行解析错误的异常类。
+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() throw() {}
+ParseError::~ParseError() throw() {}// 是ParseError类的析构函数
 
 // class Generator
-
-Generator::Generator() : parser_(nullptr) {
-  current_subroutine_ = Subroutine::get_default_name();
-  add_subroutine(current_subroutine_.c_str());
+//定义了一个名为Generator的类，该类用于生成和管理命令行选项解析器和子程序。
+Generator::Generator() : parser_(nullptr) {//Generator类的构造函数
+  current_subroutine_ = Subroutine::get_default_name();//初始化parser_为nullptr，设置当前子程序为默认子程序
+  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;
+      delete it->second;//它删除所有的子程序，
+      it->second = nullptr;//并将parser_和所有的子程序设置为nullptr。
     }
   }
 }
 
-Generator& Generator::make_usage(const char* first_line) {
-  get_subroutine()->set_first_line(first_line);
-  return *this;
+Generator& Generator::make_usage(const char* first_line) {//是一个成员函数
+  get_subroutine()->set_first_line(first_line);//它设置当前子程序的第一行
+  return *this;//并返回this指针。
 }
 
-Parser* Generator::make_parser() {
+Parser* Generator::make_parser() {//是一个成员函数
   if (parser_) delete parser_;
-  parser_ = new Parser;
-  parser_->set_usage_subroutines(&subroutines_);
-  return parser_;
+  parser_ = new Parser;//它创建一个新的Parser对象
+  parser_->set_usage_subroutines(&subroutines_);//设置其使用的子程序
+  return parser_;//并返回这个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);
+////设置其短选项、长选项、默认值和描述
+    get_subroutine()->add_usage_line(row);//将这个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->get_description();
-    if (!subroutine->get_usage().empty()) {
-      out << std::endl;
-    }
-    out << *subroutine;
+    out << *subroutine;//打印子程序的使用信息。
   }
   return out;
 }
 
 // class ParseItem
 
-ParseItem::ParseItem(const std::string& value) : value_(value) {}
+ParseItem::ParseItem(const std::string& value) : value_(value) {}//ParseItem 类的构造函数
+//它接受一个 std::string 类型的参数 value。在构造函数体中，将传入的 value 直接赋值给类的成员变量 value_。
+//这个构造函数用于创建一个 ParseItem 对象，并初始化其 value_ 成员变量。
 
 // class Parser
 
-ParseItem* Parser::get(const std::string& key) {
-  if (pr_->find(key) != pr_->end()) {
-    return (*pr_)[key];
+ParseItem* Parser::get(const std::string& key) {//Parser 类的 get 方法，它接受一个 std::string 类型的参数 key。
+  if (pr_->find(key) != pr_->end()) {//如果 key 在 pr_ 中存在
+    return (*pr_)[key];//那么返回对应的 ParseItem 指针
   }
-  return nullptr;
+  return nullptr;//返回 nullptr
 }
 
-Parser::Parser() : subroutines_(nullptr), pr_(nullptr) {}
-
+Parser::Parser() : subroutines_(nullptr), pr_(nullptr) {}//
+//Parser 类的构造函数，它使用初始化列表将 subroutines_ 和 pr_ 成员变量初始化为 nullptr。
 Parser::~Parser() { this->cleanup(); }
-
-Parser::ParseResult* Parser::parse(const int argc, const char** argv) {
-  if (!this->init(argc, argv)) {
-    return nullptr;
+//这是 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
   }
-  auto ibegin = args_.begin() + 1;  // ignore the first cmd name
+  auto ibegin = args_.begin() + 1;  // 忽略第一个命令名
   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++;  // ignore the subroutine name
+      it++;   // 忽略子程序名
     } else {
       subroutine_name_ = args_[1];
     }
   } else {
-    // there is no options as well as subroutine name
-    // e.g., ./exec
+    // 没有选项以及子程序名
+    // 例如，./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);
+  for (; it != iend; ++it) {// 遍历所有的命令行参数
+    block.assign(*it);// 将当前参数赋值给 block
 
-    switch (block.size()) {
-      case 1:
-        if (block == "-") {
-          throw ParseError("single '-' is not allowed");
+    switch (block.size()) {//// 根据 block 的大小进行不同的处理
+      case 1://// 如果 block 的大小为 1
+        if (block == "-") {//// 如果 block 是一个单独的 "-"
+          throw ParseError("single '-' is not allowed");//// 抛出异常，因为单独的 "-" 是不允许的
         }
         break;
-      case 2:
-        if (block[0] == '-') {
-          if (block[1] == '-') {
-            throw ParseError("option '--' is incomplete");
-          } else if (block[1] == '=') {
-            throw ParseError("option '-=' is invalid");
+      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");//// 抛出异常，因为 "-=" 是无效的选项
           } else {
-            // single option
+            // 单个选项
             // e.g., ./exec -s
             (*pr_)[block.substr(1)] = nullptr;
           }
         }
         break;
       default:  // >=3
-        if (block[0] == '-') {
-          if (block[1] == '-') {
-            size_t pos_equal = block.find('=');
-            if (pos_equal == std::string::npos) {
-              // a long format option
+        if (block[0] == '-') {//// 如果 block 的第一个字符是 "-"
+          if (block[1] == '-') {//// 如果 block 的第二个字符也是 "-"
+            size_t pos_equal = block.find('=');//// 查找 "=" 在 block 中的位置
+            if (pos_equal == std::string::npos) {//// 如果没有找到 "="
+              // 长格式选项
               // e.g., ./exec --option
-              (*pr_)[block.substr(2)] = nullptr;
+              (*pr_)[block.substr(2)] = nullptr;//// 将选项添加到 pr_ 中，值为 nullptr
             } else {
-              if (pos_equal > 3) {
+              if (pos_equal > 3) {// 如果 "=" 的位置大于 3
                 // e.g, ./exec --op[..=]value
-                std::string key(block.substr(2, pos_equal - 2));
-                if (block.size() > 5)
+                std::string key(block.substr(2, pos_equal - 2));// 获取选项名
+                if (block.size() > 5)//// 如果 block 的大小大于 5
                   // e.g, ./exec --op=v
-                  (*pr_)[key] = new ParseItem(block.substr(pos_equal + 1));
+                  (*pr_)[key] = new ParseItem(block.substr(pos_equal + 1));// 将选项和值添加到 pr_ 中
                 else
-                  (*pr_)[key] = nullptr;
+                  (*pr_)[key] = nullptr;// 将选项添加到 pr_ 中，值为 nullptr
               } else {
-                // a long format option but = is illegal
+                // 长格式选项但 = 是非法的
                 // e.g., ./exec --o=[...]
-                (*pr_)[block.substr(2)] = nullptr;
+                (*pr_)[block.substr(2)] = nullptr;//// 将选项添加到 pr_ 中，值为 nullptr
               }
             }
-          } else if (block[2] == '=') {
-            // a single option with =
+          } else if (block[2] == '=') {// // 如果 block 的第三个字符是 "="
+            // 单个选项带有 =
             // e.g., ./exec -o=[...]
             std::string key;
-            key.push_back(block[1]);
-            if (block.size() > 3)
-              (*pr_)[key] = new ParseItem(block.substr(3));
+            key.push_back(block[1]);// 获取选项名
+            if (block.size() > 3)// 如果 block 的大小大于 3
+              (*pr_)[key] = new ParseItem(block.substr(3));//// 将选项和值添加到 pr_ 中
             else
-              (*pr_)[key] = nullptr;
+              (*pr_)[key] = nullptr;// 将选项添加到 pr_ 中，值为 nullptr
           } else {
-            // a combination options
+            // 组合选项
             // e.g., ./exec -ab[...]
-            auto tbegin = block.begin() + 1;  // ignore the first '-'
+            auto tbegin = block.begin() + 1;  // 忽略第一个 '-'
             auto tend = block.end();
             auto t = tbegin;
 
-            for (; t != tend; ++t) {
+            for (; t != tend; ++t) { // 遍历 block 中的每个字符
               std::string key;
-              key.push_back(*t);
-              (*pr_)[key] = nullptr;
+              key.push_back(*t);// // 获取选项名
+              (*pr_)[key] = nullptr; // 将选项添加到 pr_ 中，值为 nullptr
             }
           }
         }
         break;
     }  // switch
 
-    if (block[0] != '-' && previous != block  // not the first option
+    if (block[0] != '-' && previous != block  // 如果 block 不是选项（不以 "-" 开头）并且不是第一个选项
         ) {
-      if (previous[0] != '-') {
-        // previous is not an option, error occur
+      if (previous[0] != '-') {//// 如果 previous 不是选项
+        // previous 不是一个选项，发生错误
         // 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] == '-') {
+      if (previous[0] == '-' && previous[1] == '-') {//// 如果 previous 是一个长格式选项
         // 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_)[key] = new ParseItem(block);
+      if (pr_->find(key) != pr_->end()) {//// 如果选项在 pr_ 中存在
+        (*pr_)[key] = new ParseItem(block); // 将选项和值添加到 pr_ 中
       }
     }
 
-    previous = block;
+    previous = block;//// 更新 previous 为当前的 block
   }  // for
 
   if (subroutines_) {
-    this->set_addition();
+    this->set_addition();// 如果存在子程序，调用 set_addition 方法处理额外的选项
   }
 
-  return pr_;
+  return pr_;//返回解析结果 pr_
 }
 
-Parser::ParseResult* Parser::parse(const char* command_line) {
-  int i = 0;
-  std::string block;
-  std::vector<std::string> blocks;
-  char c;
-  while ((c = command_line[i++]) != '\0') {
-    if (c != ' ') {
-      block.push_back(c);
+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
     } else {
-      if (!block.empty()) {
-        blocks.push_back(block);
+      if (!block.empty()) {// 如果 block 不为空
+        blocks.push_back(block);// 将 block 添加到 blocks
       }
-      block.clear();
+      block.clear();//清空 block
     }
   }
-  if (!block.empty()) {
-    blocks.push_back(block);
+  if (!block.empty()) {// 如果最后一个 block 不为空
+    blocks.push_back(block);// 将 block 添加到 blocks
   }
   size_t size = blocks.size();  // argc
-  char** argv = new char*[size];
+  char** argv = new char*[size];// 创建一个新的 char* 数组
   i = 0;
-  std::for_each(blocks.begin(), blocks.end(), [argv, &i](const std::string& b) {
-    argv[i++] = const_cast<char*>(b.c_str());
+  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 中
   });
   auto pr =
-      this->parse(static_cast<const int>(size), const_cast<const char**>(argv));
+      this->parse(static_cast<const int>(size), const_cast<const char**>(argv)); // 调用 parse 方法解析命令行参数
 
-  delete[] argv;
+  delete[] argv;// 删除 argv
   argv = nullptr;
 
-  return pr;
+  return pr;// 返回解析结果
 }
 
-bool Parser::has(const char* key) {
-  std::string skey(key);
+bool Parser::has(const char* key) {//Parser 类的 has 方法，它接受一个 char 指针 key，并检查 key 是否在 pr_ 中存在。
+  std::string skey(key);// 将 key 转换为 std::string
 
-  if (pr_ && !pr_->empty() && !skey.empty()) {
+  if (pr_ && !pr_->empty() && !skey.empty()) {//判断是否存在
     if (skey[0] == '-') {
-      // check combination options, e.g., Parser::has("-xyz")
-      for (size_t i = 1; i < skey.size(); ++i) {
+       // 如果 skey 是一个组合选项，例如 "-xyz"
+      for (size_t i = 1; i < skey.size(); ++i) {// 遍历 skey 的每个字符
         std::string tkey;
-        tkey.push_back(skey[i]);
-        if (pr_->find(tkey) == pr_->end()) {
+        tkey.push_back(skey[i]);// 获取选项名
+        if (pr_->find(tkey) == pr_->end()) { // 如果选项名在 pr_ 中不存在
           return false;
         }
       }
       return true;
     } else {
-      // check single option, e.g., Parser::has("x")
-      return pr_->find(skey) != pr_->end();
+      // 如果 skey 是一个单个选项，例如 "x"
+      return pr_->find(skey) != pr_->end();// 检查选项是否在 pr_ 中存在
     }
   }
-  return false;
+  return false;// 如果 pr_ 为空或 skey 为空，返回 false
 }
 
+//parser 类的 has_or 方法，它接受一个初始化列表 options，并检查 options 中的任何一个 key 是否在 pr_ 中存在。
 bool Parser::has_or(std::initializer_list<const char*> options) {
-  if (options.size() == 0) {
+  if (options.size() == 0) {// 如果 options 为空
     return false;
+  }4
+  for (auto key : options) {// 遍历 options 中的每个选项
+    if (this->has(key)) return true;// 如果选项在 pr_ 中存在，返回 true
   }
-  for (auto key : options) {
-    if (this->has(key)) return true;
-  }
-  return false;
+  return false;// 如果 options 中的所有选项都不存在，返回 false
 }
 
-bool Parser::has_and(std::initializer_list<const char*> options) {
-  if (options.size() == 0) {
+bool Parser::has_and(std::initializer_list<const char*> options) { // Parser 类的 has_and 方法，接受一个初始化列表 options
+  if (options.size() == 0) {// 如果 options 为空
     return false;
   }
-  for (auto key : options) {
-    if (!this->has(key)) return false;
+  for (auto key : options) {// 遍历 options 中的每个选项
+    if (!this->has(key)) return false;// 如果选项在 pr_ 中不存在，返回 false
   }
-  return true;
+  return true;// 如果 options 中的所有选项都存在，返回 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) {
-    this->cleanup();
+  if (argc > 0) {// 如果参数数量大于 0
+    this->cleanup(); // 清理之前的解析结果
+
 
-    args_.reserve(static_cast<size_t>(argc_));
+    args_.reserve(static_cast<size_t>(argc_));// 为 args_ 预留空间
 
-    for (int i = 0; i < argc_; ++i) {
-      args_.push_back(argv[i]);
+    for (int i = 0; i < argc_; ++i) {// 遍历所有的命令行参数
+      args_.push_back(argv[i]);// 将参数添加到 args_
     }
 
-    pr_ = new Parser::ParseResult;
+    pr_ = new Parser::ParseResult;// 创建新的解析结果
     return true;
   }
-  return false;
+  return false;// 如果参数数量为 0，返回 false
 }
 
-void Parser::cleanup() {
-  args_.clear();
-  if (pr_) {
+void Parser::cleanup() {// Parser 类的 cleanup 方法，用于清理解析结果
+  args_.clear();// 清空 args_
+  if (pr_) {// 如果 pr_ 不为空
     auto ibegin = pr_->begin();
     auto iend = pr_->end();
     auto it = ibegin;
-    for (; it != iend; ++it) {
+    for (; it != iend; ++it) {// 遍历 pr_ 中的每个元素
       ParseItem* item = it->second;
-      if (item) delete item;
+      if (item) delete item;// 删除元素
     }
-    delete pr_;
+    delete pr_;// 删除 pr_
     pr_ = nullptr;
   }
 }
 
-void Parser::set_addition() {
-  if (subroutines_->find(subroutine_name_) != subroutines_->end()) {
-    for (const Row& row : *(subroutines_->at(subroutine_name_))) {
+void Parser::set_addition() {// Parser 类的 set_addition 方法，用于处理额外的选项
+  if (subroutines_->find(subroutine_name_) != subroutines_->end()) {// 如果子程序名在 subroutines_ 中存在
+    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;
+            pr[opl] = nullptr;// 将长选项的值设为 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;
+            pr[ops] = nullptr;// 将短选项的值设为 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
@@ -427,114 +433,115 @@ void Parser::set_addition() {
 
 // class Row
 
-Row::Row() : require_value(true) {}
+Row::Row() : require_value(true) {} // Row 类的构造函数，初始化 require_value 为 true
 
 // class Subroutine
 
-Subroutine::Subroutine() : first_line_("") {}
+Subroutine::Subroutine() : first_line_("") {}// Subroutine 类的默认构造函数，初始化 first_line_ 为空字符串
 
 Subroutine::Subroutine(const char* name, const char* description)
-    : first_line_(""), description_(description), name_(name) {
-  usages_.reserve(5);
+    : first_line_(""), description_(description), name_(name) { // Subroutine 类的构造函数，接受子程序名和描述作为参数
+  usages_.reserve(5);// 为 usages_ 预留空间
 }
 
-void Subroutine::print_with_row(std::ostream& out) {
+void Subroutine::print_with_row(std::ostream& out) {// Subroutine 类的 print_with_row 方法，接受一个输出流作为参数
   // print the subroutine name and its description
-  if (strcmp(get_first_line(), "") != 0) {
+  // 打印子程序名和描述
+  if (strcmp(get_first_line(), "") != 0) {// 如果 first_line_ 不为空
     // print the first line
     out << get_first_line();
-    if (!usages_.empty()) {
-      out << std::endl;
+    if (!usages_.empty()) {// 如果 usages_ 不为空
+      out << std::endl;// 打印换行符
     }
   }
-  auto begin = usages_.begin();
-  auto end = usages_.end();
+  auto begin = usages_.begin(); // 获取 usages_ 的开始迭代器
+  auto end = usages_.end();// 获取 usages_ 的结束迭代器
 
-  std::vector<std::string> row_list;
-  row_list.reserve(usages_.size());
+  std::vector<std::string> row_list;// 创建一个字符串向量用于存储行
+  row_list.reserve(usages_.size());// 为 row_list 预留空间
 
   // build usage rows without description field,
   // find the max-len row at the same time.
   size_t max_len = 0;
-  std::for_each(begin, end, [&max_len, &row_list](const Row& row) {
-    std::stringstream ss;
-    ss << "  ";
-    if (!row.oshort().empty()) {
-      ss << "-" << row.oshort() << " ";
+  std::for_each(begin, end, [&max_len, &row_list](const Row& row) {// 遍历 usages_
+    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 ";
-      if (!row.value().empty()) {
-        ss << "= " << row.value() << " ";
+    if (row.required()) {// 如果选项是必需的
+      ss << "arg "; // 添加 "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()));
+    max_len = std::max(max_len, ss.str().size());// 更新最大长度
+    row_list.push_back(std::move(ss.str()));// 将字符串流的内容添加到 row_list
   });
 
   // show all rows and align description field
-  size_t row_count = usages_.size();
-  for (size_t i = 0; i < row_count; ++i) {
-    std::string str_row(std::move(row_list[i]));
+  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]));// 获取当前行
     // 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) {
-  for (auto usage : usages_) {
+void Subroutine::print_with_template(std::ostream& out) {// Subroutine 类的 print_with_template 方法，接受一个输出流作为参数
+  for (auto usage : usages_) {// 遍历 usages_
     size_t i = 0;
-    for (auto t = template_str_.begin(); t != template_str_.end(); ++t) {
-      if (*t == '%') {
-        switch (*(order_.begin() + i)) {
+    for (auto t = template_str_.begin(); t != template_str_.end(); ++t) {// 遍历模板字符串
+      if (*t == '%') {// 如果当前字符是 '%'
+        switch (*(order_.begin() + i)) { // 根据 order_ 中的值决定打印哪个字段
           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) {
-  if (subroutine.template_str_.empty()) {
-    subroutine.print_with_row(out);
+std::ostream& operator<<(std::ostream& out, Subroutine& subroutine) {// 重载 << 运算符，接受一个输出流和一个 Subroutine 对象作为参数
+  if (subroutine.template_str_.empty()) {// 如果模板字符串为空
+    subroutine.print_with_row(out);// 使用 print_with_row 方法打印
   } else {
-    subroutine.print_with_template(out);
+    subroutine.print_with_template(out);// 使用 print_with_template 方法打印
   }
-  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>
-#include <direct.h>
-#include <io.h>
-#define PATH_DELIMITER '\\'
+// #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 min
-#undef min
+#undef min  // 如果已经定义了min，取消其定义
 #endif
 
 #ifdef max
-#undef max
+#undef max  // 如果已经定义了max，取消其定义
 #endif
 #elif defined(OS_LINUX) || defined(OS_UNIX)
 
-#include <cstring>
-#include <dirent.h>
-#include <sys/stat.h>
-#include <unistd.h>
+#include <cstring>  // 包含cstring头文件，用于字符串操作
+#include <dirent.h>  // 包含dirent.h头文件，用于目录操作
+#include <sys/stat.h>  // 包含sys/stat.h头文件，用于文件状态检查
+#include <unistd.h>  // 包含unistd.h头文件，用于Unix标准的系统调用
 
-#define PATH_DELIMITER '/'
+#define PATH_DELIMITER '/'  // 定义路径分隔符为'/'
 #endif
 
 #ifdef OS_UNIX
 
-#include <sys/timeb.h>
+#include <sys/timeb.h>  // 包含sys/timeb.h头文件，用于时间操作
 
 #endif
 
-#include <list>
-#include <opencv2/highgui/highgui.hpp>
+#include <list>  // 包含list头文件，用于list数据结构
+#include <opencv2/highgui/highgui.hpp>  // 包含opencv的highgui模块，用于图像IO操作
 
-namespace easypr {
+namespace easypr {  // 定义easypr命名空间
 
-long Utils::getTimestamp() {
+long Utils::getTimestamp() {  // 定义获取时间戳的函数
 #ifdef OS_WINDOWS
-  return static_cast<long>(cv::getTickCount());
+  return static_cast<long>(cv::getTickCount());  // Windows平台下，使用opencv的getTickCount函数获取时间戳
 #endif
 
 #ifdef OS_LINUX
-  struct timespec ts;
+  struct timespec ts;  // 定义timespec结构体，用于获取时间
 
-  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;
-  ftime(&tb);
-  return long(tb.time * 1e3 + tb.millitm);
+  struct timeb tb;  // 定义timeb结构体，用于获取时间
+  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;
-  std::string s(str);
-  size_t pos;
+                                            const char delimiter) {  // 定义字符串分割函数
+  std::vector<std::string> splited;  // 定义存储分割结果的vector
+  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;
-  std::list<std::string> subfolders;
-  subfolders.push_back(folder);
+                                         const bool all /* = true */) {  // 定义获取文件列表的函数
+  std::vector<std::string> files;  // 定义存储文件列表的vector
+  std::list<std::string> subfolders;  // 定义存储子文件夹的list
+  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) {
-  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);
+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
   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