src change

Prj-Linux/hyperlpr/include/CNNRecognizer.h

@@ -0,0 +1,24 @@
+//
+// Created by Jack Yu on 21/10/2017.
+//
+
+#ifndef HYPERPR_CNNRECOGNIZER_H
+#define HYPERPR_CNNRECOGNIZER_H
+
+#include "Recognizer.h"
+namespace pr {
+class CNNRecognizer : public GeneralRecognizer {
+public:
+  const int CHAR_INPUT_W = 14;
+  const int CHAR_INPUT_H = 30;
+
+  CNNRecognizer(std::string prototxt, std::string caffemodel);
+  label recognizeCharacter(cv::Mat character);
+
+private:
+  cv::dnn::Net net;
+};
+
+} // namespace pr
+
+#endif // HYPERPR_CNNRECOGNIZER_H

Prj-Linux/hyperlpr/include/FastDeskew.h

@@ -0,0 +1,17 @@
+//
+// Created by Jack Yu on 22/09/2017.
+//
+
+#ifndef HYPERPR_FASTDESKEW_H
+#define HYPERPR_FASTDESKEW_H
+
+#include <math.h>
+#include <opencv2/opencv.hpp>
+namespace pr {
+
+cv::Mat fastdeskew(cv::Mat skewImage, int blockSize);
+//    cv::Mat spatialTransformer(cv::Mat skewImage);
+
+} // namespace pr
+
+#endif // HYPERPR_FASTDESKEW_H

Prj-Linux/hyperlpr/include/FineMapping.h

@@ -0,0 +1,29 @@
+//
+// Created by Jack Yu on 22/09/2017.
+//
+
+#ifndef HYPERPR_FINEMAPPING_H
+#define HYPERPR_FINEMAPPING_H
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/opencv.hpp>
+
+#include <string>
+namespace pr {
+class FineMapping {
+public:
+  FineMapping();
+
+  FineMapping(std::string prototxt, std::string caffemodel);
+  static cv::Mat FineMappingVertical(cv::Mat InputProposal, int sliceNum = 15,
+                                     int upper = 0, int lower = -50,
+                                     int windows_size = 17);
+  cv::Mat FineMappingHorizon(cv::Mat FinedVertical, int leftPadding,
+                             int rightPadding);
+
+private:
+  cv::dnn::Net net;
+};
+
+} // namespace pr
+#endif // HYPERPR_FINEMAPPING_H

Prj-Linux/hyperlpr/include/Pipeline.h

@@ -0,0 +1,54 @@
+//
+// Created by Jack Yu on 22/10/2017.
+//
+
+#ifndef HYPERPR_PIPLINE_H
+#define HYPERPR_PIPLINE_H
+
+#include "CNNRecognizer.h"
+#include "FastDeskew.h"
+#include "FineMapping.h"
+#include "PlateDetection.h"
+#include "PlateInfo.h"
+#include "PlateSegmentation.h"
+#include "Recognizer.h"
+#include "SegmentationFreeRecognizer.h"
+
+namespace pr {
+
+const std::vector<std::string> CH_PLATE_CODE{
+    "京", "沪", "津", "渝", "冀", "晋", "蒙", "辽", "吉", "黑", "苏", "浙",
+    "皖", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "桂", "琼", "川", "贵",
+    "云", "藏", "陕", "甘", "青", "宁", "新", "0",  "1",  "2",  "3",  "4",
+    "5",  "6",  "7",  "8",  "9",  "A",  "B",  "C",  "D",  "E",  "F",  "G",
+    "H",  "J",  "K",  "L",  "M",  "N",  "P",  "Q",  "R",  "S",  "T",  "U",
+    "V",  "W",  "X",  "Y",  "Z",  "港", "学", "使", "警", "澳", "挂", "军",
+    "北", "南", "广", "沈", "兰", "成", "济", "海", "民", "航", "空"};
+
+const int SEGMENTATION_FREE_METHOD = 0;
+const int SEGMENTATION_BASED_METHOD = 1;
+
+class PipelinePR {
+public:
+  GeneralRecognizer *generalRecognizer;
+  PlateDetection *plateDetection;
+  PlateSegmentation *plateSegmentation;
+  FineMapping *fineMapping;
+  SegmentationFreeRecognizer *segmentationFreeRecognizer;
+
+  PipelinePR(std::string detector_filename, std::string finemapping_prototxt,
+             std::string finemapping_caffemodel,
+             std::string segmentation_prototxt,
+             std::string segmentation_caffemodel,
+             std::string charRecognization_proto,
+             std::string charRecognization_caffemodel,
+             std::string segmentationfree_proto,
+             std::string segmentationfree_caffemodel);
+  ~PipelinePR();
+
+  std::vector<std::string> plateRes;
+  std::vector<PlateInfo> RunPiplineAsImage(cv::Mat plateImage, int method);
+};
+
+} // namespace pr
+#endif // HYPERPR_PIPLINE_H

