Merge branch 'dev2' of http://bdgit.educoder.net/p86743915/pp6hrvtlm into master

easypr/core/CharsIdentify.java

@@ -0,0 +1,83 @@
+package com.yuxue.easypr.core;
+
+import org.bytedeco.javacpp.opencv_core;
+import org.bytedeco.javacpp.opencv_core.Mat;
+import org.bytedeco.javacpp.opencv_ml.ANN_MLP;
+
+import com.yuxue.constant.Constant;
+import com.yuxue.util.Convert;
+
+
+/**
+ * 字符检测
+ * @author yuxue
+ * @date 2020-04-24 15:31
+ */
+public class CharsIdentify {
+
+    private ANN_MLP ann=ANN_MLP.create();
+
+    public CharsIdentify() {
+        loadModel(Constant.DEFAULT_ANN_PATH);
+    }
+
+    public void loadModel(String path) {
+        this.ann.clear();
+        // 加载ann配置文件  图像转文字的训练库文件
+        //ann=ANN_MLP.loadANN_MLP(path, "ann"); 
+        ann = ANN_MLP.load(path);
+    }
+    
+
+    /**
+     * @param input
+     * @param isChinese
+     * @return
+     */
+    public String charsIdentify(final Mat input, final Boolean isChinese, final Boolean isSpeci) {
+        String result = "";
+        
+        /*String name = "D:/PlateDetect/train/chars_recognise_ann/" + System.currentTimeMillis() + ".jpg";
+        opencv_imgcodecs.imwrite(name, input);
+        Mat img = opencv_imgcodecs.imread(name);
+        Mat f = CoreFunc.features(img, Constant.predictSize);*/
+        
+        Mat f = CoreFunc.features(input, Constant.predictSize);
+
+        int index = this.classify(f, isChinese, isSpeci);
+        
+        System.err.print(index);
+        if (index < Constant.numCharacter) {
+            result = String.valueOf(Constant.strCharacters[index]);
+        } else {
+            String s = Constant.strChinese[index - Constant.numCharacter];
+            result = Constant.KEY_CHINESE_MAP.get(s);   // 编码转中文
+        }
+        System.err.println(result);
+        return result;
+    }
+    
+    private int classify(final Mat f, final Boolean isChinses, final Boolean isSpeci) {
+        int result = -1;
+        
+        Mat output = new Mat(1, 140, opencv_core.CV_32F);
+
+        ann.predict(f, output, 0);  // 预测结果
+
+        int ann_min = (!isChinses) ? ((isSpeci) ? 10 : 0) : Constant.numCharacter;
+        int ann_max = (!isChinses) ? Constant.numCharacter : Constant.numAll;
+
+        float maxVal = -2;
+
+        for (int j = ann_min; j < ann_max; j++) {
+            float val = Convert.toFloat(output.ptr(0, j));
+            if (val > maxVal) {
+                maxVal = val;
+                result = j;
+            }
+        }
+        return result;
+    }
+
+
+}

easypr/core/CharsRecognise.java

@@ -0,0 +1,136 @@
+package com.yuxue.easypr.core;
+
+import java.util.Vector;
+
+import org.bytedeco.javacpp.opencv_core.Mat;
+
+import com.yuxue.enumtype.PlateColor;
+
+/**
+ * 字符识别
+ * 
+ * @author yuxue
+ * @date 2020-04-24 15:31
+ */
+public class CharsRecognise {
+    
+    private CharsSegment charsSegment = new CharsSegment();
+
+    private CharsIdentify charsIdentify = new CharsIdentify();
+    
+
+    public void loadANN(final String s) {
+        charsIdentify.loadModel(s);
+    }
+
+    /**
+     * Chars segment and identify 字符分割与识别
+     * 
+     * @param plate： the input plate
+     * @return the result of plate recognition
+     */
+    public String charsRecognise(final Mat plate, String tempPath) {
+
+        // 车牌字符方块集合
+        Vector<Mat> matVec = new Vector<Mat>();
+        // 车牌识别结果
+        String plateIdentify = "";
+
+        int result = charsSegment.charsSegment(plate, matVec, tempPath);
+        if (0 == result) {
+            for (int j = 0; j < matVec.size(); j++) {
+                Mat charMat = matVec.get(j);
+                // 默认首个字符块是中文字符   第二个字符块是字母
+                String charcater = charsIdentify.charsIdentify(charMat, (0 == j), (1 == j));
+                plateIdentify = plateIdentify + charcater;
+            }
+        }
+
+        return plateIdentify;
+    }
+
+    /**
+     * 是否开启调试模式
+     * 
+     * @param isDebug
+     */
+    public void setCRDebug(final boolean isDebug) {
+        charsSegment.setDebug(isDebug);
+    }
+
+    /**
+     * 获取调试模式状态
+     * 
+     * @return
+     */
+    public boolean getCRDebug() {
+        return charsSegment.getDebug();
+    }
+
+    /**
+     * 获得车牌颜色
+     * 
+     * @param input
+     * @return
+     */
+    public final String getPlateType(final Mat input) {
+        PlateColor result = CoreFunc.getPlateType(input, true);
+        return result.desc;
+    }
+
+    /**
+     * 设置柳丁大小变量
+     * 
+     * @param param
+     */
+    public void setLiuDingSize(final int param) {
+        charsSegment.setLiuDingSize(param);
+    }
+
+    /**
+     * 设置颜色阈值
+     * 
+     * @param param
+     */
+    public void setColorThreshold(final int param) {
+        charsSegment.setColorThreshold(param);
+    }
+
+    /**
+     * 设置蓝色百分比
+     * 
+     * @param param
+     */
+    public void setBluePercent(final float param) {
+        charsSegment.setBluePercent(param);
+    }
+
+    /**
+     * 得到蓝色百分比
+     * 
+     * @param param
+     */
+    public final float getBluePercent() {
+        return charsSegment.getBluePercent();
+    }
+
+    /**
+     * 设置白色百分比
+     * 
+     * @param param
+     */
+    public void setWhitePercent(final float param) {
+        charsSegment.setWhitePercent(param);
+    }
+
+    /**
+     * 得到白色百分比
+     * 
+     * @param param
+     */
+    public final float getWhitePercent() {
+        return charsSegment.getWhitePercent();
+    }
+
+   
+}

easypr/core/CharsSegment.java

