Scan Business Card Tesseract and Leptonica iOS

Question

I am trying to scan a business card using tesseract OCR, all I am doing is sending the image in with no preprocessing, heres the code I am using.

 Tesseract* tesseract = [[Tesseract alloc] initWithLanguage:@"eng+ita"];
tesseract.delegate = self;
[tesseract setVariableValue:@"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@.-()" forKey:@"tessedit_char_whitelist"];

[tesseract setImage:[UIImage imageNamed:@"card.jpg"]]; //image to check
[tesseract recognize];

 NSLog(@"Here is the text %@", [tesseract recognizedText]);

Picture of card

This is the output

As you can see the accuracy is not 100%, which is not what I am concerned about I figure I can fix that with some simple per-processing. However if you notice it mixes the two text blocks at the bottom, which splits up the address, and possibly other information on other cards.

How can I possibly use Leptonica(or something else maybe OpenCV) to group the text somehow? Possibly send regions of text on the image individually to tesseract to scan? I've been stuck on this problem for a while any possible solutions are welcome!

Answer 1

I would recommend using an algorithm called "Run Length Smoothing Algorithm" (RLSA). This algorithm is used in a lot of document image processing systems, though not every system expose it as part of its API.

The original paper was published in 1982 and requires payment. However, the same algorithm is cited by many other papers on document image processing, where you can easily find implementation details and improvements.

One such paper is this: http://www.sciencedirect.com/science/article/pii/S0262885609002005

The basic idea is to scan the document image row by row, recording the width of the gaps between letters.

Then, nearby text characters can be combined by filtering on the width of the gaps, and setting small gaps to the same color as the text. The result will be large connected components that represent:

• Words,
  • By closing the gaps between characters,
• Text lines,
  • By closing the gaps between words, and
• Paragraphs
  • By scanning column by column and then closing the vertical gaps between text lines.

If you do not have access to any document image analysis libraries that expose this functionality, you can mimic the effect by:

• Using morphological operations (morphological closing), and then
• Perform connected-component labeling on the result.

Most image processing libraries, such as OpenCV, provides such functionality. It might be less efficient to take this approach because you will have to re-run the algorithm using different text gap sizes to achieve the different levels of clustering, unless the user provides your application with the text gap sizes.

Answer 2

I think you've hit on a fundamental problem with OCR - printed designs of this type use white space as meaningful delimiters, but the OCR software doesn't/can't understand that.

This is just a wild stab in the dark, but here's what I would try:

Starting in the upper left, build a box perhaps 1-5% of the size of the whole image. Send that to OCR, and see if you get what looks meaningful back. If not, expand until you get something.

Once you have something, start expanding the block in reasonable units until you stop getting new data back. You can, hopefully, decide this point is "meaningful white space", and now you can consider this processed text as "one block" and thus complete. Now start with whatever the next unprocessed part of the image is, and thus work your way through until you've got the whole image complete.

By working with a set of interlinking expanding boxes, the hope is you'll only get meaningful blocks of data grouped together. Working with your example, once you isolate the logo and process it (and the resulting gibberish), the next box will start with, say, the "N" in Noah. Then you expand out to the right until you've gotten the whole name.

With this done you go again and, hopefully, you'll get a bounding box that includes the "A" in Associate, and get that whole line.

A pixel at a time this would take too long with all those runs to the OCR, I'm sure, but there will surely be a trade-off in "size of chunks to expand per interval" and "amount of processing required".

I don't see why this approach wouldn't work for relatively normal print designs, like a regular style business card.

Answer 3

You can try HOCRText which return all the scanned words along with frame of each word in that image as an xml.

char *boxtext = _tesseract->GetHOCRText(0);

You can parse that xml to get each word and its frame. Else if you need you can mention the frame in image which should tesseract scan.

_tesseract->SetRectangle(100, 100, 200, 200);

Set this frame before you call recognise. So tesseract will scan only that frame and return text at that frame.

Answer 4

There is a sample iOS application on Github that does this which might be helpful for you:

https://github.com/danauclair/CardScan

How does he read the business card? He writes the following, (or you can read it in the file: https://github.com/danauclair/CardScan/blob/master/Classes/CardParser.m )

//  A class used to parse a bunch of OCR text into the fields of an ABRecordRef which can be added to the 
//  iPhone address book contacts. This class copies and opens a small SQLite databse with a table of ~5500
//  common American first names which it uses to help decipher which text on the business card is the name.
//
//  The class tokenizes the text by splitting it up by newlines and also by a simple " . " regex pattern.
//  This is because many business cards put multiple "tokens" of information on a single line separated by 
//  spaces and some kind of character such as |, -, /, or a dot.
//
//  Once the OCR text is fully tokenized it tries to identify the name (via SQLite table), job title (uses 
//  a set of common job title words), email, website, phone, address (all using regex patterns). The company
//  or organization name is assumed to be the first token/line of the text unless that is the name.
//
//  This is obviously a far from perfect parsing scheme for business card text, but it seems to work decently
//  on a number of cards that were tested. I'm sure a lot of improvements can be made here.