Prj-Linux/hyperlpr/include/PlateDetection.h

@@ -0,0 +1,32 @@
+//
+// Created by Jack Yu on 20/09/2017.
+//
+
+#ifndef HYPERPR_PLATEDETECTION_H
+#define HYPERPR_PLATEDETECTION_H
+
+#include <PlateInfo.h>
+#include <opencv2/opencv.hpp>
+#include <vector>
+namespace pr {
+class PlateDetection {
+public:
+  PlateDetection(std::string filename_cascade);
+  PlateDetection();
+  void LoadModel(std::string filename_cascade);
+  void plateDetectionRough(cv::Mat InputImage,
+                           std::vector<pr::PlateInfo> &plateInfos,
+                           int min_w = 36, int max_w = 800);
+  //        std::vector<pr::PlateInfo> plateDetectionRough(cv::Mat
+  //        InputImage,int min_w= 60,int max_h = 400);
+
+  //        std::vector<pr::PlateInfo>
+  //        plateDetectionRoughByMultiScaleEdge(cv::Mat InputImage);
+
+private:
+  cv::CascadeClassifier cascade;
+};
+
+} // namespace pr
+
+#endif // HYPERPR_PLATEDETECTION_H

Prj-Linux/hyperlpr/include/PlateInfo.h

@@ -0,0 +1,94 @@
+//
+// Created by Jack Yu on 20/09/2017.
+//
+
+#ifndef HYPERPR_PLATEINFO_H
+#define HYPERPR_PLATEINFO_H
+#include <opencv2/opencv.hpp>
+namespace pr {
+
+typedef std::vector<cv::Mat> Character;
+
+enum PlateColor { BLUE, YELLOW, WHITE, GREEN, BLACK, UNKNOWN };
+enum CharType { CHINESE, LETTER, LETTER_NUMS, INVALID };
+
+class PlateInfo {
+public:
+  std::vector<std::pair<CharType, cv::Mat>> plateChars;
+  std::vector<std::pair<CharType, cv::Mat>> plateCoding;
+  float confidence = 0;
+  PlateInfo(const cv::Mat &plateData, std::string plateName, cv::Rect plateRect,
+            PlateColor plateType) {
+    licensePlate = plateData;
+    name = plateName;
+    ROI = plateRect;
+    Type = plateType;
+  }
+  PlateInfo(const cv::Mat &plateData, cv::Rect plateRect,
+            PlateColor plateType) {
+    licensePlate = plateData;
+    ROI = plateRect;
+    Type = plateType;
+  }
+  PlateInfo(const cv::Mat &plateData, cv::Rect plateRect) {
+    licensePlate = plateData;
+    ROI = plateRect;
+  }
+  PlateInfo() {}
+
+  cv::Mat getPlateImage() { return licensePlate; }
+
+  void setPlateImage(cv::Mat plateImage) { licensePlate = plateImage; }
+
+  cv::Rect getPlateRect() { return ROI; }
+
+  void setPlateRect(cv::Rect plateRect) { ROI = plateRect; }
+  cv::String getPlateName() { return name; }
+  void setPlateName(cv::String plateName) { name = plateName; }
+  int getPlateType() { return Type; }
+
+  void appendPlateChar(const std::pair<CharType, cv::Mat> &plateChar) {
+    plateChars.push_back(plateChar);
+  }
+
+  void appendPlateCoding(const std::pair<CharType, cv::Mat> &charProb) {
+    plateCoding.push_back(charProb);
+  }
+  std::string decodePlateNormal(std::vector<std::string> mappingTable) {
+    std::string decode;
+    for (auto plate : plateCoding) {
+      float *prob = (float *)plate.second.data;
+      if (plate.first == CHINESE) {
+        decode += mappingTable[std::max_element(prob, prob + 31) - prob];
+        confidence += *std::max_element(prob, prob + 31);
+      }
+
+      else if (plate.first == LETTER) {
+        decode += mappingTable[std::max_element(prob + 41, prob + 65) - prob];
+        confidence += *std::max_element(prob + 41, prob + 65);
+      }
+
+      else if (plate.first == LETTER_NUMS) {
+        decode += mappingTable[std::max_element(prob + 31, prob + 65) - prob];
+        confidence += *std::max_element(prob + 31, prob + 65);
+
+      } else if (plate.first == INVALID) {
+        decode += '*';
+      }
+    }
+    name = decode;
+
+    confidence /= 7;
+
+    return decode;
+  }
+
+private:
+  cv::Mat licensePlate;
+  cv::Rect ROI;
+  std::string name;
+  PlateColor Type;
+};
+} // namespace pr
+
+#endif // HYPERPR_PLATEINFO_H

