Skew angle detection on a image with scattered characters

问题

I've been following this tutorial to get the skew angle of an image. It seems like HoughLinesP is struggling to find lines when characters are a bit scattered on the target image.

This is my input image:

This is the lines the HoughLinesP has found:

It's not really getting most of the lines and it seems pretty obvious to me why. This is because I've set my minLineWidth to be (size.width / 2.f). The point is that because of the few lines it has found it turns out that the skew angle is also wrong. (-3.15825 in this case, when it should be something close to 0.5)

I've tried to erode my input file to make characters get closer and in this case it seems to work out, but I don't feel this is best approach for situations akin to it.

This is my eroded input image:

This is the lines the HoughLinesP has found:

This time it has found a skew angle of -0.2185 degrees, which is what I was expecting but in other hand it is losing the vertical space between lines which in my humble opinion isn't a good thing.

Is there another to pre-process this kind of image to make houghLinesP get better results for scattered characters ?

Here is the source code I'm using:

#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;


static cv::Scalar randomColor( cv::RNG& rng )
{
  int icolor = (unsigned) rng;
  return cv::Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
}

void rotate(cv::Mat& src, double angle, cv::Mat& dst)
{
    int len = std::max(src.cols, src.rows);
    cv::Point2f pt(len/2., len/2.);
    cv::Mat r = cv::getRotationMatrix2D(pt, angle, 1.0);

    cv::warpAffine(src, dst, r, cv::Size(len, len));
}

double compute_skew(cv::Mat& src)
{
    // Random number generator
    cv::RNG rng( 0xFFFFFFFF );

    cv::Size size = src.size();
    cv::bitwise_not(src, src);
    std::vector<cv::Vec4i> lines;
    cv::HoughLinesP(src, lines, 1, CV_PI/180, 100, size.width / 2.f, 20);
    cv::Mat disp_lines(size, CV_8UC3, cv::Scalar(0, 0, 0));
    double angle = 0.;
    unsigned nb_lines = lines.size();
    for (unsigned i = 0; i < nb_lines; ++i)
    {
        cv::line(disp_lines, cv::Point(lines[i][0], lines[i][1]),
                 cv::Point(lines[i][2], lines[i][3]), randomColor(rng));
        angle += atan2((double)lines[i][3] - lines[i][1],
                       (double)lines[i][2] - lines[i][0]);
    }
    angle /= nb_lines; // mean angle, in radians.

    std::cout << angle * 180 / CV_PI << std::endl;

    cv::imshow("HoughLinesP", disp_lines);
    cv::waitKey(0);

    return angle * 180 / CV_PI;
}
int main()
{
    // Load in grayscale.
    cv::Mat img = cv::imread("IMG_TESTE.jpg", 0);
    cv::Mat rotated;
    double angle = compute_skew(img);
    rotate(img, angle, rotated);
    //Show image
    cv::imshow("Rotated", rotated);
    cv::waitKey(0);
}

Cheers

回答1:

I'd suggest finding individual components first (i.e., the lines and the letters), for example using cv::threshold and cv::findContours.

Then, you could drop the individual components that are narrow (i.e., the letters). You can do this using cv::floodFill for example. This should leave you with the lines only.

Effectively, getting rid of the letters might provide easier input for the Hough transform.

回答2:

Try to detect groups of characters as blocks, then find contours of these blocks. Below I've done it using blurring, a morphological opening and a threshold operation.

Mat im = imread("yCK4t.jpg", 0);
Mat blurred;
GaussianBlur(im, blurred, Size(5, 5), 2, 2);
Mat kernel = getStructuringElement(MORPH_ELLIPSE, Size(3, 3));
Mat morph;
morphologyEx(blurred, morph, CV_MOP_OPEN, kernel);
Mat bw;
threshold(morph, bw, 0, 255, CV_THRESH_BINARY_INV | CV_THRESH_OTSU);
Mat cont = Mat::zeros(im.rows, im.cols, CV_8U);
vector<vector<Point>> contours;
vector<Vec4i> hierarchy;
findContours(bw, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
for(int idx = 0; idx >= 0; idx = hierarchy[idx][0])
{
    drawContours(cont, contours, idx, Scalar(255, 255, 255), 1);
}

Then use Hough line transform on contour image. With accumulator threshold 80, I get following lines that results in an angle of -3.81. This is high because of the outlier line that is almost vertical. With this approach, majority of the lines will have similar angle values except few outliers. Detecting and discarding the outliers will give you a better approximation of the angle.

HoughLinesP(cont, lines, 1, CV_PI/180, 80, size.width / 4.0f, size.width / 8.0f);

来源：https://stackoverflow.com/questions/28525218/skew-angle-detection-on-a-image-with-scattered-characters

标签

c++

image

OpenCV

image-processing

skew