@@ -0,0 +1,453 @@
+package com.yuxue.easypr.core;
+
+import static com.yuxue.easypr.core.CoreFunc.getPlateType;
+import static org.bytedeco.javacpp.opencv_core.CV_32F;
+import static org.bytedeco.javacpp.opencv_core.countNonZero;
+import static org.bytedeco.javacpp.opencv_imgproc.CV_CHAIN_APPROX_NONE;
+import static org.bytedeco.javacpp.opencv_imgproc.CV_RETR_EXTERNAL;
+import static org.bytedeco.javacpp.opencv_imgproc.CV_RGB2GRAY;
+import static org.bytedeco.javacpp.opencv_imgproc.CV_THRESH_BINARY;
+import static org.bytedeco.javacpp.opencv_imgproc.CV_THRESH_BINARY_INV;
+import static org.bytedeco.javacpp.opencv_imgproc.CV_THRESH_OTSU;
+import static org.bytedeco.javacpp.opencv_imgproc.INTER_LINEAR;
+import static org.bytedeco.javacpp.opencv_imgproc.boundingRect;
+import static org.bytedeco.javacpp.opencv_imgproc.cvtColor;
+import static org.bytedeco.javacpp.opencv_imgproc.findContours;
+import static org.bytedeco.javacpp.opencv_imgproc.resize;
+import static org.bytedeco.javacpp.opencv_imgproc.threshold;
+import static org.bytedeco.javacpp.opencv_imgproc.warpAffine;
+
+import java.util.Vector;
+
+import org.bytedeco.javacpp.opencv_core;
+import org.bytedeco.javacpp.opencv_core.Mat;
+import org.bytedeco.javacpp.opencv_core.MatVector;
+import org.bytedeco.javacpp.opencv_core.Rect;
+import org.bytedeco.javacpp.opencv_core.Scalar;
+import org.bytedeco.javacpp.opencv_core.Size;
+import org.bytedeco.javacpp.opencv_imgcodecs;
+
+import com.yuxue.enumtype.PlateColor;
+import com.yuxue.util.Convert;
+
+/**
+ * 字符分割
+ * @author yuxue
+ * @date 2020-04-28 09:45
+ */
+public class CharsSegment {
+
+    // preprocessChar所用常量
+    final static int CHAR_SIZE = 20;
+    final static int HORIZONTAL = 1;
+    final static int VERTICAL = 0;
+
+    final static int DEFAULT_LIUDING_SIZE = 7;
+    final static int DEFAULT_MAT_WIDTH = 136;
+
+    final static int DEFAULT_COLORTHRESHOLD = 150;
+    final static float DEFAULT_BLUEPERCEMT = 0.3f;
+    final static float DEFAULT_WHITEPERCEMT = 0.1f;
+
+    private int liuDingSize = DEFAULT_LIUDING_SIZE;
+    private int theMatWidth = DEFAULT_MAT_WIDTH;
+    
+    private int colorThreshold = DEFAULT_COLORTHRESHOLD;
+
+    private float bluePercent = DEFAULT_BLUEPERCEMT;
+    private float whitePercent = DEFAULT_WHITEPERCEMT;
+
+    private boolean isDebug = true;
+    
+
+    /**
+     * 字符分割
+     * 
+     * @param input
+     * @param resultVec
+     * @return <ul>
+     *         <li>more than zero: the number of chars;
+     *         <li>-3: null;
+     *         </ul>
+     */
+    public int charsSegment(final Mat input, Vector<Mat> resultVec, String tempPath) {
+        if (input.data().isNull()) {
+            return -3;
+        }
+
+        // 判断车牌颜色以此确认threshold方法
+        Mat img_threshold = new Mat();
+
+        Mat input_grey = new Mat();
+        cvtColor(input, input_grey, CV_RGB2GRAY);
+
+        int w = input.cols();
+        int h = input.rows();
+        Mat tmpMat = new Mat(input, new Rect((int) (w * 0.1), (int) (h * 0.1), (int) (w * 0.8), (int) (h * 0.8)));
+        
+        PlateColor color= getPlateType(tmpMat, true);
+        switch (color) {
+        case BLUE:
+            threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
+            break;
+
+        case YELLOW:
+            threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU + CV_THRESH_BINARY_INV);
+            break;
+            
+        case GREEN:
+            threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU + CV_THRESH_BINARY_INV);
+            break;
+
+        default:
+            return -3;
+        }
+
+        if (this.isDebug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_char_threshold.jpg", img_threshold);
+        }
+
+        // 去除车牌上方的柳钉以及下方的横线等干扰  //会导致虚拟机崩溃
+        // clearLiuDing(img_threshold);
+        /*if (this.isDebug) {
+            String str = tempPath + "debug_char_clearLiuDing.jpg";
+            opencv_imgcodecs.imwrite(str, img_threshold);
+        }*/
+
+        // 找轮廓
+        Mat img_contours = new Mat();
+        img_threshold.copyTo(img_contours);
+
+        MatVector contours = new MatVector();
+
+        findContours(img_contours, contours, // a vector of contours
+                CV_RETR_EXTERNAL, // retrieve the external contours
+                CV_CHAIN_APPROX_NONE); // all pixels of each contours
+
+        // Remove patch that are no inside limits of aspect ratio and area.
+        // 将不符合特定尺寸的图块排除出去
+        Vector<Rect> vecRect = new Vector<Rect>();
+        for (int i = 0; i < contours.size(); ++i) {
+            Rect mr = boundingRect(contours.get(i));
+            Mat contour = new Mat(img_threshold, mr);
+            
+            if (this.isDebug) {
+                String str = tempPath + "debug_char_contour"+i+".jpg";
+                opencv_imgcodecs.imwrite(str, contour);
+            }
+            
+            if (verifySizes(contour)) { // 将不符合特定尺寸的图块排除出去
+                vecRect.add(mr);
+            }
+        }
+        if (vecRect.size() == 0) {
+            return -3;
+        }
+
+        Vector<Rect> sortedRect = new Vector<Rect>();
+        // 对符合尺寸的图块按照从左到右进行排序
+        SortRect(vecRect, sortedRect);
+
+        // 获得指示城市的特定Rect,如苏A的"A"
+        int specIndex = GetSpecificRect(sortedRect, color);
+
+        if (this.isDebug) {
+            if (specIndex < sortedRect.size()) {
+                Mat specMat = new Mat(img_threshold, sortedRect.get(specIndex));
+                String str = tempPath + "debug_specMat.jpg";
+                opencv_imgcodecs.imwrite(str, specMat);
+            }
+        }
+
+        // 根据特定Rect向左反推出中文字符
+        // 这样做的主要原因是根据findContours方法很难捕捉到中文字符的准确Rect，因此仅能
+        // 通过特定算法来指定
+        Rect chineseRect = new Rect();
+        if (specIndex < sortedRect.size()) {
+            chineseRect = GetChineseRect(sortedRect.get(specIndex));
+        } else {
+            return -3;
+        }
+
+        if (this.isDebug) {
+            Mat chineseMat = new Mat(img_threshold, chineseRect);
+            String str = tempPath + "debug_chineseMat.jpg";
+            opencv_imgcodecs.imwrite(str, chineseMat);
+        }
+
+        // 新建一个全新的排序Rect
+        // 将中文字符Rect第一个加进来，因为它肯定是最左边的
+        // 其余的Rect只按照顺序去6个，车牌只可能是7个字符！这样可以避免阴影导致的“1”字符
+        Vector<Rect> newSortedRect = new Vector<Rect>();
+        newSortedRect.add(chineseRect);
+        RebuildRect(sortedRect, newSortedRect, specIndex, color);
+
+        if (newSortedRect.size() == 0) {
+            return -3;
+        }
+
+        for (int i = 0; i < newSortedRect.size(); i++) {
+            Rect mr = newSortedRect.get(i);
+            Mat auxRoi = new Mat(img_threshold, mr);
+
+            auxRoi = preprocessChar(auxRoi);
+            if (this.isDebug) {
+                String str = tempPath + "debug_char_auxRoi_" + Integer.valueOf(i).toString() + ".jpg";
+                opencv_imgcodecs.imwrite(str, auxRoi);
+            }
+            resultVec.add(auxRoi);
+        }
+        return 0;
+    }
+
+    /**
+     * 字符尺寸验证；去掉尺寸不符合的图块
+     * @param r
+     * @return
+     */
+    public static Boolean verifySizes(Mat r) {
+        float aspect = 45.0f / 90.0f;
+        float charAspect = (float) r.cols() / (float) r.rows();
+        float error = 0.7f;
+        float minHeight = 10f;
+        float maxHeight = 35f;
+        // We have a different aspect ratio for number 1, and it can be ~0.2
+        float minAspect = 0.05f;
+        float maxAspect = aspect + aspect * error;
+        // area of pixels
+        float area = countNonZero(r);
+        // bb area
+        float bbArea = r.cols() * r.rows();
+        // % of pixel in area
+        float percPixels = area / bbArea;
+
+        return percPixels <= 1 && charAspect > minAspect && charAspect < maxAspect && r.rows() >= minHeight && r.rows() < maxHeight;
+    }
+
+    /**
+     * 字符预处理: 统一每个字符的大小
+     * 
+     * @param in
+     * @return
+     */
+    private Mat preprocessChar(Mat in) {
+        int h = in.rows();
+        int w = in.cols();
+        int charSize = CHAR_SIZE;
+        Mat transformMat = Mat.eye(2, 3, CV_32F).asMat();
+        int m = Math.max(w, h);
+        transformMat.ptr(0, 2).put(Convert.getBytes(((m - w) / 2f)));
+        transformMat.ptr(1, 2).put(Convert.getBytes((m - h) / 2f));
+
+        Mat warpImage = new Mat(m, m, in.type());
+        warpAffine(in, warpImage, transformMat, warpImage.size(), INTER_LINEAR, opencv_core.BORDER_CONSTANT, new Scalar(0));
+
+        Mat out = new Mat();
+        resize(warpImage, out, new Size(charSize, charSize));
+
+        return out;
+    }
+
+    /**
+     * 去除车牌上方的钮钉
+     * <p>
+     * 计算每行元素的阶跃数，如果小于X认为是柳丁，将此行全部填0（涂黑）， X可根据实际调整
+     * 
+     * @param img
+     * @return
+     */
+    private Mat clearLiuDing(Mat img) {
+        final int x = this.liuDingSize;
+
+        Mat jump = Mat.zeros(1, img.rows(), CV_32F).asMat();
+        for (int i = 0; i < img.rows(); i++) {
+            int jumpCount = 0;
+            for (int j = 0; j < img.cols() - 1; j++) {
+                if (img.ptr(i, j).get() != img.ptr(i, j + 1).get())
+                    jumpCount++;
+            }
+            jump.ptr(i).put(Convert.getBytes((float) jumpCount));
+        }
+        for (int i = 0; i < img.rows(); i++) {
+            if (Convert.toFloat(jump.ptr(i)) <= x) {
+                for (int j = 0; j < img.cols(); j++) {
+                    img.ptr(i, j).put((byte) 0);
+                }
+            }
+        }
+        return img;
+    }
+
+    /**
+     * 根据特殊车牌来构造猜测中文字符的位置和大小
+     * 
+     * @param rectSpe
+     * @return
+     */
+    private Rect GetChineseRect(final Rect rectSpe) {
+        int height = rectSpe.height();
+        float newwidth = rectSpe.width() * 1.15f;
+        int x = rectSpe.x();
+        int y = rectSpe.y();
+
+        int newx = x - (int) (newwidth * 1.15);
+        newx = Math.max(newx, 0);
+        Rect a = new Rect(newx, y, (int) newwidth, height);
+        return a;
+    }
+
+    /**
+     * 找出指示城市的字符的Rect，例如苏A7003X，就是A的位置
+     * 之所以选择城市的字符位置，是因为该位置不管什么字母，占用的宽度跟高度的差不多，能大大提高位置的准确性
+     * @param vecRect
+     * @return
+     */
+    private int GetSpecificRect(final Vector<Rect> vecRect, PlateColor color) {
+        Vector<Integer> xpositions = new Vector<Integer>();
+        int maxHeight = 0;
+        int maxWidth = 0;
+        for (int i = 0; i < vecRect.size(); i++) {
+            xpositions.add(vecRect.get(i).x());
+
+            if (vecRect.get(i).height() > maxHeight) {
+                maxHeight = vecRect.get(i).height();
+            }
+            if (vecRect.get(i).width() > maxWidth) {
+                maxWidth = vecRect.get(i).width();
+            }
+        }
+
+        int specIndex = 0;
+        for (int i = 0; i < vecRect.size(); i++) {
+            Rect mr = vecRect.get(i);
+            int midx = mr.x() + mr.width() / 2;
+
+            if(PlateColor.GREEN.equals(color)) {
+                if ((mr.width() > maxWidth * 0.8 || mr.height() > maxHeight * 0.8)
+                        && (midx < this.theMatWidth * 2 / 8 && midx > this.theMatWidth / 8)) {
+                    specIndex = i;
+                }
+            } else {
+                // 如果一个字符有一定的大小，并且在整个车牌的1/7到2/7之间，则是我们要找的特殊车牌
+                if ((mr.width() > maxWidth * 0.8 || mr.height() > maxHeight * 0.8)
+                        && (midx < this.theMatWidth * 2 / 7 && midx > this.theMatWidth / 7)) {
+                    specIndex = i;
+                } 
+            }
+        }
+
+        return specIndex;
+    }
+
+    /**
+     * 这个函数做两个事情
+     * <ul>
+     * <li>把特殊字符Rect左边的全部Rect去掉，后面再重建中文字符的位置;
+     * <li>从特殊字符Rect开始，依次选择6个Rect，多余的舍去。
+     * <ul>
+     * 
+     * @param vecRect
+     * @param outRect
+     * @param specIndex
+     * @return
+     */
+    private int RebuildRect(final Vector<Rect> vecRect, Vector<Rect> outRect, int specIndex, PlateColor color) {
+        // 最大只能有7个Rect,减去中文的就只有6个Rect
+        int count = 6;
+        if(PlateColor.GREEN.equals(color)) {
+            count = 7; // 绿牌要多一个
+        }
+        for (int i = 0; i < vecRect.size(); i++) {
+            // 将特殊字符左边的Rect去掉，这个可能会去掉中文Rect，不过没关系，我们后面会重建。
+            if (i < specIndex)
+                continue;
+
+            outRect.add(vecRect.get(i));
+            if (--count == 0)
+                break;
+        }
+
+        return 0;
+    }
+
+    /**
+     * 将Rect按位置从左到右进行排序
+     * 
+     * @param vecRect
+     * @param out
+     * @return
+     */
+    public static void SortRect(final Vector<Rect> vecRect, Vector<Rect> out) {
+        Vector<Integer> orderIndex = new Vector<Integer>();
+        Vector<Integer> xpositions = new Vector<Integer>();
+        for (int i = 0; i < vecRect.size(); ++i) {
+            orderIndex.add(i);
+            xpositions.add(vecRect.get(i).x());
+        }
+
+        float min = xpositions.get(0);
+        int minIdx;
+        for (int i = 0; i < xpositions.size(); ++i) {
+            min = xpositions.get(i);
+            minIdx = i;
+            for (int j = i; j < xpositions.size(); ++j) {
+                if (xpositions.get(j) < min) {
+                    min = xpositions.get(j);
+                    minIdx = j;
+                }
+            }
+            int aux_i = orderIndex.get(i);
+            int aux_min = orderIndex.get(minIdx);
+            orderIndex.remove(i);
+            orderIndex.insertElementAt(aux_min, i);
+            orderIndex.remove(minIdx);
+            orderIndex.insertElementAt(aux_i, minIdx);
+
+            float aux_xi = xpositions.get(i);
+            float aux_xmin = xpositions.get(minIdx);
+            xpositions.remove(i);
+            xpositions.insertElementAt((int) aux_xmin, i);
+            xpositions.remove(minIdx);
+            xpositions.insertElementAt((int) aux_xi, minIdx);
+        }
+
+        for (int i = 0; i < orderIndex.size(); i++)
+            out.add(vecRect.get(orderIndex.get(i)));
+
+        return;
+    }
+
+    public void setLiuDingSize(int param) {
+        this.liuDingSize = param;
+    }
+
+    public void setColorThreshold(int param) {
+        this.colorThreshold = param;
+    }
+
+    public void setBluePercent(float param) {
+        this.bluePercent = param;
+    }
+
+    public final float getBluePercent() {
+        return this.bluePercent;
+    }
+
+    public void setWhitePercent(float param) {
+        this.whitePercent = param;
+    }
+
+    public final float getWhitePercent() {
+        return this.whitePercent;
+    }
+
+    public boolean getDebug() {
+        return this.isDebug;
+    }
+
+    public void setDebug(boolean isDebug) {
+        this.isDebug = isDebug;
+    }
+
+
+}