Prj-Linux/hyperlpr/include/PlateSegmentation.h

@@ -0,0 +1,35 @@
+#ifndef HYPERPR_PLATESEGMENTATION_H
+#define HYPERPR_PLATESEGMENTATION_H
+
+#include "PlateInfo.h"
+#include "opencv2/opencv.hpp"
+#include <opencv2/dnn.hpp>
+
+namespace pr {
+
+class PlateSegmentation {
+public:
+  const int PLATE_NORMAL = 6;
+  const int PLATE_NORMAL_GREEN = 7;
+  const int DEFAULT_WIDTH = 20;
+  PlateSegmentation(std::string phototxt, std::string caffemodel);
+  PlateSegmentation() {}
+  void segmentPlatePipline(PlateInfo &plateInfo, int stride,
+                           std::vector<cv::Rect> &Char_rects);
+
+  void segmentPlateBySlidingWindows(cv::Mat &plateImage, int windowsWidth,
+                                    int stride, cv::Mat &respones);
+  void templateMatchFinding(const cv::Mat &respones, int windowsWidth,
+                            std::pair<float, std::vector<int>> &candidatePts);
+  void refineRegion(cv::Mat &plateImage, const std::vector<int> &candidatePts,
+                    const int padding, std::vector<cv::Rect> &rects);
+  void ExtractRegions(PlateInfo &plateInfo, std::vector<cv::Rect> &rects);
+  cv::Mat classifyResponse(const cv::Mat &cropped);
+
+private:
+  cv::dnn::Net net;
+};
+
+} // namespace pr
+
+#endif // HYPERPR_PLATESEGMENTATION_H

Prj-Linux/hyperlpr/include/Recognizer.h

@@ -0,0 +1,22 @@
+//
+// Created by Jack Yu on 20/10/2017.
+//
+
+#ifndef HYPERPR_RECOGNIZER_H
+#define HYPERPR_RECOGNIZER_H
+
+#include "PlateInfo.h"
+#include "opencv2/dnn.hpp"
+namespace pr {
+typedef cv::Mat label;
+class GeneralRecognizer {
+public:
+  virtual label recognizeCharacter(cv::Mat character) = 0;
+  //            virtual cv::Mat SegmentationFreeForSinglePlate(cv::Mat plate) =
+  //            0;
+  void SegmentBasedSequenceRecognition(PlateInfo &plateinfo);
+  void SegmentationFreeSequenceRecognition(PlateInfo &plateInfo);
+};
+
+} // namespace pr
+#endif // HYPERPR_RECOGNIZER_H

Prj-Linux/hyperlpr/include/SegmentationFreeRecognizer.h

@@ -0,0 +1,27 @@
+//
+// Created by Jack Yu on 28/11/2017.
+//
+
+#ifndef HYPERPR_SEGMENTATIONFREERECOGNIZER_H
+#define HYPERPR_SEGMENTATIONFREERECOGNIZER_H
+
+#include "Recognizer.h"
+namespace pr {
+
+class SegmentationFreeRecognizer {
+public:
+  const int CHAR_INPUT_W = 14;
+  const int CHAR_INPUT_H = 30;
+  const int CHAR_LEN = 84;
+
+  SegmentationFreeRecognizer(std::string prototxt, std::string caffemodel);
+  std::pair<std::string, float>
+  SegmentationFreeForSinglePlate(cv::Mat plate,
+                                 std::vector<std::string> mapping_table);
+
+private:
+  cv::dnn::Net net;
+};
+
+} // namespace pr
+#endif // HYPERPR_SEGMENTATIONFREERECOGNIZER_H

Prj-Linux/hyperlpr/include/niBlackThreshold.h

