实施车牌检测算法

Question

To improve my knowledge of imaging and get some experience working with the topics, I decided to create a license plate recognition algorithm on the Android platform.

The first step is detection, for which I decided to implement a recent paper titled "A Robust and Efficient Approach to License Plate Detection" . The paper presents their idea very well and uses quite simple techniques to achieve detection. Besides some details lacking in the paper, I implemented the bilinear downsampling, converting to gray scale, and the edging + adaptive thresholding as described in Section 3A, 3B.1, and 3B.2. Unfortunately, I am not getting the output this paper presents in eg figure 3 and 6.

The image I use for testing is as follows:

The gray scale (and downsampled) version looks fine (see the bottom of this post for the actual implementation), I used a well-known combination of the RGB components to produce it (paper does not mention how, so I took a guess).

Next is the initial edge detection using the Sobel filter outlined. This produces an image similar to the ones presented in figure 6 of the paper.

And finally, the remove the "weak edges" they apply adaptive thresholding using a 20x20 window. Here is where things go wrong .

As you can see, it does not function properly, even though I am using their stated parameter values. Additionally I have tried:

• Changing the beta parameter.
• Use a 2d int array instead of Bitmap objects to simplify creating the integral image.
• Try a higher Gamma parameter so the initial edge detection allows more "edges".
• Change the window to eg 10x10.

Yet none of the changes made an improvement; it keeps producing images as the one above. My question is: what am I doing different than what is outlined in the paper? and how can I get the desired output?

Code

The (cleaned) code I use:

public int[][] toGrayscale(Bitmap bmpOriginal) {

    int width = bmpOriginal.getWidth();
    int height = bmpOriginal.getHeight();

    // color information
    int A, R, G, B;
    int pixel;

    int[][] greys = new int[width][height];

    // scan through all pixels
    for (int x = 0; x < width; ++x) {
        for (int y = 0; y < height; ++y) {
            // get pixel color
            pixel = bmpOriginal.getPixel(x, y);
            R = Color.red(pixel);
            G = Color.green(pixel);
            B = Color.blue(pixel);
            int gray = (int) (0.2989 * R + 0.5870 * G + 0.1140 * B);
            greys[x][y] = gray;
        }
    }
    return greys;
}

The code for edge detection:

private int[][] detectEges(int[][] detectionBitmap) {

    int width = detectionBitmap.length;
    int height = detectionBitmap[0].length;
    int[][] edges = new int[width][height];

    // Loop over all pixels in the bitmap
    int c1 = 0;
    int c2 = 0;
    for (int y = 0; y < height; y++) {
        for (int x = 2; x < width -2; x++) {
            // Calculate d0 for each pixel
            int p0 = detectionBitmap[x][y];
            int p1 = detectionBitmap[x-1][y];
            int p2 = detectionBitmap[x+1][y];
            int p3 = detectionBitmap[x-2][y];
            int p4 = detectionBitmap[x+2][y];


            int d0 = Math.abs(p1 + p2 - 2*p0) + Math.abs(p3 + p4 - 2*p0);
            if(d0 >= Gamma) {
                c1++;
                edges[x][y] = Gamma;
            } else {
                c2++;
                edges[x][y] = d0;
            }
        }
    }
    return edges;
}

The code for adaptive thresholding. The SAT implementation is taken from here :

private int[][] AdaptiveThreshold(int[][] detectionBitmap) {

    // Create the integral image
    processSummedAreaTable(detectionBitmap);

    int width = detectionBitmap.length;
    int height = detectionBitmap[0].length;

    int[][] binaryImage = new int[width][height];

    int white = 0;
    int black = 0;
    int h_w = 20; // The window size
    int half = h_w/2;

    // Loop over all pixels in the bitmap
    for (int y = half; y < height - half; y++) {
        for (int x = half; x < width - half; x++) {
            // Calculate d0 for each pixel
            int sum = 0;
            for(int k =  -half; k < half - 1; k++) {
                for (int j = -half; j < half - 1; j++) {
                    sum += detectionBitmap[x + k][y + j];
                }
            }

            if(detectionBitmap[x][y] >= (sum / (h_w * h_w)) * Beta) {
                binaryImage[x][y] = 255;
                white++;
            } else {
                binaryImage[x][y] =  0;
                black++;
            }
        }
    }
    return binaryImage;
}

/**
 * Process given matrix into its summed area table (in-place)
 * O(MN) time, O(1) space
 * @param matrix    source matrix
 */
private void processSummedAreaTable(int[][] matrix) {
    int rowSize = matrix.length;
    int colSize = matrix[0].length;
    for (int i=0; i<rowSize; i++) {
        for (int j=0; j<colSize; j++) {
            matrix[i][j] = getVal(i, j, matrix);
        }
    }
}
/**
 * Helper method for processSummedAreaTable
 * @param row       current row number
 * @param col       current column number
 * @param matrix    source matrix
 * @return      sub-matrix sum
 */
private int getVal (int row, int col, int[][] matrix) {
    int leftSum;                    // sub matrix sum of left matrix
    int topSum;                     // sub matrix sum of top matrix
    int topLeftSum;                 // sub matrix sum of top left matrix
    int curr = matrix[row][col];    // current cell value
    /* top left value is itself */
    if (row == 0 && col == 0) {
        return curr;
    }
    /* top row */
    else if (row == 0) {
        leftSum = matrix[row][col - 1];
        return curr + leftSum;
    }
    /* left-most column */
    if (col == 0) {
        topSum = matrix[row - 1][col];
        return curr + topSum;
    }
    else {
        leftSum = matrix[row][col - 1];
        topSum = matrix[row - 1][col];
        topLeftSum = matrix[row - 1][col - 1]; // overlap between leftSum and topSum
        return curr + leftSum + topSum - topLeftSum;
    }
}

Answer 1

Marvin provides an approach to find text regions. Perhaps it can be a start point for you:

Find Text Regions in Images: http://marvinproject.sourceforge.net/en/examples/findTextRegions.html

This approach was also used in this question:
How do I separates text region from image in java

Using your image I got this output:

Source Code:

package textRegions;

import static marvin.MarvinPluginCollection.findTextRegions;

import java.awt.Color;
import java.util.List;

import marvin.image.MarvinImage;
import marvin.image.MarvinSegment;
import marvin.io.MarvinImageIO;

public class FindVehiclePlate {

    public FindVehiclePlate() {
        MarvinImage image = MarvinImageIO.loadImage("./res/vehicle.jpg");
        image = findText(image, 30, 20, 100, 170);
        MarvinImageIO.saveImage(image, "./res/vehicle_out.png");
    }

    public MarvinImage findText(MarvinImage image, int maxWhiteSpace, int maxFontLineWidth, int minTextWidth, int grayScaleThreshold){
        List<MarvinSegment> segments = findTextRegions(image, maxWhiteSpace, maxFontLineWidth, minTextWidth, grayScaleThreshold);

        for(MarvinSegment s:segments){
            if(s.height >= 10){
                s.y1-=20;
                s.y2+=20;
                image.drawRect(s.x1, s.y1, s.x2-s.x1, s.y2-s.y1, Color.red);
                image.drawRect(s.x1+1, s.y1+1, (s.x2-s.x1)-2, (s.y2-s.y1)-2, Color.red);
                image.drawRect(s.x1+2, s.y1+2, (s.x2-s.x1)-4, (s.y2-s.y1)-4, Color.red);
            }
        }
        return image;
    }

    public static void main(String[] args) {
        new FindVehiclePlate();
    }
}