easypr/core/CoreFunc.java

@@ -0,0 +1,269 @@
+package com.yuxue.easypr.core;
+
+import org.bytedeco.javacpp.BytePointer;
+import org.bytedeco.javacpp.opencv_core;
+import org.bytedeco.javacpp.opencv_core.Mat;
+import org.bytedeco.javacpp.opencv_core.MatVector;
+import org.bytedeco.javacpp.opencv_core.Size;
+import org.bytedeco.javacpp.opencv_highgui;
+import org.bytedeco.javacpp.opencv_imgproc;
+import org.bytedeco.javacpp.indexer.FloatIndexer;
+
+import com.yuxue.enumtype.Direction;
+import com.yuxue.enumtype.PlateColor;
+
+
+/**
+ * 
+ * @author yuxue
+ * @date 2020-05-16 21:09
+ */
+public class CoreFunc {
+
+    /**
+     * 根据一幅图像与颜色模板获取对应的二值图
+     * 
+     * @param src
+     *            输入RGB图像
+     * @param r
+     *            颜色模板（蓝色、黄色）
+     * @param adaptive_minsv
+     *            S和V的最小值由adaptive_minsv这个bool值判断
+     *            <ul>
+     *            <li>如果为true，则最小值取决于H值，按比例衰减
+     *            <li>如果为false，则不再自适应，使用固定的最小值minabs_sv
+     *            </ul>
+     * @return 输出灰度图（只有0和255两个值，255代表匹配，0代表不匹配）
+     */
+    public static Mat colorMatch(final Mat src, final PlateColor r, final boolean adaptive_minsv) {
+        final float max_sv = 255;
+        final float minref_sv = 64;
+        final float minabs_sv = 95;
+
+        // 转到HSV空间进行处理，颜色搜索主要使用的是H分量进行蓝色与黄色的匹配工作
+        Mat src_hsv = new Mat();
+        opencv_imgproc.cvtColor(src, src_hsv, opencv_imgproc.CV_BGR2HSV);
+        MatVector hsvSplit = new MatVector();
+        opencv_core.split(src_hsv, hsvSplit);
+        opencv_imgproc.equalizeHist(hsvSplit.get(2), hsvSplit.get(2));
+        opencv_core.merge(hsvSplit, src_hsv);
+
+        // 匹配模板基色,切换以查找想要的基色
+        int min_h = r.minH;
+        int max_h = r.maxH;
+
+        float diff_h = (float) ((max_h - min_h) / 2);
+        int avg_h = (int) (min_h + diff_h);
+
+        int channels = src_hsv.channels();
+        int nRows = src_hsv.rows();
+        // 图像数据列需要考虑通道数的影响；
+        int nCols = src_hsv.cols() * channels;
+
+        // 连续存储的数据，按一行处理
+        if (src_hsv.isContinuous()) {
+            nCols *= nRows;
+            nRows = 1;
+        }
+
+        for (int i = 0; i < nRows; ++i) {
+            BytePointer p = src_hsv.ptr(i);
+            for (int j = 0; j < nCols; j += 3) {
+                int H = p.get(j) & 0xFF;
+                int S = p.get(j + 1) & 0xFF;
+                int V = p.get(j + 2) & 0xFF;
+
+                boolean colorMatched = false;
+
+                if (H > min_h && H < max_h) {
+                    int Hdiff = 0;
+                    if (H > avg_h)
+                        Hdiff = H - avg_h;
+                    else
+                        Hdiff = avg_h - H;
+
+                    float Hdiff_p = Hdiff / diff_h;
+
+                    float min_sv = 0;
+                    if (true == adaptive_minsv)
+                        min_sv = minref_sv - minref_sv / 2 * (1 - Hdiff_p);
+                    else
+                        min_sv = minabs_sv;
+
+                    if ((S > min_sv && S <= max_sv) && (V > min_sv && V <= max_sv))
+                        colorMatched = true;
+                }
+
+                if (colorMatched == true) {
+                    p.put(j, (byte) 0);
+                    p.put(j + 1, (byte) 0);
+                    p.put(j + 2, (byte) 255);
+                } else {
+                    p.put(j, (byte) 0);
+                    p.put(j + 1, (byte) 0);
+                    p.put(j + 2, (byte) 0);
+                }
+            }
+        }
+
+        // 获取颜色匹配后的二值灰度图
+        MatVector hsvSplit_done = new MatVector();
+        opencv_core.split(src_hsv, hsvSplit_done);
+        Mat src_grey = hsvSplit_done.get(2);
+
+        return src_grey;
+    }
+
+    /**
+     * 判断一个车牌的颜色
+     * 
+     * @param src
+     *            车牌mat
+     * @param r
+     *            颜色模板
+     * @param adaptive_minsv
+     *            S和V的最小值由adaptive_minsv这个bool值判断
+     *            <ul>
+     *            <li>如果为true，则最小值取决于H值，按比例衰减
+     *            <li>如果为false，则不再自适应，使用固定的最小值minabs_sv
+     *            </ul>
+     * @return
+     */
+    public static boolean plateColorJudge(final Mat src, final PlateColor color, final boolean adaptive_minsv) {
+        // 判断阈值
+        final float thresh = 0.49f;
+
+        Mat gray = colorMatch(src, color, adaptive_minsv);
+
+        float percent = (float) opencv_core.countNonZero(gray) / (gray.rows() * gray.cols());
+
+        return (percent > thresh) ? true : false;
+    }
+
+    /**
+     * getPlateType 判断车牌的类型
+     * 
+     * @param src
+     * @param adaptive_minsv
+     *            S和V的最小值由adaptive_minsv这个bool值判断
+     *            <ul>
+     *            <li>如果为true，则最小值取决于H值，按比例衰减
+     *            <li>如果为false，则不再自适应，使用固定的最小值minabs_sv
+     *            </ul>
+     * @return
+     */
+    public static PlateColor getPlateType(final Mat src, final boolean adaptive_minsv) {
+        if (plateColorJudge(src, PlateColor.BLUE, adaptive_minsv) == true) {
+            return PlateColor.BLUE;
+        } else if (plateColorJudge(src, PlateColor.YELLOW, adaptive_minsv) == true) {
+            return PlateColor.YELLOW;
+        } else if (plateColorJudge(src, PlateColor.GREEN, adaptive_minsv) == true) {
+            return PlateColor.GREEN;
+        } else {
+            return PlateColor.UNKNOWN;
+        }
+    }
+
+    /**
+     * 获取垂直或水平方向直方图
+     * 
+     * @param img
+     * @param direction
+     * @return
+     */
+    public static float[] projectedHistogram(final Mat img, Direction direction) {
+        int sz = 0;
+        switch (direction) {
+        case HORIZONTAL:
+            sz = img.rows();
+            break;
+
+        case VERTICAL:
+            sz = img.cols();
+            break;
+
+        default:
+            break;
+        }
+
+        // 统计这一行或一列中，非零元素的个数，并保存到nonZeroMat中
+        float[] nonZeroMat = new float[sz];
+        opencv_core.extractChannel(img, img, 0);
+        for (int j = 0; j < sz; j++) {
+            Mat data = (direction == Direction.HORIZONTAL) ? img.row(j) : img.col(j);
+            int count = opencv_core.countNonZero(data);
+            nonZeroMat[j] = count;
+        }
+
+        // Normalize histogram
+        float max = 0;
+        for (int j = 0; j < nonZeroMat.length; ++j) {
+            max = Math.max(max, nonZeroMat[j]);
+        }
+
+        if (max > 0) {
+            for (int j = 0; j < nonZeroMat.length; ++j) {
+                nonZeroMat[j] /= max;
+            }
+        }
+
+        return nonZeroMat;
+    }
+
+    /**
+     * Assign values to feature
+     * <p>
+     * 样本特征为水平、垂直直方图和低分辨率图像所组成的矢量
+     * 
+     * @param in
+     * @param sizeData
+     *            低分辨率图像size = sizeData*sizeData, 可以为0
+     * @return
+     */
+    public static Mat features(final Mat in, final int sizeData) {
+
+        float[] vhist = projectedHistogram(in, Direction.VERTICAL);
+        float[] hhist = projectedHistogram(in, Direction.HORIZONTAL);
+
+        Mat lowData = new Mat();
+        if (sizeData > 0) {
+            // resize.cpp:3784: error: (-215:Assertion failed) !ssize.empty() in function 'cv::resize'
+            opencv_imgproc.resize(in, lowData, new Size(sizeData, sizeData));
+        }
+
+        int numCols = vhist.length + hhist.length + lowData.cols() * lowData.rows();
+        Mat out = Mat.zeros(1, numCols, opencv_core.CV_32F).asMat();
+        FloatIndexer idx = out.createIndexer();
+
+        int j = 0;
+        for (int i = 0; i < vhist.length; ++i, ++j) {
+            idx.put(0, j, vhist[i]);
+        }
+        for (int i = 0; i < hhist.length; ++i, ++j) {
+            idx.put(0, j, hhist[i]);
+        }
+        for (int x = 0; x < lowData.cols(); x++) {
+            for (int y = 0; y < lowData.rows(); y++, ++j) {
+                float val = lowData.ptr(x, y).get(0) & 0xFF;
+                idx.put(0, j, val);
+            }
+        }
+
+        return out;
+    }
+
+    
+    
+    /**
+     * 显示图像
+     * @param title
+     * @param src
+     */
+    public static void showImage(final String title, final Mat src) {
+        if (src != null) {
+            opencv_highgui.imshow(title, src);
+            opencv_highgui.cvWaitKey(0);
+        }
+    }
+
+}