@@ -0,0 +1,105 @@
+//
+// Created by Jack Yu on 26/10/2017.
+//
+
+#ifndef HYPERPR_NIBLACKTHRESHOLD_H
+#define HYPERPR_NIBLACKTHRESHOLD_H
+
+#include <opencv2/opencv.hpp>
+using namespace cv;
+
+enum LocalBinarizationMethods {
+  BINARIZATION_NIBLACK =
+      0, //!< Classic Niblack binarization. See @cite Niblack1985 .
+  BINARIZATION_SAUVOLA = 1, //!< Sauvola's technique. See @cite Sauvola1997 .
+  BINARIZATION_WOLF = 2,    //!< Wolf's technique. See @cite Wolf2004 .
+  BINARIZATION_NICK = 3     //!< NICK technique. See @cite Khurshid2009 .
+};
+
+void niBlackThreshold(InputArray _src, OutputArray _dst, double maxValue,
+                      int type, int blockSize, double k,
+                      int binarizationMethod) {
+  // Input grayscale image
+  Mat src = _src.getMat();
+  CV_Assert(src.channels() == 1);
+  CV_Assert(blockSize % 2 == 1 && blockSize > 1);
+  if (binarizationMethod == BINARIZATION_SAUVOLA) {
+    CV_Assert(src.depth() == CV_8U);
+  }
+  type &= THRESH_MASK;
+  // Compute local threshold (T = mean + k * stddev)
+  // using mean and standard deviation in the neighborhood of each pixel
+  // (intermediate calculations are done with floating-point precision)
+  Mat test;
+  Mat thresh;
+  {
+    // note that: Var[X] = E[X^2] - E[X]^2
+    Mat mean, sqmean, variance, stddev, sqrtVarianceMeanSum;
+    double srcMin, stddevMax;
+    boxFilter(src, mean, CV_32F, Size(blockSize, blockSize), Point(-1, -1),
+              true, BORDER_REPLICATE);
+    sqrBoxFilter(src, sqmean, CV_32F, Size(blockSize, blockSize), Point(-1, -1),
+                 true, BORDER_REPLICATE);
+    variance = sqmean - mean.mul(mean);
+    sqrt(variance, stddev);
+    switch (binarizationMethod) {
+    case BINARIZATION_NIBLACK:
+      thresh = mean + stddev * static_cast<float>(k);
+
+      break;
+    case BINARIZATION_SAUVOLA:
+      thresh = mean.mul(1. + static_cast<float>(k) * (stddev / 128.0 - 1.));
+      break;
+    case BINARIZATION_WOLF:
+      minMaxIdx(src, &srcMin, NULL);
+      minMaxIdx(stddev, NULL, &stddevMax);
+      thresh =
+          mean - static_cast<float>(k) *
+                     (mean - srcMin - stddev.mul(mean - srcMin) / stddevMax);
+      break;
+    case BINARIZATION_NICK:
+      sqrt(variance + sqmean, sqrtVarianceMeanSum);
+      thresh = mean + static_cast<float>(k) * sqrtVarianceMeanSum;
+      break;
+    default:
+      CV_Error(CV_StsBadArg, "Unknown binarization method");
+      break;
+    }
+    thresh.convertTo(thresh, src.depth());
+
+    thresh.convertTo(test, src.depth());
+    //
+    //        cv::imshow("imagex",test);
+    //        cv::waitKey(0);
+  }
+  // Prepare output image
+  _dst.create(src.size(), src.type());
+  Mat dst = _dst.getMat();
+  CV_Assert(src.data != dst.data); // no inplace processing
+  // Apply thresholding: ( pixel > threshold ) ? foreground : background
+  Mat mask;
+  switch (type) {
+  case THRESH_BINARY:     // dst = (src > thresh) ? maxval : 0
+  case THRESH_BINARY_INV: // dst = (src > thresh) ? 0 : maxval
+    compare(src, thresh, mask, (type == THRESH_BINARY ? CMP_GT : CMP_LE));
+    dst.setTo(0);
+    dst.setTo(maxValue, mask);
+    break;
+  case THRESH_TRUNC: // dst = (src > thresh) ? thresh : src
+    compare(src, thresh, mask, CMP_GT);
+    src.copyTo(dst);
+    thresh.copyTo(dst, mask);
+    break;
+  case THRESH_TOZERO:     // dst = (src > thresh) ? src : 0
+  case THRESH_TOZERO_INV: // dst = (src > thresh) ? 0 : src
+    compare(src, thresh, mask, (type == THRESH_TOZERO ? CMP_GT : CMP_LE));
+    dst.setTo(0);
+    src.copyTo(dst, mask);
+    break;
+  default:
+    CV_Error(CV_StsBadArg, "Unknown threshold type");
+    break;
+  }
+}
+
+#endif // HYPERPR_NIBLACKTHRESHOLD_H