easypr/core/Features.java

@@ -0,0 +1,90 @@
+package com.yuxue.easypr.core;
+
+import static com.yuxue.easypr.core.CoreFunc.features;
+import static org.bytedeco.javacpp.opencv_core.merge;
+import static org.bytedeco.javacpp.opencv_core.split;
+
+import org.bytedeco.javacpp.opencv_core.Mat;
+import org.bytedeco.javacpp.opencv_core.MatVector;
+import org.bytedeco.javacpp.opencv_imgproc;
+
+/**
+ * 
+ * @author yuxue
+ * @date 2020-05-05 08:26
+ */
+public class Features implements SVMCallback {
+
+    /***
+     * EasyPR的getFeatures回调函数
+     * 本函数是生成直方图均衡特征的回调函数
+     * @param image
+     * @return
+     */
+    @Override
+    public Mat getHisteqFeatures(final Mat image) {
+        return histeq(image);
+    }
+    
+    private Mat histeq(Mat in) {
+        Mat out = new Mat(in.size(), in.type());
+        if (in.channels() == 3) {
+            Mat hsv = new Mat();
+            MatVector hsvSplit = new MatVector();
+            opencv_imgproc.cvtColor(in, hsv, opencv_imgproc.CV_BGR2HSV);
+            split(hsv, hsvSplit);
+            opencv_imgproc.equalizeHist(hsvSplit.get(2), hsvSplit.get(2));
+            merge(hsvSplit, hsv);
+            opencv_imgproc.cvtColor(hsv, out, opencv_imgproc.CV_HSV2BGR);
+            hsv = null;
+            hsvSplit = null;
+            System.gc();
+        } else if (in.channels() == 1) {
+            opencv_imgproc.equalizeHist(in, out);
+        }
+        return out;
+    }
+    
+    /**
+     * EasyPR的getFeatures回调函数
+     * 本函数是获取垂直和水平的直方图图值
+     * @param image
+     * @return
+     */
+    @Override
+    public Mat getHistogramFeatures(Mat image) {
+        Mat grayImage = new Mat();
+        opencv_imgproc.cvtColor(image, grayImage, opencv_imgproc.CV_RGB2GRAY);
+
+        Mat img_threshold = new Mat();
+        opencv_imgproc.threshold(grayImage, img_threshold, 0, 255, opencv_imgproc.CV_THRESH_OTSU + opencv_imgproc.CV_THRESH_BINARY);
+
+        return features(img_threshold, 0);
+    }
+
+    /**
+     * 本函数是获取SITF特征子的回调函数
+     * 
+     * @param image  
+     * @return
+     */
+    @Override
+    public Mat getSIFTFeatures(final Mat image) {
+        // TODO: 待完善
+        return null;
+    }
+
+    /**
+     * 本函数是获取HOG特征子的回调函数
+     * 
+     * @param image
+     * @return
+     */
+    @Override
+    public Mat getHOGFeatures(final Mat image) {
+        // TODO: 待完善
+        return null;
+    }
+
+    
+}

easypr/core/PlateDetect.java

@@ -0,0 +1,111 @@
+package com.yuxue.easypr.core;
+
+import java.util.Vector;
+
+import org.bytedeco.javacpp.opencv_core.Mat;
+
+
+/**
+ * 车牌检测识别
+ * 分两个步骤： 1、车牌定位 2、车牌判断
+ * @author yuxue
+ * @date 2020-04-24 15:33
+ */
+public class PlateDetect {
+
+    // 车牌定位， 图片处理对象
+    private PlateLocate plateLocate = new PlateLocate();
+
+    // 切图判断对象
+    private PlateJudge plateJudge = new PlateJudge();
+
+    /**
+     * @param src 图片路径，不能包含中文及特殊字符
+     * @param resultVec 车牌的图块集合
+     * @return the error number
+     *         <ul>
+     *         <li>0: plate detected successfully;
+     *         <li>-1: source Mat is empty;
+     *         <li>-2: plate not detected.
+     *         </ul>
+     */
+    public int plateDetect(final Mat src, Vector<Mat> resultVec) {
+        Vector<Mat> matVec = plateLocate.plateLocate(src);  // 定位
+
+        if (0 == matVec.size()) {
+            return -1;
+        }
+
+        if (0 != plateJudge.plateJudge(matVec, resultVec)) { //对多幅图像进行SVM判断
+            return -2;
+        }
+        return 0;
+    }
+
+
+    /**
+     * 生活模式与工业模式切换
+     * @param pdLifemode
+     */
+    public void setPDLifemode(boolean pdLifemode) {
+        plateLocate.setLifemode(pdLifemode);
+    }
+
+    public void setGaussianBlurSize(int gaussianBlurSize) {
+        plateLocate.setGaussianBlurSize(gaussianBlurSize);
+    }
+
+    public final int getGaussianBlurSize() {
+        return plateLocate.getGaussianBlurSize();
+    }
+
+    public void setMorphSizeWidth(int morphSizeWidth) {
+        plateLocate.setMorphSizeWidth(morphSizeWidth);
+    }
+
+    public final int getMorphSizeWidth() {
+        return plateLocate.getMorphSizeWidth();
+    }
+
+    public void setMorphSizeHeight(int morphSizeHeight) {
+        plateLocate.setMorphSizeHeight(morphSizeHeight);
+    }
+
+    public final int getMorphSizeHeight() {
+        return plateLocate.getMorphSizeHeight();
+    }
+
+    public void setVerifyError(float verifyError) {
+        plateLocate.setVerifyError(verifyError);
+    }
+
+    public final float getVerifyError() {
+        return plateLocate.getVerifyError();
+    }
+
+    public void setVerifyAspect(float verifyAspect) {
+        plateLocate.setVerifyAspect(verifyAspect);
+    }
+
+    public final float getVerifyAspect() {
+        return plateLocate.getVerifyAspect();
+    }
+
+    public void setVerifyMin(int verifyMin) {
+        plateLocate.setVerifyMin(verifyMin);
+    }
+
+    public void setVerifyMax(int verifyMax) {
+        plateLocate.setVerifyMax(verifyMax);
+    }
+
+    public void setJudgeAngle(int judgeAngle) {
+        plateLocate.setJudgeAngle(judgeAngle);
+    }
+    
+    public void setDebug(boolean debug, String tempPath) {
+        plateLocate.setDebug(debug);
+        plateLocate.setTempPath(tempPath);
+    }
+
+}

easypr/core/PlateJudge.java

@@ -0,0 +1,107 @@
+package com.yuxue.easypr.core;
+
+import org.bytedeco.javacpp.opencv_core;
+import org.bytedeco.javacpp.opencv_imgproc;
+
+import java.util.Vector;
+
+import org.bytedeco.javacpp.opencv_core.Mat;
+import org.bytedeco.javacpp.opencv_core.Rect;
+import org.bytedeco.javacpp.opencv_core.Size;
+import org.bytedeco.javacpp.opencv_ml.SVM;
+
+import com.yuxue.constant.Constant;
+
+
+/**
+ * 车牌判断
+ * @author yuxue
+ * @date 2020-04-26 15:21
+ */
+public class PlateJudge {
+
+    private SVM svm = SVM.create();
+
+    public PlateJudge() {
+        loadSVM(Constant.DEFAULT_SVM_PATH);
+    }
+    
+    public void loadSVM(String path) {
+        svm.clear();
+        // svm=SVM.loadSVM(path, "svm");
+        svm=SVM.load(path);
+    }
+    
+    /**
+     * EasyPR的getFeatures回调函数, 用于从车牌的image生成svm的训练特征features
+     */
+    private SVMCallback features = new Features();
+    
+
+    /**
+     * 对单幅图像进行SVM判断
+     * @param inMat
+     * @return
+     */
+    public int plateJudge(final Mat inMat) {
+        int ret = 1;
+        // 使用com.yuxue.train.SVMTrain 生成的训练库文件
+        Mat features = this.features.getHistogramFeatures(inMat);
+        /*Mat samples = features.reshape(1, 1);
+        samples.convertTo(samples, opencv_core.CV_32F);*/
+        
+        Mat p = features.reshape(1, 1);
+        p.convertTo(p, opencv_core.CV_32FC1);
+        ret = (int) svm.predict(features);
+        return ret;
+        
+        // 使用com.yuxue.train.PlateRecoTrain 生成的训练库文件
+        // 在使用的过程中，传入的样本切图要跟训练的时候处理切图的方法一致
+        /*Mat grayImage = new Mat();
+        opencv_imgproc.cvtColor(inMat, grayImage, opencv_imgproc.CV_RGB2GRAY);
+        Mat dst = new Mat();
+        opencv_imgproc.Canny(grayImage, dst, 130, 250);
+        Mat samples = dst.reshape(1, 1);
+        samples.convertTo(samples, opencv_core.CV_32F);*/
+        
+        // 正样本为0 负样本为1
+        /*if(svm.predict(samples) <= 0) {
+            ret = 1;
+        }*/
+        /*ret = (int)svm.predict(samples);
+        System.err.println(ret);
+        return ret ;*/
+        
+    }
+
+    /**
+     * 对多幅图像进行SVM判断
+     * @param inVec
+     * @param resultVec
+     * @return
+     */
+    public int plateJudge(Vector<Mat> inVec, Vector<Mat> resultVec) {
+
+        for (int j = 0; j < inVec.size(); j++) {
+            Mat inMat = inVec.get(j);
+
+            if (1 == plateJudge(inMat)) {
+                resultVec.add(inMat);
+            } else { // 再取中间部分判断一次
+                int w = inMat.cols();
+                int h = inMat.rows();
+
+                Mat tmpDes = inMat.clone();
+                Mat tmpMat = new Mat(inMat, new Rect((int) (w * 0.05), (int) (h * 0.1), (int) (w * 0.9), (int) (h * 0.8)));
+                opencv_imgproc.resize(tmpMat, tmpDes, new Size(inMat.size()));
+
+                if (plateJudge(tmpDes) == 1) {
+                    resultVec.add(inMat);
+                }
+            }
+        }
+        return 0;
+    }
+
+
+}

easypr/core/PlateLocate.java

@@ -0,0 +1,354 @@
+package com.yuxue.easypr.core;
+
+import java.util.Vector;
+
+import static org.bytedeco.javacpp.opencv_core.*;
+import static org.bytedeco.javacpp.opencv_imgproc.*;
+
+import com.yuxue.constant.Constant;
+import org.bytedeco.javacpp.opencv_imgcodecs;
+
+import org.bytedeco.javacpp.opencv_core.CvPoint2D32f;
+import org.bytedeco.javacpp.opencv_core.Mat;
+import org.bytedeco.javacpp.opencv_core.MatVector;
+import org.bytedeco.javacpp.opencv_core.Point;
+import org.bytedeco.javacpp.opencv_core.Point2f;
+import org.bytedeco.javacpp.opencv_core.RotatedRect;
+import org.bytedeco.javacpp.opencv_core.Scalar;
+import org.bytedeco.javacpp.opencv_core.Size;
+
+
+/**
+ * 车牌定位
+ * @author yuxue
+ * @date 2020-04-24 15:33
+ */
+public class PlateLocate {
+
+    // PlateLocate所用常量
+    public static final int DEFAULT_GAUSSIANBLUR_SIZE = 5;
+    public static final int SOBEL_SCALE = 1;
+    public static final int SOBEL_DELTA = 0;
+    public static final int SOBEL_DDEPTH = CV_16S;
+    public static final int SOBEL_X_WEIGHT = 1;
+    public static final int SOBEL_Y_WEIGHT = 0;
+    public static final int DEFAULT_MORPH_SIZE_WIDTH = 17;
+    public static final int DEFAULT_MORPH_SIZE_HEIGHT = 3;
+
+    // showResultMat所用常量
+    public static final int WIDTH = 136;
+    public static final int HEIGHT = 36;
+    public static final int TYPE = CV_8UC3;
+
+    // verifySize所用常量
+    public static final int DEFAULT_VERIFY_MIN = 3;
+    public static final int DEFAULT_VERIFY_MAX = 20;
+
+    final float DEFAULT_ERROR = 0.6f;
+    final float DEFAULT_ASPECT = 3.75f;
+
+    // 角度判断所用常量
+    public static final int DEFAULT_ANGLE = 30;
+
+    // 高斯模糊所用变量
+    protected int gaussianBlurSize = DEFAULT_GAUSSIANBLUR_SIZE;
+
+    // 连接操作所用变量
+    protected int morphSizeWidth = DEFAULT_MORPH_SIZE_WIDTH;
+    protected int morphSizeHeight = DEFAULT_MORPH_SIZE_HEIGHT;
+
+    // verifySize所用变量
+    protected float error = DEFAULT_ERROR;
+    protected float aspect = DEFAULT_ASPECT;
+    protected int verifyMin = DEFAULT_VERIFY_MIN;
+    protected int verifyMax = DEFAULT_VERIFY_MAX;
+
+    // 角度判断所用变量
+    protected int angle = DEFAULT_ANGLE;
+
+    // 是否开启调试模式，0关闭，非0开启 
+    protected boolean debug = true;
+
+    // 开启调试模式之后，切图文件保存路径
+    protected String tempPath = Constant.DEFAULT_TEMP_DIR + System.currentTimeMillis() + "/";
+
+    /**
+     * 生活模式与工业模式切换
+     * @param islifemode
+     * 如果为真，则设置各项参数为定位生活场景照片（如百度图片）的参数，否则恢复默认值。
+     * 
+     */
+    public void setLifemode(boolean islifemode) {
+        if (islifemode) {
+            setGaussianBlurSize(5);
+            setMorphSizeWidth(9);
+            setMorphSizeHeight(3);
+            setVerifyError(0.9f);
+            setVerifyAspect(4);
+            setVerifyMin(1);
+            setVerifyMax(30);
+        } else {
+            setGaussianBlurSize(DEFAULT_GAUSSIANBLUR_SIZE);
+            setMorphSizeWidth(DEFAULT_MORPH_SIZE_WIDTH);
+            setMorphSizeHeight(DEFAULT_MORPH_SIZE_HEIGHT);
+            setVerifyError(DEFAULT_ERROR);
+            setVerifyAspect(DEFAULT_ASPECT);
+            setVerifyMin(DEFAULT_VERIFY_MIN);
+            setVerifyMax(DEFAULT_VERIFY_MAX);
+        }
+    }
+
+    /**
+     * 定位车牌图像
+     * @param src 原始图像
+     * @return 一个Mat的向量，存储所有抓取到的图像
+     */
+    public Vector<Mat> plateLocate(Mat src) {
+        Vector<Mat> resultVec = new Vector<Mat>();
+
+        Mat src_blur = new Mat();
+        Mat src_gray = new Mat();
+        Mat grad = new Mat();
+
+        int scale = SOBEL_SCALE;
+        int delta = SOBEL_DELTA;
+        int ddepth = SOBEL_DDEPTH;
+
+        // 高斯模糊。Size中的数字影响车牌定位的效果。
+        GaussianBlur(src, src_blur, new Size(gaussianBlurSize, gaussianBlurSize), 0, 0, BORDER_DEFAULT);
+        if (debug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_GaussianBlur.jpg", src_blur);
+        }
+
+        // Convert it to gray 将图像进行灰度化
+        cvtColor(src_blur, src_gray, CV_RGB2GRAY);
+        if (debug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_gray.jpg", src_gray);
+        }
+
+        // 对图像进行Sobel 运算，得到的是图像的一阶水平方向导数。
+
+        // Generate grad_x and grad_y
+        Mat grad_x = new Mat();
+        Mat grad_y = new Mat();
+        Mat abs_grad_x = new Mat();
+        Mat abs_grad_y = new Mat();
+
+        Sobel(src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
+        convertScaleAbs(grad_x, abs_grad_x);
+
+        Sobel(src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT);
+        convertScaleAbs(grad_y, abs_grad_y);
+
+        // Total Gradient (approximate)
+        addWeighted(abs_grad_x, SOBEL_X_WEIGHT, abs_grad_y, SOBEL_Y_WEIGHT, 0, grad);
+
+        if (debug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_Sobel.jpg", grad);
+        }
+
+        // 对图像进行二值化。将灰度图像（每个像素点有256 个取值可能）转化为二值图像（每个像素点仅有1 和0 两个取值可能）。
+
+        Mat img_threshold = new Mat();
+        threshold(grad, img_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
+
+        if (debug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_threshold.jpg", img_threshold);
+        }
+
+        // 使用闭操作。对图像进行闭操作以后，可以看到车牌区域被连接成一个矩形装的区域。
+
+        Mat element = getStructuringElement(MORPH_RECT, new Size(morphSizeWidth, morphSizeHeight));
+        morphologyEx(img_threshold, img_threshold, MORPH_CLOSE, element);
+
+        if (debug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_morphology.jpg", img_threshold);
+        }
+
+        // Find 轮廓 of possibles plates 求轮廓。求出图中所有的轮廓。这个算法会把全图的轮廓都计算出来，因此要进行筛选。
+
+        MatVector contours = new MatVector();
+        findContours(img_threshold, contours, // a vector of contours
+                CV_RETR_EXTERNAL, // 提取外部轮廓
+                CV_CHAIN_APPROX_NONE); // all pixels of each contours
+
+        Mat result = new Mat();
+        if (debug) {
+            src.copyTo(result);
+            // 将轮廓描绘到图上输出
+            drawContours(result, contours, -1, new Scalar(0, 0, 255, 255));
+            opencv_imgcodecs.imwrite(tempPath + "debug_Contours.jpg", result);
+        }
+
+        // Start to iterate to each contour founded
+        // 筛选。对轮廓求最小外接矩形，然后验证，不满足条件的淘汰。
+        Vector<RotatedRect> rects = new Vector<RotatedRect>();
+
+        for (int i = 0; i < contours.size(); ++i) {
+            RotatedRect mr = minAreaRect(contours.get(i));
+            if (verifySizes(mr))
+                rects.add(mr);
+        }
+
+        int k = 1;
+        for (int i = 0; i < rects.size(); i++) {
+            RotatedRect minRect = rects.get(i);
+            /*if (debug) {
+                Point2f rect_points = new Point2f(4);
+                minRect.points(rect_points);
+
+                for (int j = 0; j < 4; j++) {
+                    Point pt1 = new Point(new CvPoint2D32f(rect_points.position(j)));
+                    Point pt2 = new Point(new CvPoint2D32f(rect_points.position((j + 1) % 4)));
+
+                    line(result, pt1, pt2, new Scalar(0, 255, 255, 255), 1, 8, 0);
+                }
+            }*/
+
+            // rotated rectangle drawing
+            // 旋转这部分代码确实可以将某些倾斜的车牌调整正，但是它也会误将更多正的车牌搞成倾斜！所以综合考虑，还是不使用这段代码。
+            // 2014-08-14,由于新到的一批图片中发现有很多车牌是倾斜的，因此决定再次尝试这段代码。
+
+            float r = minRect.size().width() / minRect.size().height();
+            float angle = minRect.angle();
+            Size rect_size = new Size((int) minRect.size().width(), (int) minRect.size().height());
+            if (r < 1) {
+                angle = 90 + angle;
+                rect_size = new Size(rect_size.height(), rect_size.width());
+            }
+            // 如果抓取的方块旋转超过m_angle角度，则不是车牌，放弃处理
+            if (angle - this.angle < 0 && angle + this.angle > 0) {
+                Mat img_rotated = new Mat();
+                Mat rotmat = getRotationMatrix2D(minRect.center(), angle, 1);
+                warpAffine(src, img_rotated, rotmat, src.size()); // CV_INTER_CUBIC
+
+                Mat resultMat = showResultMat(img_rotated, rect_size, minRect.center(), k++);
+                resultVec.add(resultMat);
+            }
+        }
+
+        return resultVec;
+    }
+
+
+    /**
+     * 对minAreaRect获得的最小外接矩形，用纵横比进行判断
+     * 
+     * @param mr
+     * @return
+     */
+    private boolean verifySizes(RotatedRect mr) {
+        float error = this.error;
+
+        // China car plate size: 440mm*140mm，aspect 3.142857      
+        float aspect = this.aspect;
+        int min = 44 * 14 * verifyMin; // minimum area
+        int max = 44 * 14 * verifyMax; // maximum area
+
+        // Get only patchs that match to a respect ratio.
+        float rmin = aspect - aspect * error;
+        float rmax = aspect + aspect * error;
+
+        int area = (int) (mr.size().height() * mr.size().width());
+        float r = mr.size().width() / mr.size().height();
+        if (r < 1)
+            r = mr.size().height() / mr.size().width();
+
+        return area >= min && area <= max && r >= rmin && r <= rmax;
+    }
+
+    /**
+     * 显示最终生成的车牌图像，便于判断是否成功进行了旋转。
+     * @param src
+     * @param rect_size
+     * @param center
+     * @param index
+     * @return
+     */
+    private Mat showResultMat(Mat src, Size rect_size, Point2f center, int index) {
+        Mat img_crop = new Mat();
+        getRectSubPix(src, rect_size, center, img_crop);
+
+        if (debug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_crop_" + index + ".jpg", img_crop);
+        }
+
+        Mat resultResized = new Mat();
+        resultResized.create(HEIGHT, WIDTH, TYPE);
+        resize(img_crop, resultResized, resultResized.size(), 0, 0, INTER_CUBIC);
+        if (debug) {
+            opencv_imgcodecs.imwrite(tempPath + "debug_resize_" + index + ".jpg", resultResized);
+        }
+        return resultResized;
+    }
+
+
+
+    public String getTempPath() {
+        return tempPath;
+    }
+
+    public void setTempPath(String tempPath) {
+        this.tempPath = tempPath;
+    }
+
+    public void setGaussianBlurSize(int gaussianBlurSize) {
+        this.gaussianBlurSize = gaussianBlurSize;
+    }
+
+    public final int getGaussianBlurSize() {
+        return this.gaussianBlurSize;
+    }
+
+    public void setMorphSizeWidth(int morphSizeWidth) {
+        this.morphSizeWidth = morphSizeWidth;
+    }
+
+    public final int getMorphSizeWidth() {
+        return this.morphSizeWidth;
+    }
+
+    public void setMorphSizeHeight(int morphSizeHeight) {
+        this.morphSizeHeight = morphSizeHeight;
+    }
+
+    public final int getMorphSizeHeight() {
+        return this.morphSizeHeight;
+    }
+
+    public void setVerifyError(float error) {
+        this.error = error;
+    }
+
+    public final float getVerifyError() {
+        return this.error;
+    }
+
+    public void setVerifyAspect(float aspect) {
+        this.aspect = aspect;
+    }
+
+    public final float getVerifyAspect() {
+        return this.aspect;
+    }
+
+    public void setVerifyMin(int verifyMin) {
+        this.verifyMin = verifyMin;
+    }
+
+    public void setVerifyMax(int verifyMax) {
+        this.verifyMax = verifyMax;
+    }
+
+    public void setJudgeAngle(int angle) {
+        this.angle = angle;
+    }
+
+    public void setDebug(boolean debug) {
+        this.debug = debug;
+    }
+    public boolean getDebug() {
+        return debug;
+    }
+
+}

easypr/core/SVMCallback.java

@@ -0,0 +1,44 @@
+package com.yuxue.easypr.core;
+
+import org.bytedeco.javacpp.opencv_core.Mat;
+
+
+/**
+ * @author Created by fanwenjie
+ * @author lin.yao
+ *
+ */
+public interface SVMCallback {
+
+    /***
+     * EasyPR的getFeatures回调函数,本函数是生成直方图均衡特征的回调函数
+     * 
+     * @param image
+     * @return
+     */
+    public abstract Mat getHisteqFeatures(final Mat image);
+
+    /**
+     * EasyPR的getFeatures回调函数, 本函数是获取垂直和水平的直方图图值
+     * 
+     * @param image
+     * @return
+     */
+    public abstract Mat getHistogramFeatures(final Mat image);
+
+    /**
+     * 本函数是获取SITF特征子的回调函数
+     * 
+     * @param image
+     * @return
+     */
+    public abstract Mat getSIFTFeatures(final Mat image);
+
+    /**
+     * 本函数是获取HOG特征子的回调函数
+     * 
+     * @param image
+     * @return
+     */
+    public abstract Mat getHOGFeatures(final Mat image);
+}